Slashdot Mirror

Cliki, a wiki directory of "Links to and resources for free software implemented in Common Lisp and available on Unix-like systems."
CLOCC - the Common Lisp Open Code Collection"
common-lisp.net, providing hosting and remote repositories to dozens of Free Software Common Lisp applications.

This doesn't even touch SourceForge (which hosts another two dozen or so Lisp projects I'm aware of). When you consider how small the Lisp community is compared to the number of Perl hackers (easily in the range of 1000:1), and the number and quality of the code on just those repositories to CPAN, the productivity advantage of Lisp really does seem closer to 50x. According to your argument, all those Perl hackers should not have had any trouble in coming up with an efficient implementation by now. Yet, with less that a dozen regular hackers between them, the CMUCL and SBCL projects have produced compilers that outperform g++. At the very least, the Perl folks should not have had any trouble producing an efficient regular expression library, but here again, Lisp has them beat.

Of course, the above links point to software written in only one dialect of Lisp, Common Lisp. When you consider the software produced in other dialects, like Scheme, NewLisp, LUSH, XLISP, and Isis, the difference becomes even more apparent. To say nothing of commercial software, where none of the languages you mention can even boast a fraction of the number of large, successful systems delivered in Lisp.

Personally, I've used Macintosh Common Lisp (now from Digitool) since it was available from Apple, but I've tried Lispworks (since that's what I use on a Linux box at work), and CLISP of course. Most of the other versions, including Franz's, I've used in the past on other platforms (Sun) since I lost my beloved Symbolics box. MCL was by far the best experience under OS9 and prior, though the user interface elements haven't completely tracked the change to OS X, though I usually use CLIM anyway for code portability so we're really just talking look and feel issues. The Xanalys product is very nice, the demo is pretty unrestricted (just the continuous time to use it, and inability to dump images so you need to load up your system after you start - pretty reasonable for what you get), and the full unrestricted version isn't too expensive.

If you're just starting out and want to poke around, I'd have to recommend Xanalys personal as the best bang for the buck, since you get a pretty nice IDE with it (though Digitool's might be easier to learn if you're used to OS 9). Once you get to the point of needing to dump applications, you can either spend the money to upgrade to professional, or use one of the free lisps to dump images. Your main limitation in these alternatives will be the user interface, as that is generally unique to the implementation unless you use CLIM (and CLIM is not free) or something like Garnet, neither of which will give you something very mac-like.

Personally, I've used (now from Digitool) since it was available from Apple, but I've tried Lispworks (since that's what I use on a Linux box at work), and CLISP of course. Most of the other versions, including Franz's, I've used in the past on other platforms (Sun) since I lost my beloved box. MCL was by far the best experience under OS9 and prior, though the user interface elements haven't completely tracked the change to OS X, though I usually use CLIM anyway for code portability so we're really just talking look and feel issues. The Xanalys product is very nice, the demo is pretty unrestricted (just the continuous time to use it, and inability to dump images so you need to load up your system after you start - pretty reasonable for what you get), and the full unrestricted version isn't too expensive.

If you're just starting out and want to poke around, I'd have to recommend Xanalys personal as the best bang for the buck, since you get a pretty nice IDE with it (though Digitool's might be easier to learn if you're used to OS 9). Once you get to the point of needing to dump applications, you can either spend the money to upgrade to professional, or use one of the free lisps to dump images. Your main limitation in these alternatives will be the user interface, as that is generally unique to the implementation unless you use CLIM (and CLIM is not free) or something like Garnet, neither of which will give you something very mac-like.

Note, I'm on win32, but I found allegro (Franz) to have a very nice environment. However, the constraints it puts on the evaluation/student version are very harsh, and it tends to crash very hard if you use badly-defined foreign-functions :) The problem is, I really don't feel like using another GUI interface... Anyway, if you go to http://alu.cliki.net/Success%20Stories, you'll find more information on large applications developped in CL.

Lisp is a multiparadigm language, not a pure functional one. Mature web servers written in lisp have existed for years, and are typically not written in a functional style. AllegroServe and Araneida are probably the big two (they have different focuses, think apache vs. zope). http://www.cliki.net/Web

And in the book he uses Allegro which is proprietary and non-free.

Well, it's really non-free. But how can a conforming ANSI Common Lisp system be proprietary?

Take a look at CLiki if you are looking for a free Common Lisp.

• CLiki, the Common Lisp Wiki
• Paul Graham's articles about Lisp
• Paul Graham's book, On Lisp
• The Emacs Wiki

I know Lisp is not the ideal language - its ugly, illegible, and slower than compiled languages

The vast majority of Common Lisp implementations have either a native code or through-C compiler, and at least two (Corman Lisp and SBCL) of them only come with a native code compiler.

Objectively, CMUCL can produce flotaing point code at least 5% faster than GCC on a non-trivial (the "Coyote Gulch" ephemeris calculator) benchmark. Of course, bechmarks are objective and misleading, and your assertion was subjective and misleading, and there's plenty of testimony (from real users writing non-trivial applications, not just some random bums paid off by the Scheme Underground) that Lisp is faster than C++.

Scheme seems like it has lost the intelligent simplicity of Python in favour of clumsy "special character" based syntax,

while Common Lisp has many detractors that don't complain much of details. Is your complaint about Common Lisp based on all Lisp variants? Or is CL especially bad?

Of course, your own assertion that Lisp is ugly and slow is stated authoritatively, even while you admit that you've "not coded a line yet," certainly could give someone the wrong impression.

ASDF on cliki

Sorry, but you're comparing apples and oranges here. LISP is adheres more to a completely different programming paradigm (functional programming) as opposed to Java/C/C++ and all the other OO languages.

If you actually believe this, you don't know Lisp very well. While Schemers often emphasize the functional use of their language, Common Lispers move about as they wish in the realms of procedural, object-oriented, and functional programming in order to most easily solve their problems.

You might have a look at the Table of Contents of the Hyperspec to have a better idea of the things available in Common Lisp as a language proper, and something like Cliki for links to Lisp libraries and such whose source code will indicate how people actually program in Lisp these days.

The ones I'm most familiar with are extensions of Common Lisp. There are 3 CL web servers, each with dynamic HTML generation capability (AllegroServe, Araneida, CL-HTTP). Then there's Lisp Server Pages, Active Lisp Pages, etc., and another whole load of CGI solutions. I use (and highly recommend) AllegroServe. There is a whole big list over at Cliki (which runs on Araneida).

There are many CGI bindings for various Scheme implementations, and the PLT web server is kind of popular. I'm not very familiar with Scheme web solutions though, so I probably left something out.

There is a lot of activity with Smalltalk-based web apps. Seaside is a continuation-based framework that gets a lot of attention. There's also AIDA/Web, and an unfinished mod.Smalltalk. I am not very familiar with Smalltalk web solutions either, so I probably missed a few.

Python is a very popular option, and Zope seems to be a very popular framework. I don't know anything about web programming in Python aside from that.

Take pretty much any of the recent lightweight (in the conference meaning of the term) languages, and you're bound to find good options, almost all of them better in terms of security and speed than PHP; I can't think of a single one that has a more annoying syntax or more convoluted and limited semantics than PHP, though. Another thing that you should consider is the website we're posting on is pretty interactive, and kind of popular, and it's written in Perl.

I am really pleased to see a major software development community leaving the C-like realm of programming languages. While C is still nice as assembler substitute, I never could convince me that it is useful for general application development. Same goes more or less for C++/Java, though I do not have much exposure to them myself and will try to keep it that way.

There are really neat languages to successfully code nice programs and all the C-like ones are clearly not belonging into that group. Being a Common Lisp zealot I strongly prefer its multi-paradigm style to anything else for most tasks, but I also see the benefit in using OCaml, Eiffel and other languages with way more abstraction than any C-like language so far manages to convey to the ordinary programmer. Having proper closures, and first-class functions, and a not-limiting OO implementation increases productivity by a order of magnitude.

Ok, but one must face reality: As software developer eventually you will have to code something in say Java, but Lispers have now a real advantage: LINJ
For now I can use most of the expressivness of Common Lisp and still can pretend to hack Java. :-)

• Played Jak & Daxter or any of its sequels
• Played Abuse
• Booked a reservation on Orbitz
• Visited the campaign web sites of Bill Clinton in '96 or Howard Dean in '04
• Used the Mirai facial-animation software or watched Gollum in Two Towers / RoTK
• Used an AMD processor, parts of whose logic is validated via the ACL2 theorem-prover software
• Used GNU/XEmacs
• Used AutoCAD
• Used the lisppaste pastebot on a bunch of channels on Freenode

Not all the world is a desktop application with a GUI. Lisp and the other languages aren't going away in this space anytime soon. It's just too cumbersome to do many of these things in C++, and too slow to do them in Java (Common Lisp is usually native compiled).

are not inherently fast or slow - implementations are fast or slow, not languages

can be both dynamic and have good performance

can be cross-platform without swallowing POSIX whole

can have multiple inheritance without damaging your brain

can be object-oriented without being object-obsessed

If you like, you can quit as soon as you understand how static scoping and closures work - at least that way you will avoid the primary mistake in pretty much every recent scripting language.

There is a small risk you will become a SmugLispWeenie by doing this, so be forwarned.

I am a happy user of Common Lisp, which supports imperative, functional, OO etc. out of the box. But what is more important is that the language itself is extensible. It is a rather common approach to write applications by first extending the language, and such extensions can go quite far. For example, people have integrated prolog style logic programming into Lisp, there are libraries that support nondeterministic evaluation and backtracking, prototype-based alternatives to the native OO system, dataflow, you can use it as a dynamic markup language etc. The nice thing is that all this gets part of the Lisp system just like the builtins, so that a programmer can mix and match all of these, and the features of CL itself.

Paul Graham has written a really cool book on that topic, which is freely available.

Not much use outside AI or research? Hmmm, tell that to Paul Graham, who wrote Viaweb in Lisp, which Yahoo then bought for $40 million and called it Yahoo!Store. I don't think AutoCAD counts as AI either. See alu.cliki.net for some idea of how it's currently being used.

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

CLiki is a Common Lisp wiki written using Araneida. Other popular web systems for Common Lisp include CL-HTTPD, used for Bill Clinton's 96 campaign and Howard Dean's 2004 campaign, and Franz's AllegroServe.

So why would you pick Lisp for a web server? You said it yourself - "the standards change so fast". Lisp is not a language for AI, it's a language for rapid development in a changing domain, and it provides good-to-excellent performance at the same time (much better than Perl, PHP, and Java). The fact that it's an ANSI standard brings it much closer to "write once, run anywhere" than Java, and the large standard library makes certain programs even more portable than their C counterparts. So, the question is not "why Lisp?", it's "why not Lisp?".

Really, isn't a functional language like LOGO
(hmmm, something strange about that turtle head there) better?

And what about LOGO's big brother, Common Lisp?

C'mon guys! The Turtle is calling for you. Will you answer?

That's actually a pretty good theory, and the high-end of computing long since recognised it as truth. If you look at things like Common Lisp CLIM, that's already how it is. Words are just symbols. So are icons. They have meanings. Their manipulation is "symbolic computing". A good computing system lets people manipulate all those symbols. As CLIM did years ago, and still does. See e.g. screenshots here (though you'd have to actually use it to appreciate the fluidity).

(Obligatory Lisp community stuff follows:)
Have you taken the Road to Lisp Survey?
Do you know about CLiki?
Have you ever been to #lisp on freenode?

(Obligatory Lisp community stuff follows:)
Have you taken the Road to Lisp Survey?
Do you know about CLiki?
Have you ever been to #lisp on freenode?

Actually, Lisp is an ideal platform for kick-ass windowing systems, such as CLIM. One key feature of CLIM is that the data sent to windows still remembers where it came from. As opposed to conventional window systems, where stuff either becomes pixels, or, if you are lucky, selectable as text.

RMS came from the AI lab at MIT, who were using Lisp machines as personal workstations before workstations even became common. These machines had OS's that had user-readable and user-modifiable code all the way down to and including the hardware microcode!

It's a shame that the UNIX model of "everything becomes an undifferentiated stream of byte-sized characters" took over the world. That world gives us solutions like Perl, which proliferate quick-and-dirty hacks that make all sorts of assumptions on the format of text streams to try to reconstruct the data hidden within them. When the assumptions fail (Y2K, anyone?) all sorts of things break.

Imagine if any time value anywhere in the system *understood* that it was a time. You could display it on the screen if you wanted, but you wouldn't use that text for processing, rather you would use the time value itself. Human display is separate from the machine representation. That is the idea behind CLIM.

Note: RMS doesn't fully get it, unfortunately. Consider Emacs, which has a Lisp-like extension language, but is unbelievably out-of-date. It uses default dynamic scope, which has been known since the 70s to be an ugly mistake, doesn't support packages, so names all have to have long prefixes, and doesn't fully use structured data types, so that all sorts of code depends on properly forming nested lists. But, RMS being RMS, he can't be persuaded to change his approach.

"GNU will be able to run Unix programs, but will not be identical to Unix [...] Both C and Lisp will be available as system programming languages." -- The GNU Manifesto, rms, 1985

The cirCLe project supports this.

Because the MOP means CLOS is infinitely mutable, and therefore you can mould the properties of CLOS to fit better with relational theory, with accessor methods capable of arbitrary joins and whatnot?

Because CL has restartable conditions, not mere exceptions, thus making preservation of transactionality orders of magnitude easier?

Because CLOS is multiple-dispatch, so you don't have the conceptual problem of methods "in" classes, to confuse you when you try to operate on the results of an SQL join?

Because a few lisp macros let you merge an sql sublanguage into lisp?

Seriously, check out uncommonsql!


(sql:def-view-class employee ()
((emplid :db-kind :key :type integer :initarg :emplid)
(first-name :accessor first-name :type (string 30) :initarg :first-name)
(last-name :accessor last-name :type (string 30) :initarg :last-name)
(email :accessor employee-email :type (string 100) :nulls-ok t :initarg :email)
(companyid :type integer)
(company :accessor employee-company :db-kind :join :db-info (:join-class company :home-key companyid :foreign-key companyid :set nil))
(managerid :type integer :nulls-ok t)
(manager :accessor employee-manager :db-kind :join :db-info (:join-class employee :home-key managerid :foreign-key emplid :set nil)))
(:base-table employee))

;; Employees of Widget's Inc.
(sql:select 'employee :where [and [= [slot-value 'employee 'companyid]
[slot-value 'company 'companyid]]
[= [slot-value 'company 'name]
"Widgets Inc."]])

Huh?! Are you insane or something? Ever checked out CLOS?

As for online resources, a good place to start is probably the cliki, a CL-related WikiWeb with emphasis on free software.

There are some free online books, like Successful Lisp, Loving Lisp - the Savy Programmers Secret Weapon, or Paul Grahams On Lisp (which isn't really a beginners book, but very enlightening once you are familiar with the basics). The Common Lisp Cookbook is not as big as it should be, but does contain useful information, and is growing.

An absolutely invaluable reference is the HyperSpec, a heavily hyperlinked online version of the standard. You definitely need that.

You might also want to check out the comp.lang.lisp newsgroup, or the #lisp channel at freenode. Depending on your specific interests, the LispWeb or Clump mailing lists may be interesting, the first deals with web programming using Lisp (surprise!), the second with general application developers issues.

Last but not least, there has been a movement of Lispniks gathering to drink beer and talk about all things Lisp (and everything else) in the last months. Check out this site, maybe there's a user group in your area. The people I've met so far are generally a nice and interesting bunch, and won't bite you even if you don't know the argument lisp of update-instance-for-redefined-class from the top of your head.

Happy hacking!

As for online resources, a good place to start is probably the cliki, a CL-related WikiWeb with emphasis on free software.

There are some free online books, like Successful Lisp, Loving Lisp - the Savy Programmers Secret Weapon, or Paul Grahams On Lisp (which isn't really a beginners book, but very enlightening once you are familiar with the basics). The Common Lisp Cookbook is not as big as it should be, but does contain useful information, and is growing.

An absolutely invaluable reference is the HyperSpec, a heavily hyperlinked online version of the standard. You definitely need that.

You might also want to check out the comp.lang.lisp newsgroup, or the #lisp channel at freenode. Depending on your specific interests, the LispWeb or Clump mailing lists may be interesting, the first deals with web programming using Lisp (surprise!), the second with general application developers issues.

Last but not least, there has been a movement of Lispniks gathering to drink beer and talk about all things Lisp (and everything else) in the last months. Check out this site, maybe there's a user group in your area. The people I've met so far are generally a nice and interesting bunch, and won't bite you even if you don't know the argument lisp of update-instance-for-redefined-class from the top of your head.

Happy hacking!

AI gives lisp a bad name. Common Lisp is actually a wonderful language for all sorts of stuff. Try it out.

"the implementors choose not to be fully ANSI-compliant. You won't notice it at first, but if you get into advanced object-system hacking CLISP will become unsuitable."

"Also, it's a byte-code interpreter system. This severely affects performance (except in bignums, due to some numerical methods magic), but it does have a smaller memory footprint. And it's widely ported."

"I use libraries like AllegroServe (HTTP server)"

"You can investigate GCL or ECLS, which compile to C and may work under mingw."

"Well, most Scheme implementations aren't anywhere near the same quality as the CL ones (with a few notable exceptions) and they all have to implement incompatible supersets of the language (because R5RS defines approximately nothing)."

CLISP is a fairly well-established implementation but due to some reason I cannot fathom, the implementors choose not to be fully ANSI-compliant. You won't notice it at first, but if you get into advanced object-system hacking CLISP will become unsuitable. Also, it's a byte-code interpreter system. This severely affects performance (except in bignums, due to some numerical methods magic), but it does have a smaller memory footprint. And it's widely ported.

CMUCL does purport to be a complete ANSI-conforming implementation, and it has a high-performance native-code compiler. But it's not ported very much (some ports have gone unmaintained) and only to Unixy systems. The current maintainers are interested mostly in features and speed, whereas...

SBCL is a fork of CMUCL, with the goal of being more easily maintained, cleaner, and conforming. It's also more widely ported now, having resurrected some of the old CMUCL ports and added some new ones (someone is working on OS X now). SBCL has been adding features back that were dropped, sometimes improving, for example, kernel-threads recently (vs user-threads in CMUCL).

Lately they've been driving the development of each other, since many patches can be cross-ported easily. This is all the better for the users :-).

I use CMUCL for most of my work, which involves database-driven web-app development, and it works fine. Though I am thinking about switching to SBCL soon, with nice features like kernel-threads coming around. Well, presumably I would be able to use either. I use libraries like AllegroServe (HTTP server), UncommonSQL (RDBMS OO interface), and IMHO (web apps w/Apache).

Neither work on Windows (yet) so there you would need to look into Allegro, LispWorks, or Corman Lisp (which I forgot to list in the previous post). All these are native compilers that can produce Windows applications. There are no free compilers for Windows which produce native code, afaik. You can investigate GCL or ECLS, which compile to C and may work under mingw. The commercial compilers all have GUI toolkits or bindings to the Windows API. Allegro is probably out of your price range, LispWorks is ~$900 and Corman is ~$150. All have free personal editions to play with.

Why do I say Scheme isn't as practical? Well, most Scheme implementations aren't anywhere near the same quality as the CL ones (with a few notable exceptions) and they all have to implement incompatible supersets of the language (because R5RS defines approximately nothing). Personally I think the design of Scheme itself works against practical usage and implementation, but there are those who disagree. In universities they teach Scheme, but as I was saying, as an academic exercise and not something to be used in industry. Which is a real shame.

Anyway, if you want a learning environment, I recommend the LispWorks personal edition IDE (Linux, Windows, Unix, and soon OS X). This will get you started with a minimum of fuss. Later on, you can setup Emacs with the ILISP package and interface with your CL implementation; this is a popular way. Or you may find some other IDE. The minimum needed really is parenthesis-matching and auto-indentation. After that you might like interactive features such as shortcuts to compile code-fragments, documentation at a keystroke, easy access to a Lisp listener, inspector, debugger, etc.

There are many books, such as Paul Graham's ANSI Common Lisp, Peter Norvig's Paradigms of AI Programming, online tutorial Successful Lisp, and sites such as CLiki with lots of pointers to resources.

CMUCL
SBCL
LispWorks
Corman Lisp

gtk+ bindings that I haven't ever used are mentioned on cliki

JACOL apparently allows java / cl interop, but again, I've never used it.

I haven't seen Qt bindings.

McCLIM is the most fun, though - a project for an open-source implementation of the CLIM spec. Just reading the CLIM specification is worthwhile, if you're academically interested in graphics toolkits.

gtk+ bindings that I haven't ever used are mentioned on cliki

JACOL apparently allows java / cl interop, but again, I've never used it.

I haven't seen Qt bindings.

McCLIM is the most fun, though - a project for an open-source implementation of the CLIM spec. Just reading the CLIM specification is worthwhile, if you're academically interested in graphics toolkits.

lispers have transcended need for physical "containers" in this universe, and instead exist as pure energy...

In most cases those meetings turned out to happen in nice bars and involved both talking Lisp and drinking beer, which IMHO clearly qualifies as physical.

Naah...

I'll just keep using UnCommonSQL, for my object-relational persistence needs, thanks.

The "lack of commercial CL success" meme has GOT to die. CL is used for very high-value commecial systems. Apps written in CL are used by law firms, intelligence, security and police agencies worldwide as an investigative aid, it's used to get your airline tickets ready, it's used to do all sorts of HARD stuff. The stuff that other people look at and go "not possible with today's technology" or "you'll need a human to do that."

No, it's not hyped like Java, but I confidently predict that in 40 years time Lisp will still be around (as will Fortran...). Lisp is one of the oldest computer languages, but it has continuously evolved, and is still evolving today.

It's pretty pathetic to see the XML and scripting-language-du-jour communities discover problems that Lisp solved years ago, reinvent/steal solutions to those solved problems, then hype the solutions as big new "wins"...

The symbolics Lisp Machine user interface was based around this. For an impression of it looked like and worked, look at this movie. CLIM is available for the two major commercial Lisp implementations from Franz, Inc. and Xanalys; there is also a free implementation in the works. Here are some relevant links.

The symbolics Lisp Machine user interface was based around this. For an impression of it looked like and worked, look at this movie. CLIM is available for the two major commercial Lisp implementations from Franz, Inc. and Xanalys; there is also a free implementation in the works. Here are some relevant links.