In October, I will be moving to California to work for a hugely awesome lisp company there.

Exciting and excellent times ahead, I’m sure!

I’ve been toying around with making a Common Lisp adapter to Cucumber, a behavior-driven development tool. I think this will really be very sweet.

Here’s how the step definition file would look like (these are really just stubs; in reality, you’d put in the lisp code you want to happen for the given textual description):

1
2
3
4
5
6
7
8

(Given* #?"^I start clucumber in (.*)$" (path)
  (assert path))

(When* #?"^I define some-other-package as the test package$" ()
  (pending))

(Then* #?"^the current package should be \"([^\"]+)\"$" (package-name)
  (pending (format nil "package is ~A" package-name)))

Date: Saturday, 2010-02-27
Time: 12:30 Venue: In and around the Metalab, Rathausstrasse 6, Vienna (map)

I’m pleased to announce the first international totally informal lisp meeting in Vienna. A bunch of Lisp hackers are coming to here on the 27th, and we will meet, talk and hack in and around the Metalab.

The approximate schedule is as follows:

12:30 - Lunch at Fromme Helene. There is a table reserved for 15 persons (we’re 5 confirmed hackers at the moment). If you want in, drop me a line.
~14:30 - Reconvene at the Metalab for hacking/coffee/cold drinks/(optional) lightning talks

Hackers who have confirmed they’ll be there, so far:

• Tobias C. Rittweiler
• Luke Gorrie
• Stelian Ionescu
• Attila Lendvai
• Gábor Melis
• Mark Evenson

Thanks to the SBCL team for infusing this event with positive energy. SBCL: Harming the software industry since 1999.

Over the weekend, I wrote a little client library to a queue server that I’ve grown very fond of over the last year, beanstalk. It’s a very simple queue server, but it comes with a nice feature (delayed jobs) that I’ve had a use for recently.

The queue server is nicely engineered (written in C, works with queues a few million jobs deep), and very fast; it has guards in the protocol against worker failure, and it was a pleasure to implement: The whole thing is just 320 lines of code, including comments.

You can get the source (and a tiny example) at the cl-beanstalk github repository.

Hope this is useful for anyone else - I am planning on using this in autobench myself, to distribute work across several build hosts.

Today, I submitted a patch (the first free software lisp one in months for me!) to the Hunchentoot project, and it got accepted. Yay!

Some backstory: Hunchentoot’s 1.0.0 release dropped a lot of implementation-dependent features, among them functionality to invoke the debugger if an error happens while handling a request. While workarounds exist, none of them were obvious to new users or users who recently upgraded.

The patch I sent should fix this, hopefully. It adds a rudimentary error handling protocol to Hunchentoot, and provides two generic functions whose behavior can be adapted to your error handling needs. You can see for yourself in Hunchentoot’s svn repository.

If you’re a Hunchentoot user, I urge you to test this (in both development mode using debuggable-acceptor and running with the default settings). The sooner you find bugs, the sooner they can be fixed, the sooner a release can be pushed out. And if you don’t find bugs at all, that’s cool, too (-:

Caching and naming things.

Well, maybe not caching. But if two people are getting married in Austria, they do have to solve the other hard problem. That is, one partner gets to keep their name, and the other partner has to decide what to do:

• Take on the partner’s name (it’s expected that the female partner does this),
• keep one’s old name,
• or prepend or append one’s own name to the partner’s name.

In the latter two cases, Austrian family law introduces a “family name” that is one of the two partners’ original names, which is what they pass on to their children. This makes both options a non-solution: You get your pie, but something else gets eaten: Possibly your sanity.

So, if partners “Fuchs” and “Liewald” were to get married and wanted to use the (wonderfully punny) “Liewald-Fuchs” as both partners’ name and the name that their children get, they would be out of luck. Or so it would seem.

It turns out there might be a way to pull this off. A person who recently got a bit of media attention bearing the last name of “Hollunder-Hollunder” has done this already (but with slightly different starting parameters and a different goal):

1. Get married, prepend/append names such that one partner has the desired combination of names,
2. divorce, arrange that both partners keep the new names,
3. get married again, and have the other partner take on the desired name.

One divorce costs €500, the legal cost for a marriage certificate after a divorce is €70. Might just be worth it (-:

Two weeks ago, the rotary program dial on my dishwasher broke. Luckily, I could fix it with two Lego parts (a Cross Axle #6 and a 16-teeth gear) initially, but the program selection experience suffered from the axle’s being too thin: it’d always bend in the turning direction until the selector would too-rapidly rotate past the point I wanted to select. Ugh.

Luckily for me, there’s a reprap at the Metalab. This is a low-cost 3d printer that can extrude parts made of ABS (the same material that Lego pieces are made of). With the help of Philipp’s MetaCADEvaluator plugin to Art of Illusion (AoI), I managed to create a very nice 3d model of a replacement for the dial. That plugin let me define parameters for each part, so I could easily resize all parts manually once I discovered that I’d mistakenly noted down each part’s diameter instead of the radius. However, this was slightly fiddly business: All editing happens inside Art of Illusion’s part name text fields, the syntax is slightly odd, and you can’t define your own part library.

Enter my urge to try out Clojure. This little side project took three steps:

1. Find out how to embed clojure in AoI (done).
2. Make it open a swank port so I can on AoI from emacs without having to recompile all the time (done).
3. Build a part definition DSL (ongoing, one milestone achieved).

There’s a detailed description of these steps after the jump. Here’s the github project for my AoI clojure plugin.

Embedding clojure inside AoI

This was rather easier than I’d thought. The hardest part was finding out how clojure’s gen-class works so as to generate two classes, one to implement the Plugin interface (so that the plugin gets loaded) and one to implement the Tool interface (so I get a menu entry that lets me start the Swank listener).

After that, it was building an extensions.xml and figuring out how to make ant build a .jar file that AoI could grok (both easy).

Making it open a Swank port

That one was easy, as well: Just add the swank-clojure project as a submodule, and add its sources to the plugin .jar file. Having done that, open a port and add the current window somewhere so we can manipulate objects in it later (source).

So after that, opening the Swank port vie the tool menu let me connect to AoI with emacs and off I went, doing experiments! For all who want to build Art of Illusion plugins with clojure, I’ve made a minimal-plugin branch that does exactly this, available here.

Building a part definition DSL

This one was the biggie: I wanted to write lisp that lets me interactively define 3d models. What is here right now is a little DSL that lets me create simple 3d models, and lets me perform boolean operations on them (union, difference, intersection). This is enough to make this model, which is the exact same part we extruded before.

There are still things left TODO:

• The syntax of the DSL needs more love. It is quite verbose right now.
• Models need relative transformations: witness the “90 0 0” on almost every part.
• For debugging purposes, it would be useful to get a tree of the composite objects (with only the end result visible), instead of just the one result object.

Conclusion

All of this was way easier and far more fun than I’d thought building plugins to java projects could be: I’d gone in expecting something in the order of gratuitously frustrating and mind-numbingly boring. Instead, after I had the first few hurdles out of the way (most of which were rooted in my emacs’s slime config (-:), I was euphoric from regular small successes all the way. As you can tell from the commit history, this took a little over 3 days to build.

I strongly recommend the Clojure and swank-clojure approach to building plugins to java projects: Once you’ve got a Swank listener open, it’s all experimentation and small bits of progress. Excellent stuff, all around.

This isn’t original work, so perhaps more suited to being in my soup than this blog, but it’s so cool it just has to be on Planet Lisp. perfectstorm is:

a real time strategy game study written in Common Lisp using OpenGL for graphics display and cairo for texture generation.

Looks very very interesting. Google SoC students take note: this is an open source project (-:

(found via neingeist)

(This blog entry is outdated. The currently recommended way to get lisp software and its dependencies is quicklisp).

Outdated information

It has been brought to our attention that asdf-install is still thought to be the preferred way to install cool lisp software. I would like to use this space to advertise an alternative tool that too few people know about, and that allows you to almost instantly (OK, as fast as your computer can install the required software and download & build the packages) get you up and running with and get you updates of the newest in cool lisp packages.

That tool is clbuild.

It doesn’t yet bring in all of the software available on cliki, but it includes enough cool things that I would recommend it to anyone who wants to check out with a minimum of hassle either of (not an exhaustive list, but you get the idea):

• McCLIM,
• Climacs, Closure, Beirc, Gsharp,
• Hunchentoot, and
• CXML

Or just get a lisp system up and running that includes most of the useful libraries out there. If you have been messing around with asdf-install (raise hands if you ever asdf-installed a library to get its dependencies and then pulled that library from CVS again and replaced the symlinks manually), do yourself a favour and check it out.

Recently, I got a used Mac Mini from a friend; I decided to put it to good use as a media station in my living room, and it does indeed work pretty well (after fixing it up with codecs that are in use in the real world, but that’s not the topic of this article (-:).

One thing that I find very useful is the ability to import movie files (that one might download from the vast and unfriendly-to-copyright-holders internet, as described here for instance) into iTunes on my desktop mac and have the Front Row thing on the living room machine play them over the network. The steps one needs to take in order to get this working are many and tedious, and so I’ve created an AppleScript to do all the hard work for me. It:

• Converts an .avi movie (they usually come encoded as DivX or Xvid) into a standalone .mov file using Quicktime Player (this doesn’t transcode),
• extracts the Show name, Season, Episode number, Episode name from the file name via a friend’s service called “renamr” (a telnet 2.0 service, he calls it),
• imports the file into iTunes, tags it nicely, and
• cleans up after itself.

The files thus imported will pop up in the nicely remote-controllable interface, marked as “unwatched,” and wait for me to finally get some spare time to sit down and watch them. (Which might very well be after the WGA strike ends, so it all should work out nicely in the end.)

If you find yourself wishing for a similar solution, download this file, read the comments in the beginning, skip over the MIT-style licence, and read the code until you are convinced I’m not doing anything stupid or malicious. Then, have fun using it!