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.

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)

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.

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!

This means that instead of:

* (xrpc:call "http://localhost:8080/RPC2" "addNumbers" '(1 2 3.0)) ; WRONG

You get to do this:

* (xrpc:call "http://localhost:8080/RPC2" "addNumbers" '(:integer 1
                                                         :double 2
                                                         :double 3.0))
6.0

This doesn’t look vastly superior, but consider this case:

* (xrpc:call "http://localhost:8080/RPC2" "weekDay" `(:time ,(get-universal-time)))
0

Where before, you had to construct an xml-rpc-date structure; ew. This also allows nicer handling of (unsigned-byte 8) vectors (you can base64-encode them now), and you don’t have to construct yucky xml-rpc-struct objects anymore: just use alists. The decoding functions now return the type tag that they saw in the response or request.

Speaking of requests, the server is now finished, lifting CXML-RPC to more or less the same level as s-xml-rpc. It implements the introspection functions specified in xmlrpc-c’s documentation, and the faults_interop spec. You can define methods for different handlers, which means that you can attach more than one handler to different URLs and they can expose different sets of methods to the world. This might be handy for those running virtual hosts.

In response to yesterday’s post, Rafal Strzalinski pointed me at Ivan Boldyrev’s s-xml-rpc-hunchentoot, which adapts the s-xml-rpc server functions for use with hunchentoot’s handlers. There’s no port to DRAKMA for the client part.

I think you should give CXML-RPC a try if you either want to expose multiple sets of methods on different handlers, or you don’t want to install aserve just for an xml-rpc client. (-:

So I re-implemented s-xml-rpc’s client part to use the libraries that are already available in clbuild, and got a pretty pleasant-to-use library. To simply invoke an xml-rpc method, use:

* (xrpc:call "http://betty.userland.com/RPC2" "examples.getStateName" '(:integer 41))
"South Dakota"

* (xrpc:call "http://time.xmlrpc.com/RPC2" "currentTime.getCurrentTime" ())
#<CXML-RPC::XML-RPC-DATE 20071202T06:56:43>

It’s entirely undocumented right now, and some names (and interfaces) may be subject to change, but I’m making it available now anyway, at my git repository.

The plans for the near future (e.g. next weekend) include a server part based on Hunchentoot, and, um, test cases and documentation. Stay tuned!

Now I’m hacking on a sweet new project again (news about that in due time, I promise). In the meantime, I started a new (lighter on the technical content, heavier on the pop cultural stuff) tumblelog at http://mublag.boinkor.net/. This one’s powered by Soup, a new blogging platform that two friends of mine are just launching.

Right. More technical content will happen in a few days. Until then, don’t look at the Unicorn baby link.

Here’s a selection of the things that I think would be good candidates for review in a new version of ASDF (bsdf? yasdf? qwer? /.,m?):

So. I’m not sure if a blog post is the correct medium for this, but I somehow find this more suitable than a mail to cclan-devel. If you’ve got comments, do blog them yourself or send me an e-mail. (Disclaimer: This is what I consider important. More ASDF-wise people might have more insight into this topic. I’ve just been thinking about them for quite some time, and just recently came up with the right words.)

• PGP key signatures are useless, because a signature on a key doesn’t tell you anything about the standards that were used to get the key owner’s identity to the signing party.
• CACert are trying to get a WebTrust-compatible audit. From what I heard at the talk, instead of being audited for the first time, they worked with the auditors to get into auditable shape (with the same auditor) next year. That sounded kinda familiar to me…

Anyway, after the talk ended (which was cut short at 2:00h by a person who graciously stepped in as a moderator), the assurance thing itself was kind of anticlimactic: There were ~20 people present; everyone was told to get 10 forms, fill them out, and get assured by (and assure themselves) three people who are Assurers, then repeat the process with seven others. Nobody knew who of the attendees were assurers. I don’t think the guy who held the talk understood what I was trying to get at when I suggested that this was kinda suboptimal. Frustrated at the lack of a response when I asked him if he himself was an assurer, I left.

I feel like I just wasted (and not in a good way) two hours. I applaud cacert.org’s server and client certification services (and I’ll continue to use them), but I’ll gladly forfeit the 100 assurance points that state my ability to sit through 2 hours of boredom and to defy bad organization at an assurance meeting. Give me a useless (but non-boring) PGP key-signing party in a cafe or a pub any day.

CLAPPA is the project I submitted for funding to the Google Summer of Code, which is now being funded by clozure. The main idea behind the project is to have a package repository for asdf-install that presents information more nicely than does cliki. When I talked about doing something like this project on #lisp, Nicolas Lamirault spoke up and told me he had something that was part of the way there already — CLAPPA.

The goals of this project include checking for common maintainer errors when uploading a released package, and having a bit more machine/human-processable metadata available. This metadata will include dependencies between packages (already done in the original CLAPPA, but loads arbitrary code), versions with release dates (already done, just need all of the packages on cliki.net), and possible naming conflicts (think of the CFFI-UFFI-COMPAT system in CFFI). Some other sweet features will include an atom (or rss) feed for new releases, and for new releases that are dependencies of a given package, to help maintainers keep track of which updates may have broken their packages.

To draw the outline of this project a bit more clearly, here’s what this project is not about:

• Dubious security features. This is not intended to be a repository of guaranteed-safe code. (Who’d guarantee we’re honest?) CLAPPA is going to protect itself against malicious code, but its users must take care to protect themselves.
• Configuration management in the style of cl-librarian. This might be done in the future, but for now the focus is on getting a useful package repository going.
• Versioned dependencies in ASDF or getting packages from DARCS. This is another interesting addition for the future. Again, the focus is on an asdf-install compatible package repository, for now.

I’ve set up a wiki to track development progress at http://clappa-wiki.boinkor.net/ (need to be logged in to edit), and you can read the original google project submission at this lisppaste.

Here’s a list of half-to-fully-baked ideas that I’m going to explore in the near future:

• First of all, the CLAPPA, the CL APPlication Archive (link may be down due to my hacking on it) project got funding. The LispNYC breakout group rated it high for google Summer of Code, but then Marco Baringer told me Clozure would be interested in funding this. There was so much interest in fact, that they decided to go ahead and really fund this project, thus freeing one SoC slot for another project! (More on that later.)

• If one were to write a somewhat backwards-compatible pathname system for CL (ahem), one could do worse than try and do translation to CL-structured pathnames by putting a translator object into the :HOST slot of the CL pathname. There would still be murkiness w.r.t. merging and creation of new pathnames, but at least it’d have a slight chance of working. Hm.

• McCLIM’s CLIM Listener doesn’t yet have a remote interface to lisps like slime does. One thing that would be neat is real remote lisp communication via the SWANK protocol. The other thing is extending that protocol to transport presentations and graphics in addition to text, maybe similar to what display postscript does.

• McCLIM currently has a few problems when running in multiple application frames: Each frame has its own command loop with its own input context, so when an application in frame A decides to accept something, and the user clicks on an object of that type in frame B, it’s not entirely clear into which input context the object should go (and if it should be highlighted/clickable at all). An idea was to have an input context switcher widget that knows about the input contexts of all active application frames.

• asdf-dependency-grovel should separate dependencies at compile time and ones at load time. This sounds like it’s easy to do, but I’m sure there are going to be surprises.

• I want an Azul machine to play with. They sound horrendously over-powered, but I bet they’re the best platform to run ABCL on. (-:

The setup

I had chosen the worst possible time to fly: a 23:45 (local time) arrival on Saturday guaranteed that I would have to wait 1 hour for the last bus to Cambridge, then arrive there at around 2:00. One bus broke down before that journey started, and a longer-than-expected walk across Cambridge later (which was packed full with drunk english teenagers — one of them was trying to beat up buildings!), I finally entered the land of Nod at around 3:30.

Tutorials

I managed to wake up on time for breakfast, after which the tutorials started. I stayed on Edi’s Hunchentootorial until the second break, then switched, intrigued by rumors about CMUCL internal discussion, to the MPS thing. The afternoon, I stayed on Duane’s Allegro CL debugging/optimization tutorial. From this one, I took away a few neat things to do in an ACL instance when things are bad. At the end, there was an interesting discussion about memory management techniques (which were to be repeated during Jans Aasman’s talk on the last day). I had dinner at a great Indian place with a crowd of people whose names and faces were forgotten due to me being horribly tired. I think Luke was there. I fell into bed at 10pm and slept for a good, long time.

Favorite quote from Sunday’s sessions (Duane Rettig):

Paul Dietz’ test suite doesn’t look kindly to adding arguments to standard functions.

It doesn’t stop us from doing so, but it does give me pause.

The talks

The days of the talks are a blur. Things that stuck were:

• The weird context switch performed during Herbert Stoyan’s talk - From EVAL/APPLY history to code identity transforms in under one minute. (With unbalanced parens on the first such slide. Ow.)

• That, upon hearing about ESA, people seem to worry about compatibility with Emacs applications (don’t worry, Christian, you were not the only one). Guys, an editor’s text buffers are not ideal places for an interactive user interface, however compelling the idea might have been in the seventies.

• There was a great debate whether a creative angle for teaching CS (as exhibited by Alexander Repenning’s XMLisp method) was superior to the entirely technological (some might say technocratic) method employed by Queinnec. As Queinnec’s approach seems to balance out genders, scales to large numbers of students, and compensates for not-entirely-motivated teaching personnel, I, personally, am slightly in favor of doing things in the first semesters his way.

• Had a slight case of reality distortion when, during Michael Sperber’s presentation, there erupted a discussion about square brackets. A discussion about square and round brackets. At a Lisp conference.

• Felt slightly peeved by Antonio Menezes Leitao’s motivational (“pessimistic”) pep-talk, which postulated that lisp libraries are poorly documented, badly tested and don’t solve the whole problem. While technically impressive, his translator from Java to CL also creates badly-documented libraries (#| |#-style comments instead of docstrings because they clutter up the code), which fail tests, and don’t solve the whole problem any more than do the Java libs. On the plus side, widespread use of this translator could mean a surge in cool lisp code refactoring tools, and I’d like to see that.

• Props to Cyrus for blatantly ignoring the timekeeper. Those 10 (13, actually) lessons for lisp would have been a great topic for an invited talk, it’s too bad he had so little time to expand on them.

• Charlotte Herzeel’s talk was an eye-opener for me and (it seems) many others who hadn’t thought much about AOP before. Declarativeness for application behavior descriptions = win.

• Was impressed that not once in his talk did Andrew Borden utter the word “Lisp” or anything related to it. People with more mathematical skills than me might have gotten something from it.

• The ALU meeting. This was a once-in-a-lifetime experience, in that I don’t want to attend one ever again. Interesting fact: The ALU board had 10 members (not sure how many there are after the election). It must be hard to coordinate so many people. Do you need all of ten to maintain an association whose stated purpose is organizing ILCs?

• The Banquet was pretty great. Lots of fun was had, in addition to very good food. I sat next to Richard Jones, but was too awed to talk much about things of importance with him. I hear Juho did bounce some ideas off him later on, which is good.

• Deeply impressed by HOP. Also, amused that Serrano, as a french native, chose a name that starts with #\H.

• Happy that more vendors are enthusiastic about extensible sequences. Heads up to would-be improvers of Common Lisp: it’s possible to add good things to CL that don’t add (much) incompatibility with the spec, but retain usefulness. Looking forward to a CDR document.

After the conference

On Wednesday, Nick announced that there would be four places on the Bus tour to Anglesey Abbey and Ely were available and already paid for; that was too good an opportunity to pass on. (I later learned that one of the places was Patrik’s, which means I’ll have to invite him to a few drinks at the metalab in exchange. (-:)

Also, on Wednesday evening, Robert Strandh organized a dinner for Nick and a few others at Hotel Felix, for the invitation to which I’m very grateful. Great conversation was had, along with very tasty food, and a lot of (I hear) good wine. (-:

Both Anglesey Abbey and Ely (Thursday) were remarkably beautiful (the great weather didn’t hurt, either). Also, our tour guide managed to keep us all awake on the bus to and from each place with stories about each place, which I think was no small feat. Some photos of this tour are available on the ilc07 flickr group.

After the tour, Nick announced that one more place in a punt was available. As nobody else was interested, I gladly took that place, too, and had a great ride, taking pictures until the camera’s battery died. Unfortunately, I didn’t make it to the appointed place at the appointed time in order to meet Robert, Cathleen and Cyrus for dinner that evening. Too bad, I hear it was really good.

Finally, Friday was a day of packing stuff and walking around Cambridge taking more photos (some of which I might upload later), and flying home. Of special remarkability, I think, are photos of a shop called “TOTAL IT SOLUTIONS” (not an insurance provider), and of a poster announcing Cambridge Stammering Open Day, which I think will finally establish Cambridge as the perfect place to hold conferences on speech impediments.