Running primes again was fun. PHP is still quite fast for an interpreted language. Lisp is nicely inbetween VM languages like C# and Java and interpreted languages like PHP. Ruby1.9 is definatly faster than 1.8 but still slower than pretty much everything else (sadly). Nothing really seems to have dramatically noticeably changed. The old stats I generated still seem roughly right-ish. As right as this “benchmark” can be.

A quick benchmark on a Athlon 5200+ sorted by running speed:

Prime number benchmarks
Benchmark machine: Linux 2.6.32-29-generic-pae #58-Ubuntu SMP Fri Feb 11 2011 i686 GNU/Linux

C results:
Compile [gcc]:          0.09 seconds
Execute:                0.60 seconds

x86 Assembly results:
Compile [gcc]:          0.08 seconds
Execute:                0.65 seconds

C++ results:
Compile [g++]:          0.44 seconds
Execute:                0.78 seconds

Haskell results:
Compile [ghc]:          0.85 seconds
Execute:                0.93 seconds

C# (Mono) results:
Compile [mcs]:          0.52 seconds
Execute [mono]:         1.18 seconds

Java results:
Compile [javac]:        1.38 seconds
Execute [java]:         1.55 seconds

Common Lisp results:
Compile [sbcl]:         1.00 seconds
Execute [sbcl]:         3.09 seconds

Erlang results:
Compile [erlc]:         0.54 seconds
Execute [erl]:          5.82 seconds

PHP results:
Execute [php]:          12.0 seconds

PERL results:
Execute [perl]:         14.3 seconds

AWK results:
Execute [awk]:          15.3 seconds

Python results:
Execute [python]:       15.7 seconds

Ruby 1.9.1 results:
Execute [ruby1.9.1]:    32.6 seconds

Ruby 1.8 results:
Execute [ruby1.8]:      73.4 seconds

TCL results:
Execute [tclsh]:        180. seconds

cl-pack covers most of Perl’s pack’s features ignoring as far as I’m concerned only weird esoteric stuff. Granted thats up to interpretation but I am very happy with what cl-pack supports and so I am pushing out 0.2 and calling it “feature complete” unless I hear from anyone soon needing anything or with bugs. If not I’ll rerelease it in a bit as 1.0. It’s a pretty solid piece of work IMHO.

He’d suggested some more radical changes too, the biggest being to turn the two pack/unpack case statements into macro-foo so that I could just go

(define-directive #\i ...)

all on its own. I gave it a good try and pretty much got it working, but it unfortunately spits out about 125 style warnings, increased the code by about 100 lines or ~ 20% and I’m not sure in the end if it really was any clearer, so I scrapped that for now and am just releasing the basic easy changes and moving onto a few more features.

The planned release will be hopefully something like a few more features for 0.2.0 and then if nothing explodes, release it as 1.0 and cl-pack should be done-ish.

cl-pack is a Common Lisp library supplying perl/php/ruby compatible pack() and unpack() functions so that Lisp can easily communicate with those languages via binary protocols or files. pack() and unpack() take Lisp data and pack them into binary strings that can be stored or exchanged safely with other programs. The (un)pack functions are handy utilities that most other common languages support and now so does Lisp.

Cavets: This is the first release, therefor full coverage of all pack() syntax isn’t yet available. Most data type (all common ones) are supported, as are repeaters in the form of numbers and ‘*’. Grouping with brackets and other extended syntax is not yet supported, but should be forthcoming in the next release. Documentation is in cl-pack.lisp and if you want to see what it can do, also look at tests.lisp. cl-pack is ASDF compatible so it should integrate with your system well. It relies on ieee-floats but ships with a copy should your system be lacking one.

You can get it at ftp.mindstab.net/cl-pack

So yeah, this is what I’ve been working on for the past month or so. Glad to get it out. I plan to throw up some small web page for it in a few days and then start working on the remaining syntax support.

Edit: I set up a page for cl-pack at CLiki http://www.cliki.net/cl-pack

I’m playing with a new RPC framework that doesn’t have Lisp support but I’m looking to see if I could add it, and I’ve noticed that because it mainly uses a ‘binary protocol’ that Lisp doesn’t necessarily support binary data types like float much. Or at all. And interestingly (at least to me) Lisp doesn’t seem to have a Perl compatible (and PHP, Ruby, and Python) pack() and unpack() function, which, looking at the code of the implementation of this RPC frame work in all the other languages, is what they use to encode the data.

So I’ve stepped back from that for a moment and am playing around with writing pack() and unpack() functions in Lisp. Through this little side project I’m finally learning a lot more about Lisp packages and ASDF, so it’s been fun so far. Integer support was dead easy to write, but I was dreading groking the ieee float specification enough to try implementing it, but thankfully someone already did and I can make use of the Lisp package ieee-floats for that, so Yay and thanks! And so hopefully soon I’ll have a perl compatible pack() and unpack() set of functions for Lisp.

As a side note, even though it can be frustrating, I really do enjoy hacking away in Lisp, for some reason I just find it fun.