Slashdot Mirror

"...especially www.franz.com--list commercial customers who have been satisfied with developing software in Common Lisp."

Here's a link to the "Success Stories" section of www.franz.com - I believe that many people will find these to be particularly surprising, but that's a prejudice I'll attempt to debunk through action rather than words.

I think the answer's fairly simple; there aren't enough developers and development projects that utilize the functional programming paradigm to raise media interest. Alas.

I don't work for Franz Inc. or any of their partners, but I urge you to take a look at their CL implementation. I have delivered four successful projects partly based on their Allegro solution. It can be easily interfaced through CORBA, which means I can write parts of any project in CL, using ORBLink to interface them with a Java front-end.

Aside from the scholastic value of lisp (or scheme) as a system of abstract logic, there is a thriving commercial industry - it's not huge, but it does include some big names - Yahoo, Orbitz.. the list goes on..

• Companies making it big with lisp
• Lisp career listings

Aside from the scholastic value of lisp (or scheme) as a system of abstract logic, there is a thriving commercial industry - it's not huge, but it does include some big names - Yahoo, Orbitz.. the list goes on..

• Companies making it big with lisp
• Lisp career listings

Check out this list for some lisp job listings.

There are quite a few major applications of lisp on the market right now - yahoo storefront is one example (although they've been changing some things around lately inside the company), and Orbitz.

Check out the list here - it's sure to make you think twice about the commercial viability of lisp: Lisp Success Stories

Oh, I almost forgot to mention - we've also got an opensource lisp nexus setup at http://opensource.franz.com - lots of slick stuff there, like Ahmon's NFS server for windows: it's better than Hummingbird's - faster, and has some account handling hacks.

I feel horribly dirty for pointing you to my own company's site, as I am the webmaster, but the company I work for - Franz, makers of Allegro Common Lisp have a slew of success stories on our website - Orbitz, the guys who made Crash Bandicoot, the group that made the Final Fantasy movie.. etc.

Take a look - the best part is, there aren't any ads - there's only one company's products on the site ;)

I feel horribly dirty for pointing you to my own company's site, as I am the webmaster, but the company I work for - Franz, makers of Allegro Common Lisp have a slew of success stories on our website - Orbitz, the guys who made Crash Bandicoot, the group that made the Final Fantasy movie.. etc.

Take a look - the best part is, there aren't any ads - there's only one company's products on the site ;)

I was recently (April) hired-on as webmaster at Franz, a commercial lisp company (we make Allegro Common Lisp) which has introduced me to lisp in a very loud way. Since joining these guys (and gals), I've been thoroughly indoctrinated - with my full consent - because of my belief that as computing hardware progresses programming in more abstract languages will allow for more creative and effective use of the platform. Sure, coding assembler on a new super-duper petaflop chip will still be possible and less wasteful, but who would want to code a million lines of asm to save a few (or even a few thousand) operations out of a few billion, or trillion when it will only net a difference of nanoseconds in the end? I'm less interested in making super-fast programs than I am in making artistic and super-functional programs.

I'm not expressing the views of Franz, every member of the company has their own beliefs on what makes for great programming - which is one of the major reasons I find this place so fulfilling, everyone has complex reasons for their design considerations, and everyone communicates them (something I've grown to appreciate from working in too many places where this was definitely not the case), and consequently I've been exposed to quite a few different techniques of Lisp coding since my introduction half a year ago. I'm constantly amazed that so many different styles of programming can be expressed in the same language, it's capable of accomodating any logical thought process that can be converted to code - and I doubt many of you often use recursion in a logical way on a daily basis, but even that can be done efficiently in lisp.

I'm still very new to lisp, and I was never a serious programmer in the past, but I've always been accustomed to asking questions, and here are a few that I'd like some input on:

• If you learned any other programming language, did you initially find the formalities of its structure to be a significant stumbling block to understanding the language as a whole? Was the same true of learning lisp?
• How much time do you spend debugging non-lisp code? How much on lisp?
• What language took you the most time to learn - was it your first?
• What feature do you consider to be the most important for an abstract language to support efficiently - and which features have you found to be most poorly implemented in lisp distributions?

I'd love to hear about what people think sucks about lisp and needs improvement - or can't be improved, so far I haven't found anything that I could complain about, the most difficult thing for me has been managing all the documentation on a half-century old language in the process of learning it. I've begun to love working in lisp, but I suppose being surrounded by a group so full of passion for it has helped contribute to my bias - if I'm wrong, help snap me out of it with a good argument against using lisp. ;)

I was recently (April) hired-on as webmaster at Franz, a commercial lisp company (we make Allegro Common Lisp) which has introduced me to lisp in a very loud way. Since joining these guys (and gals), I've been thoroughly indoctrinated - with my full consent - because of my belief that as computing hardware progresses programming in more abstract languages will allow for more creative and effective use of the platform. Sure, coding assembler on a new super-duper petaflop chip will still be possible and less wasteful, but who would want to code a million lines of asm to save a few (or even a few thousand) operations out of a few billion, or trillion when it will only net a difference of nanoseconds in the end? I'm less interested in making super-fast programs than I am in making artistic and super-functional programs.

I'm not expressing the views of Franz, every member of the company has their own beliefs on what makes for great programming - which is one of the major reasons I find this place so fulfilling, everyone has complex reasons for their design considerations, and everyone communicates them (something I've grown to appreciate from working in too many places where this was definitely not the case), and consequently I've been exposed to quite a few different techniques of Lisp coding since my introduction half a year ago. I'm constantly amazed that so many different styles of programming can be expressed in the same language, it's capable of accomodating any logical thought process that can be converted to code - and I doubt many of you often use recursion in a logical way on a daily basis, but even that can be done efficiently in lisp.

I'm still very new to lisp, and I was never a serious programmer in the past, but I've always been accustomed to asking questions, and here are a few that I'd like some input on:

• If you learned any other programming language, did you initially find the formalities of its structure to be a significant stumbling block to understanding the language as a whole? Was the same true of learning lisp?
• How much time do you spend debugging non-lisp code? How much on lisp?
• What language took you the most time to learn - was it your first?
• What feature do you consider to be the most important for an abstract language to support efficiently - and which features have you found to be most poorly implemented in lisp distributions?

I'd love to hear about what people think sucks about lisp and needs improvement - or can't be improved, so far I haven't found anything that I could complain about, the most difficult thing for me has been managing all the documentation on a half-century old language in the process of learning it. I've begun to love working in lisp, but I suppose being surrounded by a group so full of passion for it has helped contribute to my bias - if I'm wrong, help snap me out of it with a good argument against using lisp. ;)

Franz has a few listed on their webpage: here.

By the way: Apparently lots of people use Lisp (Common Lisp), but don't tell, because they consider it a competitive advantage, and would rather not that their competitors have the same advantage.

...which I've been suffering with for years. Am I the only one who finds their offerings to be clunky, quirky, and inefficient?

If you mean "free" with a small letter look at the "free" versions of Allegro CL (Franz Inc or LispWorks (). Been working for four years with a (commercially licenced) Allegro CL and it simply rocks because you get all benefits of LISP with a modern IDE which you can enhance yourself (Personally I don't like Emacs, especially on Windows)

For server side scripting use AllegroServe, an opensource web server for Common Lisp. It's been ported to lisps other than ACL, too. (I don't have the links to those URLs handy. Can someone please post them?)

Let's not forget: AllegroServe, a kickass web server for lispers.

There doesn't need to be. You can write all your your GUI's in Java and use them from lisp with jLinker (in Allegro CL).

Don't forget Allegro CL Trial Edition, which is also "free".

The most interesting thing about your ignorant reply is that lisp is most often used by HUGE projects. The teams that build these programs invariably say they couldn't have done it without lisp.

The first such example of this was Macsyma, built in the 70's on Mac Lisp, ported to the Vax on top of Franz Lisp (from UCB). Macsyma was an incredible large program for that day and time. It took hours to compile on a Vax. It was also considered an incredible advanced program for the time.

DEC even used Macsyma to validate new Vax hardware (like the MicroVax), because it was, simply, the most complex program that ran an a Vax.

Lastly, there are lots of corporate success stories. Check out http://www.franz.com/success/ for data points on this.

• http://www.franz.com/products/
• http://www.xanalys.com/software_tools/products/ide .html

More Lisp vendors:

• http://www.digitool.com/ (Mac)
• http://www.corman.net/

'Free' (whatever the current definition of that is nowadays) Lisps:

• http://clisp.sourceforge.net/
• http://www.cons.org/cmucl/

As for type declarations, they're there both for speed and correctness. The optional type declarations in CMUCL can serve both purposes. There is a tradeoff here: on the one hand, the need to keep track of the type information is a burden on the programmer when it is inessential to the logic of the program; OTOH, compiler needs this information to produce compact code and sometimes, catch errors. I like the CL's approach the best: it provides you with the option ONLY when you need it. Also, when programming in CL, I find type errors are rare; most bugs are logical.

Python is a very nice language, especially for beginners. But I doubt anyone who know CL well will prefer Python over CL. The expressiveness, the flexibility, the speed, the maturity of compiler and runtime system technologies; those are enough reasons for me to stick with CL.

As an aside: I like Python, and I've been watching Python's development for a while; however, I've yet to see a PEP (Python Enhancement Proposal) which cannot be implemented *within* the language in CL with a page or two using Macro, MOP, etc. Therefore I concluded that it is much less effort to bring libraries to CL, than it is to bring Python up to the level of CL in terms of language maturity.

In short, I think it is much easier to find happiness in CL! I believe most people will feel the same, too, if they're persistent enough to master the few beautiful concepts underlying the design of CL.

Which book do you have? It may or may not be a good place to start. (Graham's own ANSI Common Lisp is a good starter.)

There are plenty of good implementations. XAnalys Lispworks, Corman, and Franz have free trial versions of their environments which are suitable for learning. Also CLisp is a free (GPL) Common Lisp for Windows. All of the preceding except for Corman are also available for various Unices (although there may well only be free trial versions for Linux), and CMUCL is also available there. You'd be hard pressed to go too far wrong with any of those (I use Lispworks for most of my work and like it).

...I only got into Lisp a few weeks ago, but already the flexibility of the language is paying-off. I find the development of my code is much more rapid and "hands-on" - I'm able to spot logical errors and specific code flaws as I write them, rather than days or weeks down the line. Well - I won't rant, but I've found that the best IDE for my purposes is Franz's Allegro CL Franz also has an interactive Lisp course linked from their site.

Allegro CL, like implemented by Franz , is _extremely fast_. It is compiled, you can "live on top of the compiler", ie. interactively compile a function and disassemble it.

You can either ignore types, or at the end of a project, optimize it with more specific types (ie define vars/members as floats etc). The hard part is third party libraries, but CL does have a hell of a lot of libraries SPECIFIED IN THE STANDARD. Yes, it has a standard. It also has OO, CLOS, which is a very flexible OO-implementation.

And if you didn't know, check out this:

the control software of the Deep Space 1 (DS1) spacecraft, which is written in Common Lisp, has been chosen together with another system as NASA's 1999 Software of the Year.

Many of them do, although as always, it depends on what you want to do. For Scheme, consider something like DrScheme. For Common Lisp, both Xanalys and Franz have good commercial environments. And these are just examples. Further, it's usually fairly easy to use at least C code from these languages, so the amount of code available is greater than it might look at first. I don't know as much about the statically-typed side of things, but from what digging around I have done there, I think that there is often a reasonable amount of stuff available there too.

At any rate, I certainly find that my Xanalys Lispworks environment gives me everything that I need to do a lot of the programming that I need to do.

In the Free world, CMUCL has kernel-level threads support (for FreeBSD and Linux), but only in the current development versions.

In the commercial world, Franz's Allegro CL has OS-native threads on Unix, Linux, and Windows.

One of the advantages of Lisp is that it makes it very easy to get working code written very quickly, giving you time to change your design if need be, and to go back and optimize only the parts of the code that need it (no point optimizing code that gets run .001% of the time). One of the disadvantages is that it makes it easy for poor programmers (or naive Lispers) to write amazingly inefficient code that works correctly. But well written Lisp runs comperable to or faster than C++. Both CMUCL and ACL compile to the native architecture, of course.

just had to point out that Square used Allegro Common Lisp for the movie. The link below has a nice discussion about why they chose Common Lisp and has a picture of the cool photo realistic computer graphics they have in the movie. http://www.fra nz. com/success/customer_apps/animation/squareusa.php3

One big theme I notice in all the comments on this topic: Functional languages didn't take off because there are (were) no good implementations.

Wrong.

I will speak only about Common Lisp and its direct predecessors, because of all the functional languages I know it is the most flexible and useful for real-life development.

In the 1970s and 1980s there were Lisp Machines. Read up on them sometime---I claim that they were the most advanced and powerful workstations of their time. They had graphical development tools and environments that were mere dreams in the minds of other programmers at the time. They had hardware specialized to run Lisp, and they did so very, very well. Lisp Machines (Symbolics et al.) went out of fashion at around the time when general-purpose hardware began to pick up a lot of momentum and the personal computer began to gather popularity.

Their place was taken by implementations of Lisp running on workstation-class computers. Digital, Sun, IBM, and HP boxes all had third-party Lisp implementations. Most of these implementations are alive today, and available for most UNIXes, as well as Windows and MacOS. These would be Franz Inc.'s Allegro CL, and Xanalys' (formerly Harlequin) LispWorks. Both are robust and powerful. In fact, well-written Lisp will outperform comparable C code with either of those compilers. The real issue here is that there are no free Lisp implementations that compare to the commercial offerings in quality and ease of use. There are CMUCL and CLISP, but neither holds a candle to ACL or LispWorks, for example.

The lack of popularity of functional languages stems mainly from ignorance. As several other people have pointed out, it takes some effort to learn the paradigm, and most people, even those with CS degrees, do not choose to make that effort. Lisp hackers tend to have a strong background in language theory and other topics too complicated for the average ``geek'' whose competence ends at some Perl shopping cart script.

All the three bigger vendors (Franz, Xanalys and Digitool) provide advanced graphical IDEs. Unfortunately there is no free IDE per se as far as I know, but Xemacs with ILISP makes for a pretty nice environment for the free Common Lisp systems.

If you'll excuse me ranting for a bit, but I find it baffling how many people seem to think that if they haven't heard about something, it doesn't exist. Even rabid users of obscure operating systems turn their brain off when it comes to programming languages, industrial applications of computers, and what not, and loudly proclaim that the most popular choice is the only choice.

The world is a big place. There is an enormous number of multi-billion dollar "niche" markets you have never heard about out there.

Maybe he should look at http://www.franz.com/apps/gd.main.html for a sample of what's being done with this "research topic"

~~~~~~~~~
auntfloyd

CL has several advantages over both Perl/Python and C/C++.

• Like Perl and Python, Lisp provides an interactive environment. You can make changes to a running program without having to restart it. Plus, modern Lisps give you a real garbage collector, not a simple reference counter like in Python (although newer versions of Python may have a better GC).

• Like C/C++, Common Lisp is compiled. Unlike C/C++, CL allows you to call the compiler interactively---again, you never have to restart your program. Compiled Lisp code is about as fast as comparable C or C++ code. In fact, most interactive environments compile code on the fly as you type expressions in!

• Like Python and C++, Common Lisp also provides a robust and rich object system, called CLOS. I haven't done much with CLOS, although I like the idea of multiple inheritance and the ability to dispatch methods based on more than one object (Lisp methods and generic functions can dispatch on any of their arguments).

• Unlike C and Perl, Lisp is pretty clean, syntacticly. You never have to remember operator precedence or any of the funky variable naming rules. Lisp is case insensitive, although it is pretty easy to override this.

Several Lisp environments are available, both commercial (Franz, Harlequin) and free (CMU Common Lisp). There's a complete web server written in Lisp, the Common Lisp Hypermedia Server. If you want to learn more about Lisp, check out the Associate of Lisp Users and browse through the section on tutorials and books (a good book, by David Lamkins, is called Successful Lisp).

Not all is happy in Lisp-land, though. There's no archive network like CPAN or CTAN, so you'll have to go digging when you want a regexp package (although I can tell you to look at SCSH for that). While commercial Lisp environments from Franz and Harlequin are available on Windows, the only free Lisp I know of that has been ported to windows is Clisp, which "only" has a byte-compiler (like EMACS). CMU CL, the best free Lisp around, only runs under UNIX. I also don't know of an equivalent to mod_perl that embeds Lisp in Apache, although if you use CL-HTTP this isn't an issue. Still, Lisp may deserve your attention. As old as the language is, Lisp is still years ahead of its time.

You ask the wrong questions. Lisp is not used to solve common problems, people gravitate towards Lisp because their problems cannot be solved by the 'common' languages.

Anyway, take a look at:

• www.franz.com (the "applications" link)
• Lisp on the Deep Space 1 spacecraft
• Why Lisp?
• Lisp 'portal'

Full disclosure: I'm doing contract PR work for Franz. Stories like this are like candy to me. :) --Tom pr@franz.com