PAIP Retrospective

Chris Rathman's posting at Lambda the Ultimate reminded me of Peter Norvig's retrospective piece on his 1992 book, Paradigms of Artificial Intelligence Programming.

Norvig first looks at the state of Lisp now compared to 1997, and concludes that the situation has become somewhat bleak. I don't get too worried about the relative numbers of usenet postings for various languages (part of Norvig's measure of language popularity), but he does mention one thing that has concerned me for a while: There is no work being done toward evolving a new ANSI standard for lisp.

I'm not sure just how concerned I should be about that. It is true, after all, that people are adding new features to the language (Franz' hierarchical packages, e.g.). And there are still some facilities for which standardization might possibly be premature (such as multiprocessing). But I worry a little bit that there won't be enough energy in the lisp community to deal with a more formal standardization effort when the time is right.

Lisp has warts, like any language. And eight years (the ANSI standard came out in 1994) is a long time to live with those warts.

On the plus side, Lisp still stands out among other languages, for many reasons. Norvig points out that other languages (particularly Java) now offer some of the benefits that were previously unique to Lisp. I've found, however, that when the fingers hit the keyboard, Lisp still wins:

• First-class functions. The syntax for Java's inner classes is so clumsy, I feel like a sucker every time I use one. And Python's lambda is just a cruel joke.
• Interactive development. I haven't seen anything like the industrial-strength debuggers that most lisp environments have.
• Syntax and macros. Lisp has a consistent syntax for everything, and that syntax makes it really easy to write macros. Either other language designers don't understand how helpful macros are, or they quail at the prospect of implementing them for non-sexp syntaxes. You'd think that the scripting languages, at least, would recognize the utility of macros for creating domain specific/little languages.
• Error handling. Other languages have exceptions. But they don't have handler-bind or restart-case.

More generally, there is a huge advantage to using a language with 40 years of history (I know, I've gone on about this before): Almost everything in the language fits together well (in what Kent Pitman calls the language's ecology). I'm no language designer, but it's often easy for me to look at a language and see features that could have easily been made to work together, but don't.

(Norvig's extraction of the 52 most important lessons from PAIP is kind of fun, too.)

P.S. lemonodor is still only half-alive. I'm settled in my new apartment, but I still need to take care of my home high-speed internet needs.

More Than Zero Point Zero

Toomas Altosaar posts a dangerous little function to info-mcl:

  Even more disconcerting is when 0.0 stops being 0.0. Here is a
  compact (and faulty) example of how to change the value behind 0.0
  using "standard Lisp code" in MCL:

  (defun increment-0.0 (value)
     (let ((sum 0.0))
       (declare (dynamic-extent sum))
       (incf sum value)))

  (increment-0.0 5.0)

  and now if you eval 0.0 you get 5.0

  0.0 => 5.0

  and it's time to reboot.

P.S. Lemonodor.com is operating in reduced-functionality mode for a bit. Mostly this means I won't be posting anything, and the comments links don't work. You can still read the comments by following the timestamp/permalink link at the end of each entry (except for this entry, because... it's not a real entry).

Chaos

It's finally time to pack up and move the vast array of servers and robotic tape libraries comprising lemonodor. My tech staff tells me that the process will take at least a week. I asked them to temporarily mirror the site somewhere else, but they keep telling me that's not the right way, the right way is to develop a distributed hypertext system with transparent failover, secure blahblah and referential whatchamacallit, and put the site on that.

So lemonodor might be down for a week or two. Sorry.

Optimization

"I regret every single declaration I've made in the past seven years of Lisp programming." -- Me.

(Your mileage may vary. Does not include ignore, ignoreable, or notinline declarations. Historical performance does not insure future performance. Otherwise, it's true.)

CMUCL 18D Released

cmucl 18d was released. This version includes some significant improvements, like OpenBSD support (x86) and better custom structure printing.

Check the release notes for more details.

Greetings From L.A.

Hello from sunny Los Angeles!

Yeah, I've moved. And gotten a new job, at Evolution Robotics.

Chicago is great, and I will miss the excellent people I worked with (Will even wrote and sang a song for me!). I'll miss my friends and family. But I needed a change of scenery, and I am sooo excited about living in LA and working on some robots.

Logistically, it could hardly get any better. I arrived here a little after noon Friday, found a great apartment two hours later, and signed a lease Saturday morning. My Beetle, according to the auto shipper's website, is en route, currently in Reno. All that's left is to go back and fetch my cats, and then truck all my stuff here (including the G4 serving up lemonodor; there will be down time).

How much lisp will I be doing at work? None. What will happen to lemonodor? I don't know. I imagine spending more effort on some of the free lisp projects, but I'll have to see what happens and how much time I have.

Already overheard at the Rose Bowl flea market: "You're in the pilot, right?" "No, I'm not in the budget." "Oh." [awkward silence] "OK, I'm sure we'll talk later. Bye!"

Your Introduction To Lisp...

Damond Walker started a pretty good thread in comp.lang.lisp with his post on how he first started using lisp:

  By sunday night I had the game done.  It was around 2000 lines of Lisp
  code, another 300-400 lines of C, and a 5 page paper which described
  the algorithms I used.

  I gave my presentation Monday morning and, honest to god, mouths hit
  the floor.  I had a few fellow students actually get mad at me.  My
  ego was pretty inflated at the time.  I think the prof still uses the
  game as an example here and there.  

Read the thread, but skip the... well, you know what parts to skip.

LispWorks Looking Good

Mike has been having a good experience so far evaluating LispWorks. Xanalys has been very responsive, already having sent us a patch to fix the behavior of :up in pathnames, and code to display function arguments on the fly. Looking good.

There is something a little strange to me about both those issues, though. How can we possibly be the first people to run into :up not working? As in, this code does not work:

(load (merge-pathnames 
       (make-pathname :directory '(:relative :up)
                      :name "foo"
                      :type "lisp")
       *load-pathname*))

But if you change :up to :back, it does work. Similarly with displaying function arguments on the fly, which seems like a very natural thing to want (ok, so ACL doesn't always do that either).

Part of what I like about lisp is that it usually feels very livable, and lived-in, compared to, say, Java. 40 years of experience have worn down the sharp edges in the language. And given us a body of tradition to help guide our programming. So it is slightly shocking to me when things that seem like they should be along well-worn paths turn out to be on the frontier.

MCL Now Insanely Cheap

Digitool dropped the price of MCL from $345 to $95. If you're a student, you can get it for $66. Wow.

They also dropped the concept of subscriptions, though existing subscriptions will be honored. Tech support is now fee-based; either $25 per incident or $200 per year (educational discounts available).

Of course, it's still version 4.3.1, and it only runs in the Classic environment under OS X.

Mike's idea of buying a copy now to support work on the OS X version is awfully appealing. (He actually bought a subscription, which is no longer an option.)

To tell the truth, it's somewhat reassuring to hear anything at all from the Digitool corporate entity. I have to at least wonder whether this is the start of a bold new marketing initiative, or something more desperate.

Let Loose the Lawyers of, uh, LAW

Gary Byers is hoping to release a new version of OpenMCL soon, but there are some obstacles:

Another important step in that direction involves the resolution of certain legal issues by my new employer. Briefly, the intent of all parties concerned is that I can continue to work on OpenMCL and that this be done in a way that satisfies certain complicated, pre-existing legal obligations of those parties.

He sounds confident that everything can be resolved, at least. Eventually.

News From Usenet

UFFI: Kevin Rosenberg has a new version of UFFI, with bug fixes and improvements, and a new license: GNU LGPL instead of GNU GPL.

CLSQL: He also released CLSQL, which is based on Pierre Mai's MaiSQL:

  The major changes compared to MaiSQL are:

  - ported FFI from CMUCL to UFFI.
  - new AllegroCL ODBC interface back-end.
  - compatibility layer for CMUCL specific code.
  - much improved robustness of the MySQL back-end.
  - improved system loading.
  - improved packages and symbol export.

  CLSQL has been tested on ACL,LW,CMUCL on both Linux and
  Windows platforms.

mod_lisp: There's a new version of mod_lisp by Marc Battyani:

  From the change log:

  21-03-2002
  Version 2.2
  Allow more than one Set-Cookie
  Renamed the win32 dll to mod_lisp.dll

  22-02-2002
  Version 2.1
  Added the possibility to add notes in the apache notes table
  Corrected a multithreading bug in the Win32 version
  Better handling of header only replies.

Hierarchical Packages: Tim Bradshaw has hacked on Franz' sample implementation of hierarchical packages and produced a version that definitely works for cmucl and LispWorks, and "will (should) work in any Lisp that both allows redefinition of CL:FIND-PACKAGE and actually goes through that function in the reader." Which leaves out clisp, at least.

CLX: Peter Van Eynde has a new release of CLX (packaged as part of CLOCC):

  There is support for clisp/sbcl/cmucl and limited support for
  lwl (no unix sockets) and acl (seems to work, but needs testing).

Looking Into LispWorks

Val Kulyukin, my colleague from the U of Chicago days, mentioned the other day that he had run into exactly the same bug I saw when running ACL-created DLLs in Visual Basic. His solution: switch to LispWorks. We're looking into that possibility. The bits of the LispWorks IDE I've seen make me want to play with it more; Maybe it could even begin to be compared to MCL's, who knows.

Val's advice: Develop in ACL, deliver with LispWorks.

It looks like Val has some lisp code worth checking out: code to control the Microsoft Agent, control Saphira robots, and control Internet Explorer. He's also using the public domain version of our RAP agent programming language for some of his work.

(Also, I like the Bertrand Russel quote at the end of Val's Integrating Lisp With the World tutorial: "Tolerate and cooperate, or die.")

Yadda Lambda, it's Here

Issue #0 of Yadda Lambda is out. It's a little slim; there's an article on using vim for lisp programming, and one on how to name slot accessors, and that's it.

But I still think it's great.

Yadda Soon

The first issue of Yadda Lambda, an online lisp magazine, is now scheduled to be published this evening.

That issue is slated to contain 4 articles; I know at least one is by Tim Moore. I'm looking forward to it.

TRS-80

For probably the last time in a long time, last night I went to the Empty Bottle to see TRS-80. TRS-80 is the best band in Chicago. Straight experimental/techno/pink floydish stuff would really upset my digestion after a while, but they have this great drummer that sets it off perfectly, especially live.

The videos they project during the show are good enough that I'd pay for them. Not a single snippet of the source material has ever been familiar to me.

Oh wait, they have videos online! Check out Community College. (Carl feels strongly that they should write the song Community College Instructor, as well.)

People at the Empty Bottle are usually pretty nice, and the TRS-80 crowd is even better. I'm already missing it.

For to listen to: the biz (filthy rich) / trs-80.

Dynamic Space Reigned In

I haven't been doing much coding lately, it's been mostly documentation and design work for me. But there are a few things I've seen in comp.lang.lisp I wanted to make note of here so I would remember them later.

Raymond Toy posted a way to determine cmucl's dynamic space size:

> Try the following:
>
> * (alien:def-alien-variable ("dynamic_space_size" dynamic-space-size) c-call::int)
> * dynamic-space-size

By doing this I learned two things.

1. The default is 512M of dynamic space.
2. My attempt to determine the syntax of the -dynamic-space-size command line switch by reading the argument parsing code went off track somewhere; instead of -dynamic-space-size=<n>, it's just -dynamic-space-size <n>.