Archive for the ‘lisp’ Category

A year of living vi-rously

Tuesday, January 31st, 2012

For reasons which are not apparent* even to myself (although I suspect it had to do with general contrariness mixed with regret for some arrogant comments from the past) I spent 2011 emacs-free. More than that, I spent it using only vi (or, rather, vim) to do my text – including program text – editing. Since I couldn’t get SLIMV to work at the beginning of 2011 – it is in much better shape now – I even gave up the wonder that is Slime/Swank.

I can report that, even for a duffer like me, it is possible to develop very efficiently with vi(m) and a repl running in another terminal. So there, old-splittist!

And just to make sure I’m not making any forward progress, I’ve switched back to emacs for 2012. Now my buffers are full of “jjjj” and “kkkk”…

* I do this a lot, don’t I?


Thursday, February 17th, 2011

Twas a gorgeous day in Zurich leading up the inaugural resurrected Zurich Lisp and Stuff User Group meeting. (Clearly being in the telco business means you can re-order packets and acronyms.) The offices of Teclo were handy to public transport routes, and lightly scattered with expert assembled Swedish furniture and furnished with assembled Swedish experts. (That is, furniture assembled by folks with expertise in things other than assembling Ikea  furniture, some of which, the expertise that is, was gained in Sweden.)

An unexpectedly (to me, at least) large crowd arrived, united in their thirst for things parenthetical and lack of a bottle opener. Luke made good on the second with a deftly wielded business-card case, but they were to be cruelly taunted with respect to the first with Hans Huebner talking about how he didn’t build a Lisp-Machine-on-a-FPGA, and Luke giving a seminar on the performance characteristics of TCP at the interface between the mobile carriers’ networks and the internet at large. (Both very interesting talks, giving rise to some lively question and answer sessions.)

By this time the hour was approaching double figures, which is pretty damn late for the German-speaking part of Switzerland, so a hardy dozen-or-so adjourned to a local tapas bar and convinced the kitchen to feed us on left-over loaves and fishes.

Many thanks to Teclo folks for organizing this meeting. There is a clear and demonstrated need for these sort of get-togethers. Here’s to many more.

(Below a rare photo of Teclo’s Chief Scientist without his hand in the bowl of wasabi peanuts.)

Some of the Teclo team watch as Hans Huebner gives his presentation

Some of the Teclo team watch as Hans Huebner gives his presentation

“Let Over Lambda” by Doug Hoyte – a fawning review

Friday, January 7th, 2011

I have never had as much fun reading a computer language book as I have had reading Doug Hoyte’s “Let Over Lambda“. Some of it was chortling along with his unabashed Common Lisp triumphalism. Some of it was marveling at the (ab)uses to which macros can be put when conventional wisdom is turned on its head. Some of it was being tickled by his wicked choice of names (pandoric macros, flub languages). But mainly it was being propelled through 355 pages of well-paced narrative written with style, vim and brio. (Well, not so much vim as nvi, I imagine.)

This was the first book I ordered from Lulu. The quality of materials and construction seems very good. The colophon says ‘Made with lisp’, and the typography and layout are clear and familiar – ‘HCSW’ and ‘Hoytech’ have done their job well. This LOL is an attractive and pleasantly-sized monograph.

The content is fascinating and deliberately provocative. I found this highly entertaining. It seems, from the ‘Clarifications‘ section Hoyte has felt he has had to add to the book’s site, that others didn’t. Lighten up, guys. If you disagree with something someone says, the remedy is not to shout down the speaker, but to make your own case – more speech, not less. Hoyte says: “If this book has only one purpose, it is to inspire the study and research of macros… I hope readers of this book might also be so inspired that some day I might enjoy even better lisp macro tools and even more interesting lisp macro books.” This theme continues throughout LOL. Take him up on it – I would love to read more books like this one.

“Let Over Lambda” is truffled with interesting observations: macrolet is for codewalking; referential transparency is (usually? often?) a bad thing; there exists sub-lexical scope (and super sub-lexical scopes); opening closures can be fun and profitable. And with thought-provoking constructs: defmacro! and its o!vars and g!vars (which I never got comfortable with, but which I can certainly see having great utility in iterative development); #` (that’s SHARP-BACKQUOTE – which I did get very used to); alambda, dlambda and plambda; with-pandoric. And so much more: declarations, compiler-macros, cons-pools, benchmarking, sorting networks, Forth – and the power of the duality of syntax… There is something to provoke, entertain and ponder on almost every page.

And every few pages Hoyte gives a new name to a phenomenon. Since most of these don’t seem to have a name yet, this is a valuable contribution to the task of exploring and mapping the uncharted spaces of macro combination…

If you can’t bear to have your preconceptions challenged with energy but good humour, don’t buy this book. Otherwise “Let Over Lambda” really deserves a place on your bookshelf.

The Power of Paredit

Thursday, October 1st, 2009

A conversation at ECLM made me look at paredit again. I’ve been consistently using it, but I hadn’t actually been following its evolution. It’s even better than I thought! M-S (look it up) saved me 10 minutes within 60 seconds of noticing it. Even if you’ve been using paredit forever, take another look at what’s available. And if you aren’t using it – WTF? Thank you Taylor ‘riastradh’ Campbell!

eclm09 report

Wednesday, September 16th, 2009

A good time was had by all, including, most importantly, me. The European Common Lisp Meeting has a really nice feel to it, as several people commented to me. Well done Edi and Arthur once again!

The venue was quite stunning, with fabulous views over the Elbe and some of the enormous port. The walking tour on the Saturday was largely interesting (and we didn’t get too wet…). The boat-trip and dinner on the Saturday was fun, too (and we didn’t get wet at all…). The A380 is big. A hangar with multiple A380s is even bigger.

Although not technical, the overall positive theme of the talks – you can actually do something with Common Lisp! – was a refreshing change from the recent “What’s wrong with CL” emphasis. (I’m not saying there shouldn’t be a conversation about CL’s future, just that it shouldn’t be the only topic of conversation.

Dan Weinreb kicked things off with a variation of his Google tech talk. My strong impression was that it featured as a great table-of-contents for a fascinating semester course – which we’re still waiting for. Come on Dan – more! We can take it! He mainly talked about the business rules tier of QRES (the presentation layer being Java and AJAX, the database being Oracle). This is made up of ca. 750k lines of home grown lisp code (including unit tests and tools) and 150k lines of open source libraries (he namechecked Hunchentoot, drakma, usocket, and cffi). There are 50 lispers working on the codebase. Coding standards are important. Code reviews are essential. They’re not completely happy with with the support for large-scale modularity and incremental builds in lisp. Interesting quote: “How to apply experience from previous software projects to new software projects is much more difficult that most people imagine.” Dan finished with three plugs: his CPAN for Lisp proposal; Clojure is interesting; ‘Coders at Work’ is a terrific book.

Paul Tarvydas discussed his Visual Frameworks/CL-VF programming system, which is used in JetLetter, a high performance junk direct mail processor. He made a number of though-provoking claims, including ‘encapsulation should be by process’, ‘we learn from EE that asynchronous components + diagrams = reliable designs’, ‘specialization is better than generalization’, ‘not everything should be a diagram (a = b + c); but not everything can be text (a diagram)’, and my favourite ‘in lisp, refactoring means throwing away the code and starting again; code is cheap, thinking and architecture are hard/expensive’.

Dimitri Simon discussed his Piano product. It was a charming presentation, and it’s easy to see how Dimitri has ended up with every major aeronautical outfit as a customer. The piano system was evolved rather than architected or designed, and has a low 5 figures lines of source code. After sharing the religious experience that was Coral Common Lisp on the Mac II, Dimitri shared some thoughts on lisp from his self-declared ‘non-progammer’s point of view:

  • re-focus on the basics
  • the lisp user audience is not necessarily programmers
  • don’t push lisp features too hard – lisp will stand up on its own once discovered
  • simplicity and stability trump features
  • hide things that are scary (like debuggers and steppers)
  • are editors overloaded? (all you need are indenting, eval, retrieve source…)
  • give lots of examples of saving images and creating apps
  • all that is needed is very elementary graphics (x/y plots; sine waves; not file formats)
  • start at (+ 1 2) not (defun factorial (n)
  • let them make their mistakes (e.g. Fortran mindset)
  • examples, examples, examples

We saw what serious industrial customers demand from the GUI of an application with a 5-6 figure licence fee: fixed-width font text output and simple line graphics.

Michael Wessel discussed RacerPro. He said he’d talk about the role of Lisp if he had time. He didn’t. The semantic web is apparently Web 3.0, and with certain classes of description logics you will be able to draw faulty assumptions about old ladies and cats. Unlike every other presentation there wasn’t even a hint of an actual real-world use.

David McClain told us what had happened to SigLab over the last 2.5 years. Well, it moved from synchronous to asynchronous and became GigaDSP – all the eye-candy and 46k LOC, including a liberal use of CLOS and non-standard method-combinations. But wait – there’s more! There is ButterFLY, the best ideas of Erlang (a weak and primitive language otherwise) translated into 40k lines of lisp code for easy control of distributed computing: software transactional memory for queues and system table updates, but not for everything, and home grown security that is explicitly not OpenSSL. And more! OKeaNOs, a massive distributed object repository with exabyte+ individual file size limits, self-describing objects and self-reliant retrieval. All used for developing and running a 10Gbps radio LAN at 140GHz in the jungles of Vietnam. (Or something.) Interesting observation: when developing you can expect one bug per 10 lines of C code versus 50-100 lines of lisp code.

Hisao Kuroda talked about a bunch of products produced by his team (of 12) Common Lispers. His main observation was that the sheer volume of data now having to be analyzed leads to a requirement for statistical analysis/machine learning/visualization/clustering. He addressed the question ‘Why not R?’ by noting that with their extremely domain-specific solutions they have to get below the level R implements to be able to tweak etc. And, of course ‘you think you know when you can learn … but are certain when you can program’. This led to the question ‘Why Lisp?’, to which the answers were maintainability (on industrial strength implementations), ease of integration, platform independence, and runtime efficiency. But he had some observations for compiler vendors (which I reproduce as verbatim as possible):

  • No CL compiler has standard code optimization
    • constant folding (+ 1 2 3) and (+ 1 n 2)
    • constant propagation (let ((a 1)(b 2))(+ a b))
    • common sub-expression elimination (+ (- x y) (- x y) (- x y))
    • loop optimization
  • SMP
    • SBCL (non-thread safe libraries)
    • LispWorks (alpha)
    • ACL (not at all)
    • F2CL version is slow and buggy
    • displaced array can’t be optimized
    • maybe it’s impossible to beat Intel MKL
  • SSE instruction support

He had a colleague produce a paper on the compiler performance of ACL, LW and SBCL which he will translate from the Japanese and send to the vendors.

And speaking of compiler implementation, Martin Simmons discussed the new SMP features of LispWorks 6. There was a fair amount of detail here, presented in an engagingly low-key way. As someone commented, the key message was ‘don’t use locks’.

Then came the lightning talks. Adlai Chandrasekhar presented sheeple, a prototype-based object system with multiple dispatch, multiple inheritance and a mainly working MOP. Luke Gorrie pointed us to OpenFirmware as a compilation target and/or a source of device drivers. Jeremy Jones demonstrated cross-platform (OSX, Windows, Linux) GUI development using Cocoa (cocotron/GNUStep) and CCL. Nick Levine gave the first of what I imagine will be many talks of his upcoming O’Reilly book ‘Lisp Outside the Box’ aka the Emu book (looks like a dodo but has a hell of a kick?). Stefan Richter tantalised us with his company’s automated software project management AIs ‘The Deadline’ and ‘Captain Feature’, and impressed (me, anyway) with an approach to the business of producing software that actually trusts programmers (and he recommended The Daemon). Tobias Rittweiler highlighted the results of some recent (paid!) work on Slime: improved autodoc highlighting of keywords; support for named readtables; improved hyperdoc support; fancy macroexpansion; and sensible handling of unwound dx objects. Dieter Hoffman presented Preforma – from meaning to machine processing and back; I have no idea.

Most common shout-outs went to LispWorks and Edi Weitz, with SBCL coming in third. The dinner was pleasant. The drinks afterwards were gruelling. I had fun.


Monday, August 31st, 2009

So, I’m going. It seems from this blog that all I do in the Lisp world is attend conferences. Oh well.

The line-up is, as usual, intriguing. I have no idea what to expect from Kuroda Hisao of Mathematical Systems, Inc. David McClain knocked it out of the park last time he spoke, so he might suffer from excessive expectations this time. Martin Simmons of LispWorks is a generally good presenter (I seem to recall). Dimitri Simos is to talk of Piano, which looks interesting, has enviable pricing, and a special secretPaul Tarvydas promises to talk of fun and profit, and who could ask for more. Dan Weinreb will presumably give the convinced lispers version of his tech-talk. And I’ll finally(?) hear about RacerPro from Michael Wessel.

All this without mentioning the traditional ECLM boat trip (sans Kenny this year), dinner and lightning talks. What could go wrong?

P.S. For some reason I’m flying out of Hamburg late afternoon on Monday, so if anyone’s up for lunch that day, let me know.

Old #lisp Logs

Thursday, April 30th, 2009

For reasons which now escape me, I decided at or around ilc09 (how many different abbreviations can I use?) to learn javascript. Someone on #lisp very helpfully said “javascript is scheme”, which was my way in to the language. The baby rhino book from O’Reilly is deeply rubbish. By contrast, the butterfly book, Javascript: The Good Parts by Douglas Crockford, is excellent (thanks, Chris!). And short. Stoyan Stefanov’s Object Oriented Javascript isn’t too bad, either.

So, having discovered the delightful, dynamic, prototype-oriented, functional language hiding inside javascript I have completely ignored what little I’ve learned to scratch an itch of mine – to wit, browsing the #lisp logs from anywhere. After a couple of hours of swearing at $.ajax and mod_rewrite I have oll (see the title of this post) to play with.

ilc11 thoughts

Thursday, April 30th, 2009

I dont know anything about sponsoring (semi)academic conferences, and here is the fruit of my knowledge.

Where the survival of an event depends on its sponsors, then it had better overdeliver to today’s sponsors to ensure there will be some tomorrow. It also helps to be clear about why someone might be interested in becoming (continuing to be) a sponsor. Selling to the people physically at the conference is going to be fairly low down on the list. Making the decision-makers feel good about supporting the lisp community is a perfectly valid reason. So is making employees (current and future) feel good about their employer. This can go further – if competition for talent is tight (think Hyderabad – or the Bay Area – or any top school) a company could distinguish itself as being OK with quirky but seriously powerful stuff by associating itself with Lisp. And if there are other market segments which still have good vibes about Lisp (and let’s face it, a lot of folks think smug lisp weenies have something to be smug about) any organisation interested in those customers would gain from a sponsorship.

As long as the right folks know about the sponsorship. Appearing on the back of the conference program isn’t going to be enough. Of course, much of this is up to the sponsor themselves – they should ‘activate’ the sponsorship by integrating it into their own sales and marketing programs (hence all the ‘a proud sponsor of…’ stuff tacked onto ads). The event can help here by having a nifty logo early enough before the event itself to allow some sort of consumer recognition to develop. The event can also help the sponsors to reach out to (the vast majority of) folks who can’t/won’t attend. A sponsor-recognition strip below the projection screen (and/or on the lectern or the debate table) means all those seeing the talks on youtube (or looking to see what someone they know from irc looks like irl on flikr) will be able to see who supported the event. The AV coverage could even be separately sponsored (“ilc11cast brought to you by NTTDoCoMo, your first choice for a fulfilling engineering career”). And encouraging/providing facilities for podcasts (rooms to interview the celebs etc) would also enable the event to reach out and touch more people than are physically present. (Even something as simple as allowing a sponsor to provide branded lanyards for the badges means that sponsor will appear in every photo and video of the event and its surrounds.)

None of this should be taken as a criticism of ilc09 – I can only imagine the sponsors are very happy to have been associated with such a success. But why keep my ignorance to myself?

Random ilc 2009 thoughts

Thursday, April 30th, 2009

In this age of ubiquitous twitterage a wrap-up of ilc09 (even one as late as this one is) seems not merely self indulgent but positively perverse. In other words, read on!

Overall I thought it was a great success: great venue, great organisation and some great speakers. The only lowlight (for me only) was the banquet, but that was a function of the low price for the event (a good thing in every other way) and the luck of the draw when finding a table.

And now the really random observations. p-cos (Pascal Costanza) is a very good teacher and is posessed of some great insights about the world. In particular he has the ultimate answer to all “how do we make lisp popular” discussions – nobody knows what makes a programming language popular, so all we can do is keep our integrity. (See also William Goldman.) v-diddy (Didier Verna) is also a very entertaining speaker, and someone to keep an eye on. Rich Hickey is a rockstar in spite of himself (who will be next?). I have yet to see an AllegroStore presentation motivated by a real use-case (although I’m sure they exist). The lightning talks were a revelation, kicked off with great energy by Jerry Boetje. Strict time controls, even on longer talks, are vital to keeping the pep in a conference. David Moon was fun. Gerry Sussman would be fun reading the phonebook. The panel session was (predictably) largely a waste of space; the big take-aways for me were (a) Kent Pitman is kinda cool, (b) “let a hundred flowers blossom and a hundred schools of thought contend” and (c) the steam has run out of the Scheme project. The Great Macro Debate reinforced my feeling that the state of the art in large-systems software engineering practice is to treat programmers as a menace (see also XCVB). The CARMA presentation was a highlight – delivering a desktop app to non-techie end-users by using abcl; no muss, no fuss, it’s good enough so let’s ship. Xach is as good on stage as he is on irc. I couldn’t bear to witness the whole of the ALU meeting. Shriram Krishnamurti is an energetic speaker who almost made me care. It’s a pity Olin Shivers gave a talk he’d given before with exactly the same jokes.

ilc2009 – MIT Museum visit (and beer)

Thursday, March 19th, 2009

Seems some folks are going to meet inside the entrance to the MIT Museum at 3pm on Saturday for a (presumably lisp-focused) look around. There is talk of a pre-visit lunch at Miracle of Science around 1:30pm, and post-visit beer at Cambridge Brewing Company around 6pm.