Slashdot Mirror

Go is a replacement of C for servers. So quite obviously some of the things aren't going to be there, since it's generally somewhat more conservative. More so as it's geared towards people writing their own language processing tools for heavy lifting in really large projects (admittedly, probably not something for the average phone app developer) which gets obviously easier if the language is simpler. That could make it a pretty good choice especially if you want to share code between a server and a client AND you're already settled on using it on the server side. Anyway, a laundry list of features ("half-features" for some of those you named to boot) is hardly an argument. If I want the ultimate rich ultra-flexible language, I already know where to find it.

Java and C# are not different languages. They are the same language - much more similar than, for example Medley Common Lisp and Franz Allegro Common Lisp, and those are two implementations which both conform to the same published specification. Java and C# have very slightly different syntax, and slightly different core libraries. But if you can read (or write) one you can read (or write) the other. The compilers work in very much the same way, and even the object code and virtual machines are similar.

Which isn't surprising. Microsoft based C# on its own implementation of Java, changing it (only) just enough to get around legal problems with Sun. It's a very sincere flattery. C# is slightly newer, so it has slightly less legacy cruft. Apart from that, you are comparing apples with apples here. If you want a more interesting comparison, compare Java/C# with Ruby, Python, Lua, JavaScript/EcmaScript or Clojure.

That's why I get to say that Bethesda writes terrible code. Every time I play a Naughty Dog game, I'm more aware of how lazy other developers are.

If you want the really interesting one, go play their Jak 3 on the PS2 which only had 32MB of RAM.

cf. http://www.franz.com/success/customer_apps/animation/naughtydog.php3 ... these are the same people that wrote games in LISP on the Playstation.

Twenty-one years ago, the Deep Space 1 probe was controlled by an autonomous spacecraft control system called "Remote Agent". This was a Lisp program running aboard the spacecraft, 100,000,000 miles away from Earth. During the flight, they remotely debugged and fixed a race condition in the code that had not shown up during ground testing. This saved the day, and the Remote Agent was subsequently named "NASA Software of the Year". One of the developers said, "Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem."

What do you think: Conservative, or Liberal Programming? (lol)
Formal Analysis of the Remote Agent Before and After Flight

Lisp was also used for the Mars Pathfinder mission, although in that case it was not running aboard the spacecraft.

http://www.pchristensen.com/blog/lisp-companies/
http://stackoverflow.com/questions/172798/lisp-in-the-real-world
http://www.franz.com/success/

http://www.franz.com/success/customer_apps/data_mining/itastory.lhtml

Airline travel and booking. No that's not important. Owned by Google now, I believe.

http://www.pchristensen.com/blog/lisp-companies/
http://stackoverflow.com/questions/172798/lisp-in-the-real-world
http://www.franz.com/success/

http://www.franz.com/success/customer_apps/data_mining/itastory.lhtml

Airline travel and booking. No that's not important. Owned by Google now, I believe.

http://www.franz.com/success/customer_apps/data_mining/itastory.lhtml

http://www.pchristensen.com/blog/lisp-companies/
http://stackoverflow.com/questions/172798/lisp-in-the-real-world
http://www.franz.com/success/

yes, their QPX software is used by Orbitz. Main engine is written in Allegro Common LISP http://www.franz.com/success/customer_apps/data_mining/itastory.lhtml

Other companies that use Allegro CL include Naughty Dog (for their playstation games dev environment) and Marai I mentioned.

Have to laugh when people say no one uses LISP anymore and their are tens billions of dollars of global business annually powered by it

Lisp is used for a whole bunch of things in highly complicated current fields. Like aircraft ticket booking, stock trading, and missile defence:

http://www.franz.com/success/

http://www.lispworks.com/success-stories/

when did we forget that javascript is garbage? everyone needs to quit writing absolutely EVERYTHING in javascript.. imagine the dos world if EVERYTHING was written in qbasic. please, for the love of the lord who loves/hates you, write your code in something that produces slim, native binaries!

Native binaries? How's this? It even has first-class functions, just like JavaScript! Not available for iOS, unfortunately. Dunno how slim the binaries are.

The present (and the future) of experimental data organisation, repurposing, re-analysing, etc. is being shifted towards Linked Data and supporting graph data stores. Give it a spin.

Yes, as the experiments clearly show: as long as you write tiny numerical computations and programs that require code-as-data anyway.

Those papers do not show, and their authors do not state, that such a qualification is justified...

toy examples aren't going to convince anyone.

...and if they had, they'd have made laughing stocks of themselves:

http://www.lispworks.com/success-stories/raytheon-siglab.html
http://www.franz.com/success/customer_apps/eda/amd.lhtml
http://www.franz.com/success/customer_apps/data_mining/itastory.php3 (also: http://www.itasoftware.com/careers/l_e_t_lisp.html?catid=8 )

etc.

Yes, as the experiments clearly show: as long as you write tiny numerical computations and programs that require code-as-data anyway.

Those papers do not show, and their authors do not state, that such a qualification is justified...

toy examples aren't going to convince anyone.

...and if they had, they'd have made laughing stocks of themselves:

http://www.lispworks.com/success-stories/raytheon-siglab.html
http://www.franz.com/success/customer_apps/eda/amd.lhtml
http://www.franz.com/success/customer_apps/data_mining/itastory.php3 (also: http://www.itasoftware.com/careers/l_e_t_lisp.html?catid=8 )

etc.

Ah, but you did replay. Fortunately for me, the complete lack of content in your comtemptuously unresponsive reply means that I can ignore your humble proclamations of The Way Things Are.

Now, I wasn't claiming that all language exploration was, is, or ever will be done exclusively in Lisp. However, the fact that Lisp syntax so throughly supports macros and other forms of syntactic abstraction makes it very good for exploration. Consider, for example, Context-Oriented Programming. Pascal Costanza has been very active in this area of language research, having worked on both ContextJ* and ContextL, the former an implementation of aspect-oriented programming in Java and the later being AOP in Lisp. He had the following to say about AOP and Lisp:

It's no wonder that the Java crowd likes AOP so much. In Java, you neither have macros, nor higher-order functions nor a serious reflective and/or metaobject API. In other words, there are no (convenient) ways to do metaprogramming, except for some mild versions thereof in java.lang.reflect, or the cumbersome ways via inner classes, or if you dare to do this, via hacking around with custom class loaders. (Ah yes, together with annotations, Sun has also introduced some tools to do program transformation...)

Compared to those options, tools like AspectJ, Spring AOP, and so on, are a breeze. (And due to clever marketing, the Java people don't even realize that they are using a (limited) subset of metaprogramming techniques here.)

It's interesting to note that in C#/.NET world, AOP hasn't caught on. I suspect that this is due to the inclusion of first-class methods from the start.

Lispers and Schemers are, in general, not impressed by AOP because macros, higher-order functions and, in CLOS, a full-fledged metaobject protocol make metaprogramming very convenient and, after an admittedly steep learning curve, very straightforward.

And it is exactly Lisp's homoiconic syntax which makes macros so convienent in the language. In my apparently not so humble opinion, Prolog is another one of the few homoiconic languages. One of my favorite examples of the power of Lisp macros comes from Paradigms of Artificial Intelligence Programming , in which Peter Norvig implements a Prolog as Lisp compiler in Lisp which effectively introduces a new dialiect of Lisp with support for unification. Franz weaponized it and now includes it in their Lisp as Allegro Prolog . How many languages allow for one to completely and seamlessly embed another language in it?

Allegro Prolog does not attempt to be ISO compliant or implement the entire language. Many standard Prolog arithmetic, predicate operators, and I/O operators are not implemented, as they are a subset of the standard Common Lisp operators

But they could, if they wanted to bother to write reader macros for ISO Prolog syntax. But what's the point? They don't have the Prolog syntax but they've got all of the Prolog semantics. So, yes, perhaps Lisp will never become a mainstream programming language because it has an atypical syntax that many programmers don't like. However, I think that is being just a little bit full of one's own petty preferences for things like {$@.->*!%?} over () to dismiss all that flexiblity just because of syntax.

Ah, but you did replay. Fortunately for me, the complete lack of content in your comtemptuously unresponsive reply means that I can ignore your humble proclamations of The Way Things Are.

Now, I wasn't claiming that all language exploration was, is, or ever will be done exclusively in Lisp. However, the fact that Lisp syntax so throughly supports macros and other forms of syntactic abstraction makes it very good for exploration. Consider, for example, Context-Oriented Programming. Pascal Costanza has been very active in this area of language research, having worked on both ContextJ* and ContextL, the former an implementation of aspect-oriented programming in Java and the later being AOP in Lisp. He had the following to say about AOP and Lisp:

It's no wonder that the Java crowd likes AOP so much. In Java, you neither have macros, nor higher-order functions nor a serious reflective and/or metaobject API. In other words, there are no (convenient) ways to do metaprogramming, except for some mild versions thereof in java.lang.reflect, or the cumbersome ways via inner classes, or if you dare to do this, via hacking around with custom class loaders. (Ah yes, together with annotations, Sun has also introduced some tools to do program transformation...)

Compared to those options, tools like AspectJ, Spring AOP, and so on, are a breeze. (And due to clever marketing, the Java people don't even realize that they are using a (limited) subset of metaprogramming techniques here.)

It's interesting to note that in C#/.NET world, AOP hasn't caught on. I suspect that this is due to the inclusion of first-class methods from the start.

Lispers and Schemers are, in general, not impressed by AOP because macros, higher-order functions and, in CLOS, a full-fledged metaobject protocol make metaprogramming very convenient and, after an admittedly steep learning curve, very straightforward.

And it is exactly Lisp's homoiconic syntax which makes macros so convienent in the language. In my apparently not so humble opinion, Prolog is another one of the few homoiconic languages. One of my favorite examples of the power of Lisp macros comes from Paradigms of Artificial Intelligence Programming , in which Peter Norvig implements a Prolog as Lisp compiler in Lisp which effectively introduces a new dialiect of Lisp with support for unification. Franz weaponized it and now includes it in their Lisp as Allegro Prolog . How many languages allow for one to completely and seamlessly embed another language in it?

Allegro Prolog does not attempt to be ISO compliant or implement the entire language. Many standard Prolog arithmetic, predicate operators, and I/O operators are not implemented, as they are a subset of the standard Common Lisp operators

But they could, if they wanted to bother to write reader macros for ISO Prolog syntax. But what's the point? They don't have the Prolog syntax but they've got all of the Prolog semantics. So, yes, perhaps Lisp will never become a mainstream programming language because it has an atypical syntax that many programmers don't like. However, I think that is being just a little bit full of one's own petty preferences for things like {$@.->*!%?} over () to dismiss all that flexiblity just because of syntax.

Oracle, Franz and OpenLink (the latter having a free software version), are about to show that in practice. I think we're getting there.

And people have been doing really large databases with great performance on in-house applications. I haven't seen them live, but I have read their papers.

So, it is an important point that you raise, but I think it has a solution in near future too.

is this java only, or can I use lisp?

Yes.

Basically programmers gave up Lisp not because of syntax, but because they aren't eager to learn new ways of programming.

Don't discount the syntax issue. When your average programmer has been ingrained with years of Algol-like syntax, coming to Lisp is not easy. And yes, the overload of parenthesis can make the language harder to read, because there are fewer cues to pick up on. Consider that humans work by visually scanning and picking out noticable features: Preattentive Processing

Don't just take my word for it, as an admitted non-Lisper. Read what an industry insider thinks, and why he coded his own "if" macro: http://www.franz.com/~jkf/coding_standards.html

It has been noted that a program is written only once yet read many times. Thus program readability has to be a primary concern of the programmer. It's likely that the person reading your code will have far less knowledge of how you've solved the problem at hand than you have at the time you wrote the code. Thus you must strive to make your code readable by someone with little knowledge of the code.

I've found that the key to readability in Lisp functions is an obvious structure or framework to the code. With a glance you should be able to see where objects are bound, iteration is done and most importantly where conditional branching is done. The conditionals are the most important since this is where the program is deciding what to do next. Bugs often occur when the conditional can't handle all possible cases. If you're planning on extending the function you need a clear idea of the possible inputs it's willing to accept and what you can assert to be true for each branch of the conditional.

Lisp wins again; too bad freedom loses. http://www.franz.com/resources/educational_resourc es/white_papers/

Maybe I'm not smart enought to know why this post is modded "Funny", but didn't Naughty Dog already use LISP for Jak and Daxter? That's a functional language, right? OP's suggestion sounds like a great one for the PS3 hardware.

Not unless I want to have my clients pay a runtime fee for every running copy of the software.

Apparently, there's this rumour that all commercial lisps charge runtime royalties. This is not true, and such a rumour spreading would be disastrous to lisp vendors.
Who you're talking about is Franz. Franz wants to be your your business partner, that's what they say on comp.lang.lisp. ;-)
Other vendors aren't so mean, e.g., LispWorks (the havey Lisp for UNIX, Windows and Mac OS) and don't impose a sick licensing scheme like Franz. The LispWorks LispWorks reads:
"Q. What's the royalty for delivering my own application?

A. End-user applications delivered from the Professional and Enterprise Editions are royalty-free, including those using LispWorks ORB, KnowledgeWorks, Common SQL or CLIM 2.0. We believe this is the least restrictive commercial Lisp deployment model available."

• The syntax, which you can adapt to, given a good editor with auto-indent and syntax highlight.
• The fact the standard libraries, despite providing a wealth of datastructures, are lame or non-existant for doing anything actually useful (heavy duty I/O, sockets, GUI, etc). Compare this with C, where nothing is standard per ANSI C, but there are libraries which do everything for free bundled in the OS.
• There is no really good free and multi-platform implementation. For C you have GCC. It works on basically everything you may care about (from ARM PDAs to s390 Mainframes). For Java you have Sun's JDK, which despite not really being open source, is a free (as in beer) download and allows you to develop payware without paying a dime to Sun. The following is a couple years old info, but I am guessing things have not changed much yet: Emacs LISP isn't does not compile into native binaries and is not Common LISP compatible. CLISP does not compile into native binaries and is not 100% Common LISP compatible (almost). CMUCL is buggy, used to have an incredibly lame garbage collector which made you twiddle your thumbs every 5 minutes, and a had poor user interface to boot, GCL is not Common LISP compliant by a longshot. The good tools are payola like Allegro. Contrast this with Sun Java JDK + Eclipse. There is no contest... Even Microsoft is handing out at the moment Visual C# Express for $0 which can be used for commercial use.

I'm unfamiliar with SciTE, but if it has parens matching and syntax highlighting for Common Lisp, it should be okay. Regarding Allegro: there is a trial edition that's downloadable for free. http://www.franz.com/downloads/trial.lhtml. It has a heap limit of 23MB, though, which means its unusable for some things.

I've used to have rather profound C++ experience (about ten years now). I've wrote a Race-Track Microtron control system in it and some other stuff like that, really :-) But I still fail see in which way it's better than Lisp, besides some (but not 10x-20x as when compared to languages like Python in Perl) performance gain, which is not always critical. It's possible to write applications, device drivers and operating systems in it, as well as databases, compilers, GUIs, web applications and lots of other stuff in it. I have some doubts concerning hard real time, but given the fact that GC can be locally avoided/inhibited using rather simple techniques, I think there should be no much problems there. C++ experience is useful thing, but I think that Lisp is in no way less important.

CL's problems actually stem from the lack of Open Source libraries (as there are just too few Lispers). There are two approaches to solving these problems:

• (a) use commercial implementation which has everything included. An example of such implementation is Allegro CL which includes hardly much less functionality than .NET Framework; they also provide mind-blowing CL OODB and a lot of other useful stuff. It's quite expensive though.
• (b) use existing open-source CL implementations & libraries, improving them as you need, and maybe contributing some your code.

Approach (b) is feasible when most functionality of your product resides in your code and not in libraries. E.g. reddit.com code is mostly a rather thin wrapper around database + Web server, so free Common Lisp implementation may not be a best tool for the job. It may be better to use a commercial CL implementation or some other language (such as Python) in such cases, depending on how much money & spare time you have.

Another example - I'm writing an online store now as a semi-holiday project, I don't have too strict time constraints there, so I'm using CMUCL+CLSQL+TBNL to implement it. With severe time constraints it would be better to use Python in my case, as I don't want to pay $$$ for commercial Lisps.

But there are plenty of cases where Lisp proves to be just the ideal tool for the job.

CL's problems actually stem from the lack of Open Source libraries (as there are just too few Lispers). There are two approaches to solving these problems:

• (a) use commercial implementation which has everything included. An example of such implementation is Allegro CL which includes hardly much less functionality than .NET Framework; they also provide mind-blowing CL OODB and a lot of other useful stuff. It's quite expensive though.
• (b) use existing open-source CL implementations & libraries, improving them as you need, and maybe contributing some your code.

Approach (b) is feasible when most functionality of your product resides in your code and not in libraries. E.g. reddit.com code is mostly a rather thin wrapper around database + Web server, so free Common Lisp implementation may not be a best tool for the job. It may be better to use a commercial CL implementation or some other language (such as Python) in such cases, depending on how much money & spare time you have.

Another example - I'm writing an online store now as a semi-holiday project, I don't have too strict time constraints there, so I'm using CMUCL+CLSQL+TBNL to implement it. With severe time constraints it would be better to use Python in my case, as I don't want to pay $$$ for commercial Lisps.

But there are plenty of cases where Lisp proves to be just the ideal tool for the job.

Naughty Dog used a variant to write "Jak and Daxter", an extremely popular game for Playstation 2. Many more people use spiritual descendents like Python.

See here for the details. They used Common Lisp for what it excels at - implementation of a domain-specific language which they could prototype in CL, then use a CL-based compiler to generate console code.

LISP is already being used for videogames on the ps2 very successfully, in very well written, fun games:

Naughty Dog and LISP

--jeff++

Your point is well taken, but note that your problem is basically a combination of lacking documentation and you still learning the language. The first is the fault of the language (well, the implementation, but still), while the latter is nobody's fault, because it's an inevitable situation. I would assume that if you were on the clock, you would already know the language you were working in. Ie. if the project were in C++, you'd already know C++, or else you wouldn't have gotten hired to work on it.

What implementation are you on, anyway? Depending on what kind of networking you need, the trivial-sockets library could be up your ally. Very simple way to connect Lisp to a network. If you're on SBCL, there is SB-BSD-SOCKETS, which exports an API pretty similar to standard UNIX sockets. Of course, for the best in documentation quality, springing for a copy of Allegro CL will get you the ACL socket API. Since you're a student, you can get a copy for a mere $99, or about what you'd pay for an academic version of any other commercial software.

Has anyone read the zlib code? While the author clearly tried to make it readable it's still very complex and it's very hard to see at a glance or even after many glances where potential buffer overflow problems may exist (or even where it might fail to implement the deflate algorithm). C is great language for writing an operating system where all you care about is setting bits in a machine register but this algorithm really taxes its abilties.

For comparison here is the deflate algorithm written in Common Lisp. It all fits neaty into a few pages. This is a far better language comparison example than the oft-cited hello world comparison.

Common Lisp has 24 special forms. 24 is not "a bazillion". Special forms (special operators, in modern parlance) are the primitive syntax of the language -- equivalent to the grammar of other languages. Almost all other languages have more "special operators" than Common Lisp.

Common Lisp has 24 special forms. 24 is not "a bazillion". Special forms (special operators, in modern parlance) are the primitive syntax of the language -- equivalent to the grammar of other languages. Almost all other languages have more "special operators" than Common Lisp.

There definitely are "good libraries with multiplatform support", and I listed a few of them elsewhere in this topic.

As for "Visual Lisp", if what you mean is a powerful IDE for Common Lisp, the commercial implementations have had these for years. Download the trial versions of Allegro Common Lisp and LispWorks and take them for a spin. They're expensive to license, but they're also (arguably) the best implementations of Common Lisp you'll find.

Naughty Dog does their 3D modelling in CL. I don't think there's any lisp in the runtime environment, tho. Lua looks like a really an interesting language. I think I'll take a closer look at it.

As everyone else that's replied to you has pointed out you are talking out your ass. Lisp had exceptions and GC long before Java or C# were even an idea. GC in Common Lisp is far ahead of GC in Java and .Net, for just this reason. An industrial strength GC isn't made over night, it's made by having applications beat the hell out of the GC and the implementors spending huge amounts of time handling huge programs. This is exactly what's happened for Lisp over the last 20 years. For example, Allegro CL hosts industrial applications the likes that have never even been dreamt of in Java or C#--programs that use GBs of memory and runs for months. Try that in Java or C#.

If you are still unconvinced, Orbitz wouldn't even be possible (according to the authors of the software that run the site) without Common Lisp.

"Where is the development environment that is as simple to use as lego blocks which anyone over the age of 6 can use to quickly create powerful apps?"

Of course there is.

And for the big boys, there is this.

Beating the Averages by Paul Graham is a good start. What made Lisp different and On Lisp are also by Graham. Lastly, one from Franz Inc on domain specific languages on top of Lisp. Really, if you've never used Lisp and you want to create your own language, you're missing the boat.

The problem with dynamic languages, like Python, is that they can't be easily compiled to native code and optimized.

Ok, so all the highly- optimizing Common Lisp compilers are fakes?

Or maybe you have no idea what you're talking about? I'm guessing the latter.

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.

There are a few Common Lisp implementations as well

Open Source:

Open MCL
SBCL

Commercial:

Macintosh Common Lisp
Allegro Common Lisp
Xanalys Lispworks

Eh?

Common Lisp programming is a pretty high-end market. Commercial Common Lisps sell for large sums of money to a number of large customers implementing really complex systems.

I would love to be proved wrong on the speed issue, but I'm confident claiming that it is impossible to write something like mplayer in any CL system today.

Take a look at Success Stories.

About the only thing CL can do today is play with files, albeit, in a not-so-nice way. Networking? Nope. It's all non-standard. There is no defacto standard like BSD sockets even. You can't even draw widgets half-way portable (and reliable) as you can in C/C++, Java, Perl, Python, etc. etc. It is simply not possible in *any* CL system today. The point of a standard like CL is to *ensure* portability, but what does that really matter when you can't do anything *with* that portability?

This simply isn't true. Where have you been the last year? There are sockets, GUIs, anything. And people make it work with more than one implementation of Common Lisp. And where is the GUI in the ISO standard of C?

There are. Several big commercial Common Lisp packages (eg.), and for Scheme (a Lisp variant), a nice little free download from Rice University. I've been playing with the latter since reading Graham's latest, and it's sweet...auto-indenting, highlighting to show matching parens, source-level step-by-step debugging, unit-testing support....then there's Emacs support of lisp code editing (again with the parens matching), and the Bigloo package for well-optimized code that compiles to native or JVM (with full access to Java libraries)...google and you'll find plenty.

Yep, it's pretty much only useful for simple problems like:

. Animation & Graphics
. Artificial Intelligence
. BioInformatics
. B2B & E-Commerce
. Data Integ. & Mining
. EDA
. Expert Systems
. Finance
. Intelligent Agents
. Knowledge Mgmt
. Mechanical CAD
. Modeling & Simulation
. Natural Lang. Proc.
. Optimization
. Research
. Risk Analysis
. Scheduling
. Telecom
. Web Authoring

and the like.

So, no, we won't (realistically) be able to turn off the garbage collector, which means that we won't be able to write real-time programs, and it'll even be touchy writing programs, such as, oh, audio or video players, that require near real-time performance

Ah, the eternal anti-GC FUD of the ignorant.

Yes, clearly it would be complete lunacy to write video games in garbage-collected LISP, like Jak and Daxter, Ratchet and Clank and so on.

Obviously AT&T were insane to write their telephone exchange control software in garbage collected LISP.

And those massive overheads ensure that we'll never see NASA using LISP to control space probes.

Bah

I love Lisp and the only thing that comes even close to it is Standard ML (get SML/NJ for interactive development, and MLton for shipping.)

Common Lisp is, by far, the most powerful programming environment; Get yourself a free copy of Allegro and see yourself fly.