Something fun, then! Normally everything I do is extremely
difficult. A friend of mine who is a self-taught qt expert
showed me a poker game he was making. I decided to have a
quick go at it myself. Now, about a decade ago some friends
of mine got excited about Texas Hold 'em. I've never been
to a casino, and I disapprove of them, but I did play some
(free) poker with my friends and kind of know the rules.

I put my working draft in my common lisp directory,
poker.lisp. It requires #:alexandria, the canonical common
lisp extra-standard common functions. Some highlights that
I found not to be well-documented at various place online
 (why would you even look at the web at this point):

1. Feeding a string into standard input
```
(let ((string 
	(format nil "~@{~a~%~}" "the test" "line strings")))
 (with-input-from-string (*standard-input* string)
	 (print (read-line))
	 (print (read-line))))
```
Remember common lisp has everything: By capturing *standard-
input* with that macro, I have access to lisp's access to
standard input. A related function I didn't use might be:

2. Capturing standard output as a string
```
(let ((string (with-output-to-string (*standard-output*)
	       (apropos 'with-output-to))))
 (print string))
```
Will of course search all visible namespaces for names with
"with-output-to" in them. This, combined with #'documentation
#'describe and #'inspect are handy introspection.

3. Inspecting namespace contents and documentation in lisp
```
(documentation 'documentation 'function)
(documentation '*standard-input* 'variable)
(documentation 'loop 'function)

(inspect '*standard-input*)
(describe '*standard-input*)
```
As seen on 'loop, #'documentation considers a macro as a 
'function. However unstandardized macros with definitions
given by the particular compiler you are using, like
'with-output-to-string are not considered as a 'function
by 'documentation. I would #'macroexpand them and inspect
the component parts, which will be supported by 
'documentation. #'apropos and #'inspect are often useful
for those compiler macros.