Here is a simple example of serializing some things into a buffer:

(make-enum-serializer :opcode (:login :run :jump :logout))
(make-bitfield-serializer :login-flags (:hidden :stay-logged-in))
 
(serialize* (:opcode :login
             :uint32 sequence-number
             :login-flags '(:hidden)
             :string login-name
             :string password) buffer)

You can unserialize those bits into existing places:

(let (opcode sequence-number flags login-name password)
  (unserialize* (:opcode opcode
                 :uint32 sequence-number
                 :login-flags flags
                 :string login-name
                 :string password) buffer)
  ...)

You can unserialize them into newly-created variables for use within a body:

(unserialize-let* (:opcode opcode
                   :uint32 sequence-number
                   :login-flags flags
                   :string login-name
                   :string password) buffer
  ...)

Or, you can unserialize them into a list:

(let ((parts (unserialize-list* (:opcode 
                                 :uint32
                                 :login-flags
                                 :string
                                 :string) buffer)))
  ...)

You can find out more about the serialization library on my unet page.

Growl is incredibly useful for any program that operates asynchronously with the user. If you want to be notified when some portion of your job completes or when there is a critical error in your web application, Growl is a great tool to have at your disposal.

I wrote an implementation for Common Lisp of the client protocol. Here is a simple example of how you might use it:

(let ((growl:*growl-default-app* "My Lisp Application")
      (growl:*growl-default-host* "localhost")
      (growl:*growl-default-password* "my-growl-password"))
  (growl:register :enabled (list "Warn" "Error")
                  :disabled (list "Info"))
  (growl:notify "Program starting up..." 
                :notification "Info")
  (unless (connect-to-database ...)
    (growl:notify "Cannot connect to database!" 
                  :title "Critical Error!"
                  :notification "Error"
                  :sticky t
                  :priority 2)))

For more complete usage information and to learn how to obtain the library, see the CL-Growl web page.

Here is the Parser Generator home page.

The KPs have been beating on your base all week. Your defenses are just about to collapse. In fact, your mortar cannons are both on the fritz. Billy Bob, the ACME Repair Guy, has just gotten one of your mortar cannons back online. Unfortunately, he had to wire things a little wonky. Your cannon is spinning all on its own. You’ve only got one button to control both the elevation of the cannon and when to fire it. And, you better fire it, because the KPs are still coming at you.

Inspiration

A few years ago, I read the book Game Design Workshop: Designing, Prototyping, and Playtesting Games. One of the exercises in the first chapter is to design a game with a “one-button interface”. At the time, I didn’t come up with anything particularly thrilling.

When I started brainstorming what to do for this Game Challenge, I remembered that exercise. I came up with this concept just under (as in 3.5 hours under) seven days ago. The game is nowhere near as polished as I’d like… but it was a 7-day thing. And, it was fun to take a break from Objective C to get back to some Lisp programming.

Obtaining It

You can find out more about the game, including where to get the source and a Mac OS X binary, on the game’s web page.

I liked the effect, but I didn’t want the tedium of having to do all n steps manually next time I go to use it. So, I wrote a GIMP plugin script to do it.

Here is an example of the plugin script in action. As you can see, I started with a text layer and a selection that was bigger than the text layer. The plugin uses the selection size as original edge of the paper (original, as in before the paper was burned).

And, here is the resulting image:

Here is the Burnt Paper plugin script. Plop this in a directory that’s in your script search path and refresh GIMP’s scripting and then you’ll find it in the Filters > Decor menu. [You can see the script search path by going to Edit > Preferences and selecting Scripts under Folders in the left sidebar. And, you can refresh the scripts by going to Filters > Script-Fu > Refresh Scripts.]

The first five respondents to this article will receive a Promotional Code to download the app for free! (Edit: all promo codes dished out… if you really want one and will publicly review my app in your blog, I’ll dig up another promo code for you.)

Features

• Kid-friendly interface! Just pick the letters you want!
• Guides your child to the proper spelling of each word.
• Adapts to your child! Cards that consistently give your child trouble show up more often.
• Support for English, Spanish, and French! (German and Japanese Kana coming soon)
• Lots of words to learn (with more coming soon).
• Three different skill levels to challenge your kid!
• Exercise some or all of the categories: Numbers, Colors, Foods (with more coming soon).

The Lisp code that I used in that article didn’t actually use Fast Fourier Transforms. To test the commentors’ claims, I needed an FFT library in Lisp. I searched around a bit and found an FFI (Foreign Function Interface) wrapper around the FFTW library. After fiddling with that library and the wrapper for about two hours, I bailed on it and wrote my own Fast Fourier Transform library entirely in Lisp.

More information as well as links to getting the code are here: nklein / Software / CL-FFT.