Forgot your password?
Programming IT Technology

Using Lisp to beat your Competition. 418

Posted by CmdrTaco
from the interesting-stuff-people dept.
kovi writes "Paul Graham, the guy who developed what finally became Yahoo!Stores (and made him $50 million richer) wrote an article that explains how he used Lisp (the infamous programming language) as a competitive advantage against the competition. As a bonus: thoughts on startup experience." Its in pdf, but its actually worth a read. Very nifty.
This discussion has been archived. No new comments can be posted.

Using Lisp to beat your Competition.

Comments Filter:
  • by Anonymous Coward
    Try [] for the English version.
  • by Anonymous Coward
    The sorta portal site for lisp: []

    Here is a list of online books and references which I found useful:

  • by Anonymous Coward
    A Link [] so everyone can read it and know, yes it is.
  • by Anonymous Coward
    Historical note: LisP is an implementation of the *lambda calculus* (just as SQL is an implementation of the relational calculus). Lambda calculus is a wierd reverse-Polish notation function language that I think mathematicians may have invented before they even had decent computers to run it on. I think lambda calculus was one of the original 'paradigms for computation' that was shown to be equivalent to Turing machines and Finite State Machines by the "Church-Turing hypothesis". There is lisp-optimized, lisp-based processing hardware out there -- powerful stuff. Personally I think any algorithm involving recursion, parsing, and composing is more straightforward in lisp than pretty much any other language. But there's a learning curve--all those parenthesis are intimidating and I think this is the single biggest reason lisp isn't a more dominant language today. I think someone else here compared the moment of nirvana when they suddenly understood lisp to that scene in the Matrix where Neo suddenly sees the Matrix underlying everything. There is indeed something semi-mystical about how much more clearly I saw algorithmic programming after I'd done it in LisP. And it's a fun language to program in.
  • by Anonymous Coward
    It is much easier and more efficient to write the first implementation in Lisp and then translate to C++ when the Lisp implementation is pretty much frozen, when compared to designing and writing the final product in C++ from the start.

    Read Graham's books to understand the real reason why, but one of his more potent analogies is sculpture. When you want to make a sculpture in bronze, you first make one in clay which is an extremely flexible and responsive medium for sculpture, and then you use that clay model to create a mold in which the final bronze sculpture is then cast.

    You *cannot* start in bronze. It is far too inflexible.

    It's the same thing with Lisp. If you are trying to solve a problem that is ill-defined and incompletely specified, like most problems are, you need the flexibility of Lisp to solve the problem efficiently. Then, when you understand the problem well enough to have written the Lisp program, then the Lisp program is sufficient as a specification for a C++ implementation.

    With C++, for example, you need to develop a rigid set of classes before you can do anything. Changing that set of classes on the fly is tremendously painful.

    In Lisp, you can pause the program execution, REDEFINE a class, and CONTINUE EXECUTION, providing a method to AUTOMATICALLY TRANSLATE the instances of the old class into instances of the REDEFINED class as they are encountered. That's object oriented power. No half-hour recompile, no restarting the program, if it needs to be changed you change it. While you are paused, you can write as much Lisp code as you want, interactively testing your implementation to make sure it does what you want.

    You C++ guys have no clue what you are missing. Luckily, Paul Graham wrote two books to clue you in: "ANSI Common Lisp" and "On Lisp." Read them, and you'll never want to go back.
  • by Anonymous Coward
    People have actually done some experiments at moving Emacs to a more modern lisp, but it would be a hell of a lot work for relatively little tangible gain. I believe RMS has a long-term plan to move Emacs on top of GUILE Scheme.

    Modern commercial lisp systems come with their own IDEs and integrated editors. Modern free lisp systems are typically used as subprocesses behind Emacs, which is surprisingly comfortable in itself, and with the ILISP emacs package actually resembles very much an IDE.

    Your final comment about converting Emacs Lisp to modern lisp is not far out at all -- people have done that. The problem is converting the reams of C code and libraries that Emacs uses, and which are closely tied to the internals of Emacs lisp the language. Besides, most of the packages available for Emacs lisp make many limiting assumptions that thwart the advantages of changing only the underlying lisp systems -- for example, no one has paid any attention to thread safety since Emacs lisp can only run single threaded.

  • by Anonymous Coward on Tuesday May 01, 2001 @11:04AM (#253041)
    Two words: tail recursion. Just as you wouldn't write the above code in C due to inefficiency, LISP programmers learn how to ensure that a function will be properly tail-recursive, and thus execute without chewing up a bazillion stack frames.
  • by Anonymous Coward on Tuesday May 01, 2001 @12:58PM (#253042)
    Graham []'s comments about the power and ease of Lisp are similar to Schwartz []'s comments on Perl (and perhaps Tim Peters []'s on Python). Each is an extreme expert in the language, and each can perform tasks well beyond most people's capabilities. His opinions are based on that level of expertise, and his observations may not apply to people with less experience.

    The fact that he took notice of Perl- and Python-using competitors is significant. He views those languages as being nearly as powerful as Lisp; their main deficiency is that their syntax isn't ``easily extensible.'' Both possess means of extending syntax, but the revealed expressive power is handicapped by the languages' definitions.

    Lisp macros work directly on Lisp objects, which exist after parsing but before compilation. Perl mostly lacks that middle ground (or rather it has 12004782 different middle grounds, depending on how you look at it), and Python's AST [] system is terribly difficult to use (and somewhat non-portable). Both of those languages treat syntax extensions as black magic; Lisp makes them everyday tools.

    Lisp does have its problems. The package system is slightly obtuse, and the inheritance scheme in standard CLOS is completely busted []. And it's only as portable as its implementations. The free Common Lisp implementations that run on many platforms are interpreters. The compilers run on a very restricted number of platforms. And there's no equivalent to CPAN []. But it's still worth a look.

  • Actually, the most famous LISP app is probably AutoCAD, which many people outside of Unixy circles have heard of. Not only that, but AutoCAD's use of a LISP dialect for macros has proably resulted in more people becoming LISP programmers than anything else - all those drafters, engineers and whatnot who don't realise LISP is supposed to be hard and obscure and only for academics.

  • Another program that uses a Lisp like language (actually Scheme IIRC) is the Gimp. Maybe you've heard of it? :)

    Functional languages have some useful properties that can make some things really easy and fast (recursive list processing algorithms for instance).

    Unfortunatly, most functional programming languages are toys that sometimes get used in big projects. Before anyone flames me to a crisp, I'd like to point out how bad the I/O is in Lisp, and how hard it is to properly handle the myriad possible errors a program has to handle gracefully when working with humans. Also, most lisp engines I've seen are interpreted (save for things like the Lisp Machine). Now this doesn't prevent you from doing very powerful very high level things with Lisp, but for the most part you can do them easier and faster with C, also it's nigh impossible to do very low level things with Lisp (At least from with what's available). Lisp is truely the language of the theoretical math major.

    Please hold on until I finish donning my asbestos underwear, thank you.

    Down that path lies madness. On the other hand, the road to hell is paved with melting snowballs.
  • Ummm... maybe you missed what he was talking about. This is an application for making online stores -- not a store itself (though I suppose it is that too). This is in line with WikiWiki, or some of the homepage builders that have come about. It's not a shopping cart application.
  • This story isn't about Lisp being used for a kick-ass user interface or a 3d engine because (IMHO) Lisp isn't as well suited to those things.
    This story is all about a user-interface (over the web). This story isn't about applications deployed client-side, and it isn't about applications that are redeployed to local programmers (e.g., SQL), and it isn't about applications that have very high performance requirements (e.g., 3D). I think it's unfair to say Lisp isn't good at UI, though.
    Anyhow, having said all that, could someone who knows Lisp better than me explain what it is about Lisp that makes it so good for AI?
    It's nothing magic -- there's not really any particular fancy features that make Lisp and AI go together (unlike, say, Prolog). In part it is tradition -- currently there may be other languages just as capable of Lisp, but when it all started there wasn't.

    The real reason Lisp and AI go together is because Lisp is a very high level language, and as such is very good for prototyping and experimentation. In AI research this is very important, while the ease of deployment is very unimportant. Lisp scales into complexity well, and you can fit pieces together well. Lisp is just a good language.

    The reasons it is good for AI are all the reasons that it is good for server-side web development. That said, I think there's other languages that are just as high-level (or higher). Smalltalk, in particular, is just as high level as Lisp if not higher. I say this not because of the features that Smalltalk has compared to Common Lisp -- in fact, Smalltalk as a language has only a handful of features, and CL has very thick books worth of features. I think the author was wrong to say that languages are good just because of features. But Smalltalk does everything CL does without features, and if that doesn't make it higher level, it at least makes it wiser.

    I really like Python, but I can't claim it's on that level.

  • To give that quote in context:

    Our plan was to write software that would let end users build online stores. What was novel about this software, at the time, was that it ran on our server, using ordinary Web pages as the interface. (...) as far as I know, Viaweb was the first Web-based application.

    I think in that context, his statement seems much more reasonable. The Xerox map server is not nearly as interactive, or as stateful, as what he was doing. There was a novelty to it.

  • by Ian Bicking (980) <> on Tuesday May 01, 2001 @10:42AM (#253053) Homepage
    I think Scheme might be a better place to start, whether or not you go on to learn Common Lisp. The basic syntactic trauma of Lispish languages is softened by the small size of Scheme, and nearly everything you learn in Scheme will apply to Common Lisp.

    In a funny sort of way, while Scheme isn't used for many large projects, it's nearly as alive as Common Lisp -- which is to say, not very alive. Scheme is more popular in Academia at this point, in large part due to the book Structure and Interpretation of Computer Programs, by Abelson and Sussman, which is a great book for learning to think differently about programming. It's the standard introductory text for programming at MIT.

    Common Lisp is far more practical than Scheme. It has every feature you would want to use, and many features that you would never want to use (e.g., dynamic scoping). It was designed by committee by smushing a bunch of previous Lisps together, and it shows. But it actually has a lot of useful code for it, and a lot of useful features.

    Scheme is designed by a committee of mathematicians posing as computer scientists, and that shows too. Common Lisp has an ANSI standard, Scheme has a strong standard that is only endorsed by convention and the academic credentials of the committe. It's an interesting difference.

    Common Lisp is also interesting in part because of its rather novel object system, CLOS. It implements what's called a Meta-Object Protocol, and is supposed to be very Deep (though I haven't used it myself). It uses a style of generic programming, as opposed to object methods -- it looks reminiscent of C++ function overloading, but is somewhat more general (arguably more general than methods). There are comparible object systems (e.g., TinyCLOS) available for Scheme, but not generally built into the language.

    Common Lisp has been used more in AI, where Scheme is a more important foundation for language design.

  • What was novel about this software, at the time, was that it ran on our server, using ordinary Web pages as the interface.

    Um, that's EVERY web application ever written. It doesn't make his statement any more reasonable. It was a shopping cart application, just like everybody and their dog was writing by that point.

  • by Masem (1171) on Tuesday May 01, 2001 @11:23AM (#253056)
    So Yoda was a Lisp Master!
  • When I was in school the scheme class was about the hardest class you would get as a CS undergrad, and it was what you got *FIRST*. They figured if you could do that class you probably could do the entire CS major. And if not best to find out now so you can go major in something else while you still have time.
  • You know the strange thing, now almost 10 years latter this morning I hit a problem and my first thought was that the Ableson & Sussman book from that class would probably be the right book to have handy, To bad my copy is at home. And yes Brandeis was a bit heavy on theory. But they did teach me rather well. In both CS and Physics.
  • I think every programer should learn lisp or scheme. It is very different from the Perl/C/Java that we spend most of our time working with. Since it is so different while programing in scheme you tend to come up with very different ways to solve problems. Once you know how to solve problems like that you can if needed take those ideas and move them back to Perl/C/java or whatever.

    But learning to think differently is something that is definitly worth it!
  • On the other hand, CL's huge library makes it an enormous project to implement, whereas Scheme can be implemented in a weekend.

    Someday someone will write a good CL library in Scheme, and we'll all be happy, except for the people who want to know the truth value of the empty list.
  • by iabervon (1971) on Tuesday May 01, 2001 @12:02PM (#253062) Homepage Journal
    Yes, in the last 30 years, the C language family has finally gotten as slow and large as the Lisp family has been all along, and now processor speed and memory size have gotten up to the level needed to do things usefully in Lisp.

    You have to respect a language which is so much ahead of its time that it can compete with languages developed decades later, even if it was too slow for most applications on most hardware in the intervening time.
  • by Christopher Cashell (2517) on Tuesday May 01, 2001 @02:36PM (#253065) Homepage Journal

    Well, Lisp isn't really based of anything, at least, not off of any other programming langauges. It is based on the concept of the Lambda Calculus, which is something of a way to describe programs in a mathematical way. Or, something like that. <g> Honestly, I've never gotten a great definition of lambda calculus, but I'm content that Lisp is cool. ;-)

    Now, as to why you haven't heard of it before, my guess is because you are either not a University Computer Science graduate, or you haven't branched into functional programming. Most universities will cover it at least very briefly in some sort of programming languages class, though rarely do they do it justice.

    As for functional programming, it's a programming paradigm, like imperative or object oriented programming. It tends to be very powerful, often makes use of constructs which are terse (fewer lines of code to do the the same thing than required in other langauges) and generally makes extensive use of recursion.

    Lisp is very interesting, however. Even though it is usually thought of as a functional language, it actually provides excellent support for functional, imperative, and object oriented programming. In fact, many people think the Common Lisp Object System (CLOS) is one of the best Object Oriented Programming implementations available. It was also the first object oriented langauge that was standardized (by ANSI or ISO, I don't remember for sure which one).

    It's also been around for a while. In fact, Lisp is one of the oldest programming langauges still in somewhat common use today. (The only older language being Fortran, which predates it by about 5 years, as I recall.)

    If you've never had any experience with functional programming, I strongly encourage you to investigate and study[1] it a little, even if you never really use it, because you will learn a great deal about programming in general for your time invested.

    Now, as for what applications have been written in it, the canonical example is GNU [] Emacs []. At it's core, Emacs is basically a lisp interpreter, and most of the editor is then written in Lisp.

    While applications that are written entirely in Lisp are perhaps not as well known, one of the most common places to find Lisp is as an extension language for other programs. Here are a handfull that make impressive use of Lisp:

    The GIMP [] uses Scheme, a dialect of Lisp for it's Script-Fu, which can be used to programatically execute anything that can be done by hand.

    Autodesk [], the makers of the industry leading CAD software AutoCAD [] use their own dialect of Lisp, called AutoLISP, for programming and customising the AutoCAD software.

    Siag Office [] is a free small, Open Source, and very impressive, Office Suite making extensive use of Scheme. (SIAG == Scheme In A Grid). It includes a very cool Spreadsheet program, as well as others, and is highly customisable.

    GnuCash [] makes use of the Guile library to provide Scheme as an extension and scripting language for the application.

    Speaking of Guile [], Guile is the official extension language library of the GNU project. Using Guile to provide Scheme scripting, you can add support for scripting and extensibility to any application. Guile is used in many applications including GnuCash (mentioned above), the SCWM [] Window Manager, the TeXmacs [] editor (integrating Tex support into an Emacs like editor), and many others.

    One last example is the Sawfish [] Window Manager, which seems to be among the most popular Window Managers around these days. It makes use of an Emacs-ish philosophy, having a very small core program, including a lisp interpreter, and implementing most of its feature set on top of that with lisp.

    This is, of course, not an exhaustive list of applications written in, or making use of, Lisp, however I think everyone here will prolly recognise a few names there. ;-)

    [1] If you're interested in learning more about Lisp, I strong suggest you take a look the book Structure and Interpretation of Computer Programs []. The full text is available online at the link here, and it is one of the best books ever written about Computer Science. It's also used as an early CS text book at MIT [].

  • The turn-off for me was his statement that high-level languages are inherently "more powerful" than low-level languages. I guess that he's using a definition of "powerful" that varies substantially from the standard CompSci meaning. Lisp, C++, Assembler, and Perl are all Turing-complete. End of story. If you can implement something in one, it can be done in any of the others. One may be easier to manage than another for a specific project, but that is completely different than saying that it is "more powerful".

    The author could use a little more CompSci theory before making such grandiose claims. I, for one, had difficulty reading further into the article once I had read that misstatement and realized that he did, in fact, mean exactly what I originally thought he said.

  • NO, he did not mean what you orriginally thought he said. He did not say that one language can accomplish a task which is impossible in another language; rather, he said that one language (like LISP) is better at doing certain things than others (like C). Perhaps he should have called this elegance, or utility, but please don't confuse a mistake in labeling with a mistake in reason.

    On a different note, CmdrTaco said, "Its in pdf, but its actually worth a read." I have two problems. First, the two instances of "its" should be "it's," because the words are contractions for "it is," not the possessive pronoun. Second, why the implication that PDFs are not, in general, worth the read? Because they look identical on multiple platforms and allow the author to get exactly the result they want? Oh, the horror...

  • by David E. Smith (4570) on Tuesday May 01, 2001 @10:11AM (#253071)
    Why wait for Google [] to find it, just so you can read the essay in plain text? Don't! Here it is [] already. And since the Web server seemed a bit sluggish, perhaps in anticipation of the /. Effect, here's a mirror of the PDF [] original. Enjoy.
  • Why should I learn English as a whole when I can just learn American English and spelling?

    Sarcasm aside...

    Scheme is a very reduced subset of LISP, designed for teaching functional language programming. I'm probably wrong, but I don't believe there are any 'real' programs written in Scheme, outside of teaching examples and such.

  • Huh? Not liking LISP because of the parens is like saying I don't like you because you have too many freckles....

    But seriously - use an editor that matches your grouping structures (parens, braces, etc). EMACS does this, as does Vim and a whole crapload of editors.

    LISP is confusing. Most definitely. However, C++ and Perl were confusing to me when I first saw them, too. LISP is completely bass-ackward from every otehr language you've seen before. Where as in C and Perl, you have all these nifty notations for denoting objects and references and such, you have none of them in LISP. Why? Because LISP programming _is_ programming with objects, as opposed to programming in C or Perl, where you can program in an OO way, but OO is not inherent in the language or the syntax of the language.

    My first year of college was Scheme and LISP, then another semester my senior year when I took an AI course and programmed my computer to play Mancala (my computer beat me about 1 out of 10 times, and I wrote the gamespace interpreter). When I started, I said the same thing - (What's (up (with (all (these (parens))))))! But after I started formatting my code in a way that was understandable to me, I could 'see' the program just like Neo 'saw' the Matrix and Perl Hackers 'see' JAPH's.

    That being said, I would disagree with the thought that you should use LISP because it's the most powerful language out there. In fact, it's not for something like graphics programming. However, if the application you are working on can be broken down into a number of objects, and actions on said objects, then there's a 90% chance that LISP would be an excellent choice for your programming language.

  • Great, now we're going to see a wanton proliferation of uppity programming languages.

    What next? A decent application for Forth []? Ada? Eiffel? C++? Oops. What that out loud?

  • Why doesn't someone start another Lisp-based OS? I mean, Unix has been reimplemented so many times... If Lisp is so appropriate for rapid development, why hasn't a Lisp OS ever resurfaced?

    I think it would be wonderful.

  • The only drawbacks to Haskell is that it is new and less people know about it and know how to use it. Many universities also do not teach Haskell because, again, it is too new.

    There are also few high quality implementations (as in "generates extremely fast native code" and "has commercial support options") out there ... Also, try to find good Haskell programmers in your area. I'm having trouble even finding a Perl expert ...

  • Anyone out there with a licence plate that says
    'CDR CAR'?
  • A large number of messages in this list have been marked funny. Is the age of a language proportional to the number of jokes that people have invented about it?

  • by xyzzy (10685) on Tuesday May 01, 2001 @10:07AM (#253089) Homepage
    You seem to be using an older dialect of Lisp. I think you meant

    (lisp (taught (me (to (count (parenthesis))))))

    or maybe

    (count parenthesis)))

  • by grub (11606) <> on Tuesday May 01, 2001 @09:43AM (#253091) Homepage Journal

    Unfortunately the author comes across as almost a "Lisp apologist" which may turn people off from looking at Lisp.

    Would anyone know if his co-author Robert Morris is the same Robert Morris (or his father) of the infamous Morris internet worm from the late 80's?

  • by Disco Stu (13103) on Tuesday May 01, 2001 @09:41AM (#253095) Journal
    What is "Lisp" based off of? Is it a C++ style code or something else, and why have I not heard of it before?

    Lisp is a functional programming language. Since you haven't heard of it, I'm betting you that didn't major in CS at a University. Lisp (along with ML and Scheme) is dearly loved by theoretical computer scientists.

    To find sample Lisp code, just do a Google search. It is very different than procedural languages lilke C, Java, etc.

    Prolly the most famous application using Lisp is Emacs. In fact, some people refer to Emacs as nothing more than a Lisp interpreter that includes some macros that are really good for text editing. Most people I know outside of academia that program Lisp do it to customize Emacs.
  • by nosferatu-man (13652) <> on Tuesday May 01, 2001 @10:05AM (#253100) Homepage
    Scheme is much prettier than CL; it's breathtaking in its conceptual purity. And it's the foundation for the best book on programming ever written.

    One of the strengths of CL is that it has a large and comprehensive standard library, and tons of clever bits that make a working programmer's life easier.

    In other words, learn them both!

  • by sammy baby (14909) on Tuesday May 01, 2001 @10:53AM (#253105) Journal
    Graham tries to make an argument that some languages are better than others. That's an abstract enough statement on the face of it that it's hard to take real offense. He quickly backs off from saying anything really controversial, though, because "Programmers get very attached to their favorite languages, and I don't want to hurt anyone's feelings." So, to illustrate his argument, he creates a cute little straw man, sets him up, and knocks him down.

    Programmers get very attached to their favorite languages, and I don't want to hurt anyone's feelings, so to explain this point I'm going to use a hypothetical language called Blub. Blub.. is not the most powerful language, but it is more powerful than Cobol or machine language.

    When we switch to the point of view of a programmer using any of the lan-guages higher up the power continuum, however, we find that he in turn looks down upon Blub. How can you get anything done in Blub? It doesn't even have y.

    So, what the hell is Y? If you're a Java zealot, you might say that it's strong typing and bytecode portability. Of course, a C nazi would want to tear his hair out because of how "limiting" all that strong typing is, and how infernally slow the produced code is. Meanwhile, Python geeks will sing the praises of syntactically signifigant source-code formatting, ML nuts will talk about how nifty it is to have your whole program look like it's written in EBNF [], and Perl monks will spout off huge strings of acronyms which all serve to hilight the Swiss Army knife nature of their language.

    In other words, by failing to take a stand on what makes some languages better than others (other than the bland assessment that the addition of lexical closures in Perl 5 was a good thing), he succeeds in avoiding offense, but utterly fails to say anything useful. "Power" becomes a catch-all abstraction, like a D&D stat, and nobody gets to argue about what features they actually want in a hypothetical uber-language, because that might get someone's panties in a bunch.

    And now I'm grumpy because I stopped to write this out instead of studying for my Distributed Object Programming final tonight. Feh.

  • by cpeterso (19082) on Tuesday May 01, 2001 @10:53AM (#253107) Homepage

    Many "modern" functional languages, like ML and Haskell [], have strong-yet-polymorphic typing and all of the functional abilities of Lisp. Of course, these languages suffer from a derth of libraries, too.

    Of course, this is a COM interface for Haskell called Haskell Direct [], allowing your Haskell program to call COM and ActiveX controls. This work was done by someone in Microsoft Research and wrote a paper about it humorously titled "Calling Hell From Heaven And Heaven From Hell." ;-)
  • by Black Parrot (19622) on Tuesday May 01, 2001 @09:46AM (#253110)
    > What is "Lisp" based off of? Is it a C++ style code or something else, and why have I not heard of it before?

    Actually, it's one of the oldest computer languages still in (semi-)common use. Vintage 1958, IIRC.

    > What are some other "famous" applications that are using Lisp?


  • by Black Parrot (19622) on Tuesday May 01, 2001 @09:48AM (#253111)
    > Lisp (along with ML and Scheme) is dearly loved by theoretical computer scientists.

    Theoreticians do love functional languages, but Lisp is primarily popular among AI researchers.

  • by Black Parrot (19622) on Tuesday May 01, 2001 @01:57PM (#253112)
    > Now that XML is around and the world is saying it?s the greatest thing since sliced bread - I have an analogy.


    I have an as-yet unreleased OSS project that I tinker with when time allows. Last summer I implemented an XML system for storing external data. My thoughts upon reviewing it: Ugh-ly!

    Since then I have ripped out all the XML and replaced it with GUILE [= Scheme = a dialect of Lisp = on topic], and I find that it's much cleaner, more readable/maintainable, and incredibly easy to parse. As a free bonus, now that I've started on the user-level scripting part of the application, I can load Scheme code directly from my config files and use all the pattern matching / symbol substitution / code writing stuff that Lisp and its ilk are so good at.

    YMMV, but it sure as heck works for me -- as a data language, a data-description metalanguage, and a scripting language.

    As a side note, interested parties might want to investigate the use of a Lisp-style language by Xconq [] for specifing game variants.

  • by tbmoore (19869) on Tuesday May 01, 2001 @10:59AM (#253113)
    Okay, with that out of the way -- yes, we have a little bit of Lisp code here. No, this was not a good idea, and no it is not a good way to get rich in the future. I have it on good authority that every single scrap of Lisp code we have is quickly being rewritten from scratch in C++, because there are so few engineers competent in Lisp here (read: zero).
    Well who's problem is that? If Yahoo! claims that it's impossible to hire competent Lisp programmers, then they aren't trying very hard at all.

    It was a good idea for Graham to write the system in Lisp - Yahoo! bought his company and made him a rich man. Sounds like Yahoo!'s IT is in a pretty wretched state if it can't maintain a system in which they invested millions of dollars.

  • by Mr T (21709) on Tuesday May 01, 2001 @11:38AM (#253115) Homepage
    Lisp is, it's not based off anything. It has no syntax, you program directly in abstract syntax trees.

    Also, it's not functional like someone tried to point out. You can use it like a functional language but generally it isn't.

    It's good stuff, you can't say your a real CS guy until you've done a fair amount of lisp.

  • by Merk (25521) on Tuesday May 01, 2001 @10:23AM (#253119) Homepage

    I know a bit of Lisp -- I love Emacs and wanted to be able to customize it more, so I played around with Lisp. I learned enough to do some pretty cool things, and learning Lisp has taught me a lot about programming in general...

    But I'm not convinced that Lisp is the "highest level language of all high-level languages" or "the most powerful of all high-level languages". In a sense that is probably VB. It is the one that removes the programmer from the actual workings of the CPU the most. Unfortunately it's also a language that's horribly designed in a lot of ways. I think Lisp has some very powerful features like macros that other languages lack, but it loses out in other areas.

    Lisp code is hard to read for most programmers, one big reason for this is that the condition in a conditional statement can be 10 lines long, and 5 parentheses deep. Because of this, finding a bug in a Lisp program could take longer than finding on in a procedural program. Secondly not many people speak Lisp. Like Esperanto, something can be wonderfully designed but if it isn't widely used it's not going to be too useful.

    I think the main reason their software was so successful was that Paul Graham et al. were extremely good coders developing in a high level language they knew very well, that was well suited to what they were trying to do. This story isn't about Lisp being used for a kick-ass user interface or a 3d engine because (IMHO) Lisp isn't as well suited to those things.

    As has been said many a time before -- "Use the appropriate tool for the task at hand".

    Anyhow, having said all that, could someone who knows Lisp better than me explain what it is about Lisp that makes it so good for AI? I've always heard that but being pretty far removed from that field I've never seen any cool Lisp AI code.

  • by Merk (25521) on Tuesday May 01, 2001 @01:02PM (#253120) Homepage

    I think you misunderstood what I was saying. Obviously in this case things worked out in this case, I'm talking about the more general cases.

    The main problems I see with Lisp aren't problems with the language, they're with how widely it's used. This affects 2 areas most:

    • The availability of programmers who know it
    • The availability of 3rd party libraries and tools

    If I went up to my boss and suggested we do our core products in Lisp he'd almost certainly reject the idea. Even if we had a few programmers who knew Lisp really well, if someone quit or we needed to expand, finding people who knew Lisp well enough to join the team would be really tough. Plus we do a lot of things in languages with huge libraries of useful code. It sounds like these guys avoided this problem by not having to hire new people and by concentrating on an area where they didn't need many external libraries.

    If I'm going to write a tool to use on my own I'll do it in whatever I feel like using. Perl for text manipulation, C for speed, Java for cross platform stuff, PHP for web stuff... As soon as the project becomes big enough I have to worry about whether other people around me know enough of the language I'm using to contribute. And if I'm going to write a client-side GUI program I'm going to do all I can to avoid using low-level GUI API calls if I can just use a wrapper library.

    Something doesn't have to be very popular to be good (i.e. Linux), but for certain things popularity is important (i.e. availability of Linux games).

    And I admit I can read procedural code in nearly any language (not Perl) easier than I can read Lisp. A big part of that is due to my having more experience with procedural languages, but I think some of it is just the nature of the language. I think most people would find that it's much easier to keep track of the level of indentation than the depth of parentheses (but hey, maybe that's just me).

  • by delmoi (26744) on Tuesday May 01, 2001 @07:22PM (#253126) Homepage
    Ok, Java might not have Scheme support, but writing scheme interpreters in java is pretty easy, and lots of people have done it. But what's cool about the way java works is that It's very easy to call objects in java dynamically using the reflection API. So, in theory (and in most cases practice as well), you could write a scheme interpreter that runs on the Java virtual machine, and can use the whole of the Java Runtime environment.
  • by bwilson (27514) on Tuesday May 01, 2001 @11:14AM (#253127) Homepage
    I recently had to learn ML [] (Meta Language) for a class. I'd done some Scheme and Lisp before, and ML at first seemed annoying.

    But ML turned out to be great! It functions like Lisp, but has some additional interesting features:

    • Strong type checking: Most of my Lisp errors were type errors. ML is the most strongly typed language I have heard of (its often used by language theoriticians). When you run the program it is first fully type checked, very few runtime errors are even possible. What makes it different from C is that type checking is implicit (although you can specify types if you want). The compiler/interpreter will figure out which types a function can accept, so you can have a function that accepts many different types for some argument, yet you get the safety of full type checking.
    • Its simpler than Lisp. Lisp has too much crap thrown in. ML is more understandable (like Scheme).
    • Few parenthesis. Although your programs are structured similar to Lisp, most parenthesis are not needed, which IMO really helps readability and makes it easier to change (no more counting parenthesis when you add something).
    • More powerful functions. When you call a function the arguements are actually matched against a pattern in the function declaration. The function with that name which has a pattern that matches the closest is used. You can write interesting recursive functions where one version of the function gets called normally, and another gets called when the argument is a 1, for example. This only scratches the surface of how powerful this feature is.
    • There is even an object oriented version: Caml []
    It is available from Bell labs []
  • by jonathanclark (29656) on Tuesday May 01, 2001 @10:48AM (#253133) Homepage
    Check out Abuse (link below), even though the game came out more than 6 years ago the community is still going and active on a daily basis. I attribute this largely to the addition of LISP which made the game very expandable. []

    Recently Jermey Scott made a Win32 port of Abuse and converted the IPX code to DirectPlay so you can play multi-player over the net. That can be found here: []
  • by jonathanclark (29656) on Tuesday May 01, 2001 @11:40AM (#253134) Homepage
    I've been a big fan of Lisp since I first learned it, but I've always had trouble articulating why it is so useful. Now that XML is around and the world is saying it's the greatest thing since sliced bread - I have an analogy.

    Lisp and XML both support

    - Arbitrarily complex data can easily represented in text.
    - Parsing of data in an easy fashion.

    However, I think LISP has some advantages over XML:

    - XML standard is becoming too complex, LISP data format is about as simple as you can get. You can write a LISP parser in 100 lines of code. This makes LISP ideal for tiny "fun" applications, to the larger enterprise applications.
    - XML is much more verbose to write - making it easier to read by humans, but also making it something you don't want to write by hand - witness all the tools that have been writing to assist XML writing.
    - LISP allows for execution and interface with code. Sometimes data can't be stored and loaded in a 100% static format. It's very useful to be able to embed calls to your program to generate data on the fly. And it's very easy to mix and match data and code.

    To see LISP in work in the real world, download some of my programs:

    Abuse [] - a side scroller action game published by Electronic Arts. Almost all the data loaded by the game is specified externally in LISP files. All but the main character's AI functions are written externally in LISP. Source code for this is available.

    EZIP [] - This program shows my new HTML-like dialog layout library. I encourage you to look at the LISP code that generates the dialog boxes. 3 very nice dialog boxes specified in 100 lines of code. LISP is easier to write than HTML because with an editor that does paren matching you can see opening and closing of rows, tables, and columns. Here is an excerpt of the LISP code from ezip:

    (well /. Say
    "Lameness filter encountered. Post aborted.
    Reason: Junk character post.") when I post the code... oh well

    (This looks better in an editor). What is cool is that changes to variable names such as "filename" and "outname" are automatically applied . If this were an Active-X control with IE showing HTML then I'd have to have a "Submit" button which sent the results of the form, and then parsed the changes I wanted by hand.

    This dialog software uses the same algorithm as IE to layout dialog boxes so when I open I dialog I don't need to specify any sizes in the code. The layout algorithm automatically determines optimal size for tables, cols, and rows. This allows it to calculate a size for the tab control, and a size for the window itself. Language translations just work regardless of how long the German word is for "duck" It's a huge advantage over conventional dialog layout methods like GUI editors.

    Golgotha [] -A 3d action game that used external LISP files to specify data for the game. This allowed artist to add new models and textures to the game. They may not know lisp but they can copy a line of code and change file names like there is no tomorrow. Source for this is available.

    I'm not going to say that people should go out and programmer entire apps in LISP - but I think it's an excellent way to represent data extern to your program - perhaps better than XML because of the flexibility it can allow you.
  • by drenehtsral (29789) on Tuesday May 01, 2001 @10:56AM (#253136) Homepage
    Among other famous LISP programs (Emacs, ABUSE, all the Sierra games (king's quest, etc...)), and some other good stuff, a decent portion of AliasWavefront is written in LISP.
  • by NCamero (35481) on Tuesday May 01, 2001 @09:48AM (#253144) Homepage Journal
    LISP is also famous to engineers as the macro language used in AutoCAD.
  • by Greg Lindahl (37568) on Tuesday May 01, 2001 @11:43AM (#253150) Homepage

    Perl is a Swiss Army Chainsaw, not a Swiss Army Knife.

  • by wiredog (43288) on Tuesday May 01, 2001 @09:56AM (#253153) Journal
    competitive advantage against the competition

    As opposed to, say, a competitive advantage against...?

  • I'd like to point out how bad the I/O is in Lisp

    LISP has had highly sophisticated I/O for many decades. This is why it's so widely used in parsers, text processors, editors [] and so on. The (Common LISP) I/O specification is here [].

    ...and how hard it is to properly handle the myriad possible errors a program has to handle gracefully when working with humans

    in fact, of course, LISP has a condition handling system at least as sophisticated as any other language. The specification is here [].

    Also, most lisp engines I've seen are interpreted (save for things like the Lisp Machine).

    Originally LISP was a compiled language []. However it is extremely easy to write a LISP interpreter in LISP, so most LISP systems area able to execute both interpreted source and compiled code. Furthermore, interpreted code can call compiled code and vice-versa. Documentation on the Common LISP compiler is here [].

    Only a few toy LISP systems lack a compiler.

    Now this doesn't prevent you from doing very powerful very high level things with Lisp, but for the most part you can do them easier and faster with C

    You really never have used the language, have you? If a programming problem can be solved easier by a good C programmer in C than it can by a good LISP programmer in LISP, it wasn't a problem in the first place. For example, I wrote a CASE tool for expert system design in LISP by myself in three months; it took a team of four programmers two years to produce the production C version of the same program.

  • by drivers (45076) on Tuesday May 01, 2001 @10:02AM (#253158)
    Great article. Now I actually want to learn lisp.

    But I don't expect to convince anyone (over 25) to go out and learn Lisp.

    Good thing I have about two weeks before I turn 26. I will have to learn quickly!
  • by J.Random Hacker (51634) on Tuesday May 01, 2001 @01:20PM (#253171)
    Actually having used LISP and C++ (along with many other languages) in my career, I can speak with *some* authority on the differences. I'm frequently astonished with people who express opinions about some language with out first learning something about it. People seem to learn only some small corner of a language and assume the rest of the language is like that chunk, or worse, latch on to some half formed opinion expressed by some other person, and claim that to be the final word on the language.

    The saddest reality is that there is a 100:1 productivity ratio among programmers, and there are many more at the low end than at the high end. I have noticed that the best programmers all know LISP. They grok LISP. As a result, they *really* understand computation deeply enough for that understanding to translate to any other language, though it still takes time to grok the core idea of that other language (C++ comes to mind as a devilishly complex language to truely master).

    Every language has a core quality that the programmer must grasp to use the language effectively. If you can't learn that core idea, the game is over.

    So -- when you say that the code is being rewritten in C++ because your shop can't maintain it, what you are saying is that you can't understand the elegant design, so you will replace it with something simpler (you hope), and will ultimately find that the resulting program is far more brittle, and harder to maintain.

    You are also saying that you don't have any of those programmers who truely grok computation.

    As support for my position: I developed software for engineering automation in the 80's and 90's, then moved to control systems when my company was sold and destroyed by poor management. Technically, the product (written in CommonLISP) was a screaming success. We just could not make good sales/management/investment decisions. I now write control system software in C++. LISP would work better, but I needed to be compatable with an existing code base. I consider myself to be expert or at least competent in both languages.

    LISP is not that hard to learn, by the way. The syntax is *really* simple, the language uniform. What *really* stalls people is not the parens or the effeciency, or loose typing (as is often reported), the core problem people choke on is the abstraction. If your mind is not well enough trained to understand the idea of mapping a function over a domain and expressing that directly, rather than say as a looping procedure, or if you can't grasp recursion, you can't really pick up speed, and when you read code that uses those ideas, you will be lost entirely.

    We could all stand to learn much more. Study LISP -- it will improve your programming skills hugely, I promise you.
  • by nonya (65503) on Tuesday May 01, 2001 @10:04AM (#253191)
    C++ is my first language. I'm not a lisp expert, but here's my thoughts on the language:

    Things I love about lisp.
    • Macros. Because the syntax is so regular and the whole lisp system is available during macro expansion, you can extend the language in very powerful ways with macros. *THIS* is a killer feature in lisp.
    • Generic Functions. This is a generalization of virtual functions where a function can dispatch based on more than one parameter. Anyone who has used the visitor pattern in C++ knows implementing multi-dispatch in C++ comes with tradeoffs.
    • Method Combination. Before/After, Around methods.
    • Higher Order Functions
    • Metaobject Protocol
    • Efficient Compilers. Checkout CMULisp for a free advanced compiler
    Things I hate about lisp.
    • Not many good libraries. I would especially like to find a good gui library. I understand there are people working on this (Free CLiM).
    • Language seems to be dying. Not many employers are interested in lisp people.
    • Typing Issues. I prefer stronger typing than lisp has. I think C++'s type system is just right. However, I understand there is no right answer to a type system. It is a tradeoff. Lisp allows some elegant tricks. For example, a pipe in lisp is built from a cons. The second element of the cons can either be another cons (the next element of the list), or a function to call to create the next element of the list. After the function is called, it (the cdr of the cons cells) is replaced with the new element. I can do the same thing in C++, but both the new cons cell and the function have to share a base class.
    Just some random thoughts on lisp. BTW, I highly recommend Paul Graham's "OnLisp" if you're interested in seeing what the language can do. Other good books are: Norvig's "Paradigms of Artificial Intelligence Programming" and if you're interested in Lisp's object model try "The Art of the Metaobject Protocol" by Kiczales, Rivieres, and Bobrow.
  • by alispguru (72689) <bane.gst@com> on Tuesday May 01, 2001 @11:54AM (#253207) Journal
    What he said was that Yahoo Store didn't contain any Java. Both what he said and what you said could be true. Do you have knowledge of the Yahoo store code base?
  • by alispguru (72689) <bane.gst@com> on Tuesday May 01, 2001 @10:58AM (#253208) Journal
    Did you miss the footnote that addresses this issue?
    3. All languages are equally powerful in the sense of being Turing equivalent, but that's not the sense of the word programmers care about. (No one wants to program a Turing machine.) The kind of power programmers care about may not be formally definable, but one way to explain it would be to say that it refers to features you could only get in the less powerful language by writing an interpreter for the more powerful language in it. If language A has an operator for removing spaces from strings and language B doesn't, that probably doesn't make A more powerful, because you can probably write a subroutine to do it in B. But if A supports, say, recursion, and B doesn't, that's not likely to be something you can fix by writing library functions.
    Graham may be opinionated, and you may not like his opinions, but he's not ignorant.
  • by alispguru (72689) <bane.gst@com> on Tuesday May 01, 2001 @11:26AM (#253209) Journal
    1. Macros. Like Graham, I can't explain why Lisp macros are the greatest thing since sliced bread in this small space. Suffice it to say macros make it possible for Lisp to absorb nearly any semantic innovation in any other language, without losing any of its current character. Lisp was invented before structured programing - we implemented macros for IF, WHILE, and LOOP, and went on. Lisp was where a lot of the early research for object-oriented programming was done, because it's so easy to prototype new languages inside it.

    2. A real specification. Like most of the new languages du jour, Python is defined by a portable implementation, and as such it will be a long time before sufficient effort can be applied to make it as efficient as any of the commercial Lisps that compile to native code, on-the-fly, cross-platform, cross-OS, cross-whatever. Both Common Lisp and Scheme have real specifications, vetted by international authorities (ANSI and IEEE, respectively), so implementors have a non-moving target when they need to get down to the metal for the last factor of two (or ten) in performance.
  • by alispguru (72689) <bane.gst@com> on Tuesday May 01, 2001 @10:30AM (#253210) Journal
    Would anyone know if his co-author Robert Morris is the same Robert Morris (or his father) of the infamous Morris internet worm from the late 80's?
    Yes, he means the Robert T. Morris of Internet worm fame. In a talk Graham gave at the 1998 Lisp Users and Vendors conference, he even joked about this, saying something like "remember when you do anything at Yahoo Store, your data is being handled by code written by RTFM".
  • by alispguru (72689) <bane.gst@com> on Tuesday May 01, 2001 @11:46AM (#253211) Journal
    ... since on-line store building is no longer rocket science. After Graham showed how it ought to be done, on-line store building became a solved problem, and hence boring. Thus, it needed to be redone in languages more suited to use and maintenance by less brilliant developers. Let's face it, 99% of IT work has to be doable by the average programmer.

    I would argue that everything should be done in Lisp ... the first time.
  • by HopeOS (74340) on Tuesday May 01, 2001 @07:34PM (#253212)
    BEN: Remember, a Lisp Programmer can feel the Recursion flowing through him.

    LUKE: You mean it controls your algorithms?

    BEN: Partially. But it also obeys your commands.

    ... luke gets his parentheses wrong and crashs. Han laughs heartily...

    HAN: Hokey religions and ancient syntaxes are no match for a good C compiler at your side, kid.

    LUKE: You don't believe in Lisp, do you?

    HAN: Kid, I've hacked from one side of this galaxy to the other. I've seen a lot of strange code, but I've never seen anything to make me believe there's one all-powerful language for programming everything. There's no mystical programming model that controls my destiny.

    ... Ben smiles quietly...

    HAN: It's all a lot of static casts and nonsense.

    BEN: I suggest you try it again, Luke.

    ... Ben fires up emacs and separates out the parentheses...

    BEN: This time, let go your conscious self and act on instinct.

    LUKE: (laughing) With the parentheses all over the place, I can't even grok the code. How am I supposed to debug?

    BEN: Your eyes can deceive you. Don't trust them.

    ... Han shakes his head. Luke runs the code, and it crashes again. Luke lets out a yell and attempts to smack the monitor...

    BEN: Stretch out with your feelings.

    ... Luke stands in one place, seemingly frozen. Luke counts out fifteen levels of parentheses in his head and adds a sixteenth. The code runs.

    BEN: You see, you can do it.

    HAN: I call it luck.

    BEN: In my experience, there's no such thing as luck.

    HAN: Look, going good against AI is one thing. Going good against UI? That's something else.

  • by selectspec (74651) on Tuesday May 01, 2001 @09:44AM (#253213)
    Look, I love Lisp, and with it I can get my emacs to do wonderful things. However, there is a major drawback to using a relatively obscure language for mainstream application development. Fewer third party libraries will be available in Lisp. This means that you'll have to do a great deal of work from scratch either porting, patching or layering libs into your lisp framework. Let's face it. Also, your code will potentially suffer from interoperability problems unless you are extremely careful.
  • by selectspec (74651) on Tuesday May 01, 2001 @12:20PM (#253214)
    Emacs is definetly difficult enough to qualify as a life long challenge. Emacs is like 42 in Hitchikers Guide to the Galaxy. Don't get me wrong, xemacs is my portal to the world. But, my configurations and modules are as cryptic as the Knights Templar. I've forgotten how half of them work anymore. Emacs is like Darth Vader. One day you realize that you are mostly Lisp/Emacs, but your not sure how you got there. You know its somehow evil, but the power of the darkside is just too tempting to ever go back.
  • by km790816 (78280) <{wqhq3gx02} {at} {}> on Tuesday May 01, 2001 @11:01AM (#253218)

    "Scheme is a simple, yet powerful, programming language. As a member of the Lisp family of languages, it is dynamically-typed and mostly functional. Since it is much smaller than Lisp, it can also be used as an embedded language, a scripting language or an extension language. The Hotdog Scheme compiler currently compiles most of the Scheme language. It has been extended to support development within the .NET framework, allowing integration of Scheme and other languages targeting the runtime (Visual Basic, C++, C#, etc.).

    • .NET provides a set of libraries that can be used by all languages.
    • .NET allows anyone to write code that can be used by anyone else. You could create components in LISP that any one else using .NET could easily use, inherit from, etc.
    • .NET provides a core set of types that are shared by all languages to allow seamless integration.

      I'm a little scared of the flame I'll get for bringing up .NET, but take a look at the site []. It's some interesting stuff.

  • by Phoukka (83589) on Tuesday May 01, 2001 @02:01PM (#253220)
    And yet, Paul Graham's point is that it is possible to write really good code really quickly using LISP, and that LISP is easy to learn, if you can get your head around the paradigm/parentheses. As such, Graham says that what your coworkers know should not be relevant -- they should learn LISP if they don't know it already.

    Notice the "should"s.

    I have no personal experience with LISP. I just got finished reading some of the source code that Graham and Norvig have published on the Web. I didn't find it that hard to understand. On the other hand, I am also rather new to programming, so maybe I don't suffer from a language rut yet. &nbspBut I doubt that.

    Your objection that LISP doesn't have an extensive set of libraries is a more powerful stumbling block. That, after all, is one of the major things that makes Java so useful. But I wonder if that objection is true? I'm not saying it isn't, because I simply don't know one way or the other. I do know that LISP libraries don't have anywhere near the exposure that the Java APIs have -- I haven't heard of any such libraries, for instance. But at the same time, I wonder whether such libraries exist and we are simply unaware of them?

    And, of course, if you take Graham's argument to heart, we should all just sit down and write some, since LISP is (in his eyes) the best language.

    The original commenter's point indeed: use the proper tool for the job. Graham would just reply the LISP is the best tool for the job.

    Have I been smarmy enough yet...? ;)
  • by waynem77 (83902) <> on Tuesday May 01, 2001 @12:32PM (#253222)
    I can't think of too many games that feature their own LISP interpreter, unless you think emacs is fun and difficult enough to qualify as a game.

    Well, emacs plays games, how about that? In fact, I keep telling people but no one ever listens: emacs does everything. If I get bored at work, sometimes I'll pop up an emacs and M-x mpuz. There's also tetris, blackbox, gomoku, doctor...

    A couple of weeks ago, I managed to completely destroy X on my home PC. I browsed the Web using emacs until I could get X back up.

    Last week, I was talking to a co-worker. I mentioned, "I'm forgetting my calculus, I tried to integrate such-and-such, and I couldn't do it. Luckily for me, emacs does symbolic mathematics." His jaw dropped open. (He does tech support for my company's symbolic math package.)

    Emacs does everything.

  • by Fnordulicious (85996) on Tuesday May 01, 2001 @11:10AM (#253223) Homepage
    > Things I hate about lisp.
    > Not many good libraries. I would especially like > to find a good gui library. I understand there
    > are people working on this (Free CLiM).

    You must not have looked at CMU Common Lisp closely enough. It includes a binding to Motif, which for me works wonderfully with the Open Motif libraries. (They aren't Liber but they are Gratis.)

    > Language seems to be dying. Not many employers
    > are interested in lisp people.

    Lisp is definitely *not* dying. Certain dialects (such as {Symbolics, TI} Zetalisp, Scheme-style Dylan) are on the wane, but Common Lisp and Scheme are two Lisps that are definitely still going strong. I see Scheme as doing better than ever, actually, and Common Lisp holds its own in many areas.

    The reason why people aren't interested in hiring Lisp people is simply due to a lack of education in Lisp. Most people have some awful memory of it from university, and don't want to deal with it. What they don't know is that under Windows or Unix it's an ideal interface prototyping system, and packages such as CL-HTTP make programming for network applications almost a gedanken exercise. Lisp is still fantastically useful but people are afraid of it or don't know about it.

    > Typing issues.

    There are no typing issues with Lisp. If you want a string you've got a string. You can't go changing it without explicit conversion, just like in C. The idea that Lisp is weakly typed is a myth, something perpetuated from the 1960s and 1970s. Just like the myth that Lisp is slow, which is also a holdover from the 1960s.

    Lisp is a strongly but *dynamically* typed language. Any datum has one type. That typed cannot be changed. If you wish to have that datum converted to another type then you use something like 'coerce' which will create a new datum of different type holding the result of mapping the information in question from the old type to the new.

    It is *dynamically* typed because types are not static. You can change types, you can create new types, etc. It's not restrictive, but it is *safe*.

    C is actually *weakly* and *statically* typed. It's weak because any datum can be converted to any other, particularly through the use of a void pointer. It's static because you have to declare your types at compile time, which limits your program's capabilities, and makes things such as polymorphism very difficult.

  • by Fnordulicious (85996) on Tuesday May 01, 2001 @12:29PM (#253224) Homepage
    > I know a bit of Lisp -- I love Emacs and wanted
    > to be able to customize it more, so I played
    > around with Lisp. I learned enough to do some
    > pretty cool things, and learning Lisp has taught
    > me a lot about programming in general...

    Emacs Lisp is not a modern Lisp. It is an archaic and *very* poorly designed implementation of a Lisp developed at MIT in the 1960s and 1970s called MACLisp. Do not confuse Emacs Lisp (which even its maintainers think is a piece of shit -- just ask them) with a *real* Lisp like Common Lisp or Scheme.

    Emacs Lisp is a bane to the Lisp community. An embarrasment. It carries on the awfulness of dynamic scoping (modern Lisps use lexical scoping), horrible garbage collection (GCPRO isn't just a hack, it's a crock -- of shit), and poor support for language extension (no easily constructed user-defined types, no object system, etc).

    > But I'm not convinced that Lisp is the "highest
    > level language of all high-level languages" or
    > "the most powerful of all high-level languages".

    There is no such thing as the 'highest level HLL'. Someone can always make a more abstract interface atop the language in question. So this statement is meaningless.

    There is no 'most powerful' language in any field. Power is a completely relative term. It's relative to the immediate situation at hand. Flexibility on the other hand is measurable by the number of different uses a particular technique can be put to.

    VB is not any higher level than Lisp is. Both remove you from the actual workings of the system. Lisp is *much* more abstract in many ways that VB will ever be. Common Lisp provides a generic and OS-independent interface to filesystems of all sorts, something that cannot be said of VB, which is locked into Microsoft's OS products. Common Lisp also provides a generic I/O system that is OS-independent. VB is again not OS-independent.

    Someone mentioned that Common Lisp had poor I/O facilities. I must disagree -- in Guy L. Steele's book _Common Lisp: The Language_ 2nd ed. there are over 100 pages in chapter 22 on I/O alone. That's not including the following chapter which focuses on filesystem interfaces and accounts for another 50 pages, and the chapter on prettyprinting code which takes up another 20 pages. Common Lisp certainly has a lot of I/O support, in many ways much better than C. And if you want someone else's I/O then you can use a foreign function interface to some other language library to call out to it.

    > Lisp code is hard to read for most programmers

    You just need a better tool. Turn on parenthesis highlighting in your Emacs. Use the sexp-movement functions. Or, quite simply, learn to expand your stack. I see plenty of piles of matched parens and braces and brackets in C. And they're *much* harder to sort out than parens. And if you really don't like parens then you can glue your own syntax onto Lisp. That's something that isn't easy to do with other languages.

    > This story isn't about Lisp being used for a
    > kick-ass user interface or a 3d engine because
    > (IMHO) Lisp isn't as well suited to those
    > things.

    Lisp was used for one of the first production 3D development environments, Symbolics Inc.'s S-Products. This was later sold to Nichimen Graphics who still uses Common Lisp as their base system for extensive 3D products. Nichimen's systems were used for a number of Nintendo 64 games, for instance.

    Kick ass user interfaces can be written in literally *hours* rather than months as in C or C++. And I write user interfaces in C and C++ so I know what I'm talking about. I could do my job in Lisp in one tenth the time, but unfortunately it's too late in the game to rewrite the existing code base.

    Don't open your mouth or your foot may fall into it. Always do your research before you post uninformed opinions.
  • However, html is even more useful than PDF.

    This is the web afterall. I don't think that the "but its in pdf" was a complaint about pdf specifically, but rather "Not html or plain text", which are both universal, any web browser (with the exception of a few really weird ones, whose names I can't remember) can show html.

    This article was a good read, but it was ALL TEXT. There was absolutly no reason to use pdf, ps, TeX, RTF, MS Word Doc, Powerpoint or whatnot. hell, html would have been overkill for the article in question! (it would have required nothing more than <p> and <h1> for the entire article (with maybe a little <em> thrown in.

    PDF, PS etc all have their place. Articles posted on the web that are all text or text and simple graphics is NOT one of those places.

  • by Animats (122034) on Tuesday May 01, 2001 @10:05PM (#253263) Homepage
    I had a merchant account on Viamall in its early days, and was aware it was a LISP application. It was a good system, and way ahead of anything else in that era. It was solidly reliable in an era when few web complex web-based systems worked at all.

    HTML is a tree, and you want to manipulate it as a tree, not as a text file. LISP is good for manipulating trees. Doing Viamall in it made sense. Back then, all the alternatives were much worse.

    LISP concepts are still around. Java is conceptually quite close to LISP. The syntax is different, but the run-time systems look rather similar. Both offer a garbage-collected environment which can load new modules during execution without compromising safety. And to a considerable extent, XML is an attempt to re-invent LISP data structures, badly.

  • by jallen02 (124384) on Tuesday May 01, 2001 @10:18AM (#253267) Homepage Journal
    Im not wure who wrote this but this was one of my first turn on's to functional programming languages.

    For the link paranoid.

    Very cool reading.

  • by Jagasian (129329) on Tuesday May 01, 2001 @11:51AM (#253278)
    Why do people continue to promote old outdated technology, when there are better, open, free alternatives? Lisp is a perfect example. The language is not statically typed in most of its incarnations. It uses strict reduction, as opposed to lazy reduction, and the language isn't purely functional. Haskell [] on the other hand:
    • standardized - an open standard.
    • ...also has free quality open source compilers and interpreters which adhere to the open standard.
    • ...uses lazy reduction, which means that a wider variety of functions normalize, as opposed to strict reduction.
    • purely functional, which leads to more elegant and easier to understand programs. Formal analysis is allot easier when the language is purely functional as opposed to polluted.
    • ...allows for imperative or procedural features through the use of monads. So you can have your cake (purity) and eat it too (imperative/procedural aspects).
    • ...uses function currying to ease the use of higher order functions and to decrease the reliance of all those damn parenthesis!
    • statically typed and uses type inference too, so you don't even have to explicitly tell the compiler what types you are using. It can do all the dirty work for you, yet still give you very high automatic assurance of program correctness.
    • simply better designed. Its syntax, semantics, and APIs are more simple, consistant, and pure than Lisp and its many incarnations.

    The only drawbacks to Haskell is that it is new and less people know about it and know how to use it. Many universities also do not teach Haskell because, again, it is too new.

    So, I ask my question: Why fear new and better things? Why do people keep ranting about the virtues of an outdated programming language, when there are better alternative standard functional programming languages?

    If you have no idea what I am talking about, then download Hugs [] (for Mac, Windows, Linux), a Haskell interpreter, and try it for yourself. Debian GNU/Linux users can simply "apt-get install hugs" and start running hugs. I also recommend a book, if you have never programmed or never programmed in a functional language before: The Craft []. Read the book an hour each day, and play around with hugs while you are at it. After a few weeks, you will understand why writing code in Haskell is allot like writing the poetry of algorithms.

  • by ekrout (139379) on Tuesday May 01, 2001 @10:03AM (#253285) Journal
    There's a great site with tons of links and info on Lisp right here [].

  • by The Pim (140414) on Tuesday May 01, 2001 @10:18AM (#253287)
    Would anyone know if his co-author Robert Morris is the same Robert Morris (or his father) of the infamous Morris internet worm from the late 80's?

    Yes it is the same Robert Morris, but for Pete's sake, don't mod me up so everyone knows!

  • by blackdefiance (142579) on Tuesday May 01, 2001 @11:25AM (#253291) Homepage
    A great book for anyone interested in reading up on this is The Little LISPer, by Daniel P. Friedman. The entire book is a dialog, consisting of questions down one side of the page, and answers down the other. It starts with the basic concepts, (ie, What is an atom?), and just builds and builds. This is easily one of the most compelling computer instruction books I've ever read. Probably not that great as a quick reference, but if there were more language books like this, I'd learn more languages.
  • by PeaNUTZ (143211) on Tuesday May 01, 2001 @10:06AM (#253293) Homepage
    A good start is Association of Lisp Users:

    And a couple of other:
  • by lispbliss (146952) on Tuesday May 01, 2001 @10:28AM (#253298) Homepage
    Peter Norvig (Division Chief, Computational Science at NASA) recently reviewed 4 Dynamic environments and Lisp ranked _very_ highly. Here is the review: /0103e.htm []
  • by lispbliss (146952) on Tuesday May 01, 2001 @10:17AM (#253299) Homepage tudy.html []

    Blurb... "We have repeated Precheltís study using Lisp as the implementation language. Our results show that Lisp's performance is comparable to or better than C++ in terms of execution speed, with significantly lower variability which translates into reduced project risk. Furthermore, development time is significantly lower and less variable than either C++ or Java. Memory consumption is comparable to Java. Lisp thus presents a viable alternative to Java for dynamic applications where performance is important."
  • by slashdoter (151641) on Tuesday May 01, 2001 @09:34AM (#253304) Homepage
    "wrote an article that explains how he used Lisp"

    yeths, we all love theth lispths, some timeths iths helpfull in a cthndy Brady kind of way


  • I'm a big fan of Common Lisp as well as Paul Graham (having read his book ANSI Common Lisp, I can see that he possesses both in-depth technical knowledge and a sense of humor). This article seems to match what I've read of him in quality, and I look forward to reading it in more depth when I get home.

    I'm not a Lisp guru by any means, but the one thing that I always get a kick out of is how easy it is to become a low-level guru. After a few weeks of playing, I was doing things I wouldn't have dreamed of doing in C or Java. And it changes one's perspective. It all translates to machine code at the lowest level, of course, but after learning Lisp I can say without a doubt that I'm a better C programmer.

    Lisp is an interesting language, because in some ways it's ridiculously high level (closures, generic functions, garbage collection, et cetera), but you're also able to get down and dirty with the cons cells with no trouble. I think this quote expresses it best:

    What I like about Lisp is that you can feel the bits between your toes.

    -- Drew McDermott

    Lisp is extremely versatile. While it was originally used in AI, it's honestly the best tool for most situations I come across. (You can see one thing I've done here [], and I've done some other stuff that I haven't had a chance to post yet.) Whenever I need to do more in the shell than loop through a few files, I write it in Lisp (I've written 5-line programs to leech an entire Web page's MP3 archive). Lisp is great at processing logs, the output of various subprocesses, and other such things. It's also got a wonderful OO system.

    Graham's "Blub" example holds true for everyone I've met who has a disdain for Lisp. The advanced features it provides really do go over their heads, which is sad, because these are often intelligent people. Also, they don't look beyond the syntax differences, and often have a lot of misinformation (Lisp is slow, you can't do iteration in Lisp, Lisp is for lists and AI) fed to them by CS professors or whoever. I also often see a lot of posts from newbies who want to write "C-Lisp" and give up when that doesn't work. Lisp is a different paradigm, and needs to be treated as such.

    If you're interested in Lisp, I would recommend reading The Evolution of Lisp [] (don't be angry at the poor fonts in the PDF; they didn't use scalable TeX fonts, the weenies :), Paul Graham's ANSI Common Lisp [], and Winston and Horn's LISP, 3rd Edition (but ignore them when they disparage car and cdr []), in that order.

    Also, don't be confused by the various Lisps out there. First, ignore Emacs Lisp. Among its quirkyisms, it's dynamically scoped, which means that if you declare a variable, every function you call will also have access to that variable. Secondly, Scheme and Common Lisp are vastly different. Scheme is much leaner, and has 1 namespace, which means you can't name a variable and a function the same thing (I dislike this, but it's a hotly contested issue). Common Lisp has a huge set of standard APIs [] and much more versatility prebuilt into its core, while Scheme tries to stay small so as to provide an easily implementable standard. I'm a Common Lisp man, myself, but try things out for yourself.

    One final thing is that if you hang out with them [lang.lisp], you'll realize that most of the long-time posters are extremely knowledgable and have a great sense of heritage. I've learned a great deal by simply lurking through their flamewars, since I find out a lot about what issues may crop up for an individual programmer.

    If you want a bit more advocacy, see my recent posts on the subject [].


  • by SquadBoy (167263) on Tuesday May 01, 2001 @09:46AM (#253326) Homepage Journal
    :LISP: /n./ [from `LISt Processing language', but mythically from `Lots of Irritating Superfluous Parentheses'] AI's mother tongue, a language based on the ideas of (a) variable-length lists and trees as fundamental data types, and (b) the interpretation of code as data and vice-versa. Invented by John McCarthy at MIT in the late 1950s, it is actually older than any other {HLL} still in use except FORTRAN. Accordingly, it has undergone considerable adaptive radiation over the years; modern variants are quite different in detail from the original LISP 1.5. The dominant HLL among hackers until the early 1980s, LISP now shares the throne with {C}. See {languages of choice}. All LISP functions and programs are expressions that return values; this, together with the high memory utilization of LISPs, gave rise to Alan Perlis's famous quip (itself a take on an Oscar Wilde quote) that "LISP programmers know the value of everything and the cost of nothing". One significant application for LISP has been as a proof by example that most newer languages, such as {COBOL} and {Ada}, are full of unnecessary {crock}s. When the {Right Thing} has already been done once, there is no justification for {bogosity} in newer languages.
  • by dark_panda (177006) on Tuesday May 01, 2001 @09:55AM (#253333)
    I'm not sure how many people out there will remember, but many moons ago, back around post-Doom Year 1 or so, a non-id software company called crack-dot-com released a nifty side-scroller called Abuse. Not only did Abuse feature a cool mouse-keyboard combo for aiming/moving and some cool level designs, it also featured a complete set of game editing utilities and an honest-to-God LISP interpreter that let you completely reprogram the game. I can't think of too many games that feature their own LISP interpreter, unless you think emacs is fun and difficult enough to qualify as a game. J
  • by blitzrage (185758) on Tuesday May 01, 2001 @09:36AM (#253337) Homepage
    What is "Lisp" based off of? Is it a C++ style code or something else, and why have I not heard of it before? What are some other "famous" applications that are using Lisp?
  • by sv0f (197289) on Tuesday May 01, 2001 @11:31AM (#253356)
    Would anyone know if his co-author Robert Morris is the same Robert Morris (or his father) of the infamous Morris internet worm from the late 80's?

    RTM the senior is the Unix/Security guru. He was a big fan of Brunner's "Shockwave Rider", which described a future world sporting a global network riddled with transient "worms". His son, RTM the junior, authored the infamous internet worm as a grad student at Cornell. I think Paul Graham and RTM the son were undergrads together at Harvard.
  • by sv0f (197289) on Tuesday May 01, 2001 @12:11PM (#253357)
    It should also be noted that Guy Steele, the editor of the original definition of Common Lisp in 1984 and the pre-ANSI definition in 1990, is the same guy who:

    (1) Co-invented scheme.
    (2) Co-wrote the best reference manual on C with Samuel Habison ("C: A Reference Manual", I think)
    (3) Co-wrote the best reference manual on Java ("The Java Programming Language Specification", I think)
    (4) Collected the original Jargon file and is therefore responsible for the funny stuff (as opposed to Raymond's contributions) in "The Hacker's Dictionary".
  • by sv0f (197289) on Tuesday May 01, 2001 @01:37PM (#253358)
    if you want a string and somebody passes you a cons, you've got a cons, and that's a problem. that's what the "strongly typed" crowd means by "weakly typed".

    What the original poster is saying, I think, is that in Lisp OBJECTS are (strongly) typed, whereas in other languages VARIABLES are (strongly) typed. That this type information is not thrown away at compile time (as in STATICALLY-typed languages), but is available at run time, means that lisp is also DYNAMICALLY typed. This is particularly critical because new types (e.g., classes) can be created at run time in Lisp.

    C is relatively strongly typed (with the exception of the short/long int business, the "see-through" typedefs and the "no formal paremeter" nature of cast operators)

    I assume the original poster felt more strongly about the "exceptions" (as do I in the case of casts) than you do!

    And, polymorphism: once again, lisp allows you to implement powerful polymorphic capabilities with its first-class user defined types, but it is notpolymorphic in the sense that OOP people mean. You might argue "better", ok, but still, it's not polymorphic.

    Common Lisp has an object system, and it's in that context that it is polymorphic. For example, you can define:

    (defmethod foo ((x string)) ...)

    (defmethod foo ((x cons)) ...)

    and Common Lisp will select the correct method depending on the type of the argument it is passed. In other words, it's polymorphic. This is because foo is a "generic function" with several methods. Methods in Common Lisp are more expressive than those in C++ and Java, what with the elegant and extensive method combination protocol, the flexibility of lambda list keywords, the presence of multimethods (e.g., you can write (defmethod bar ((x string) (y cons)) ...)).
  • by MacGabhain (198888) on Tuesday May 01, 2001 @11:37AM (#253360)

    Anyhow, having said all that, could someone who knows Lisp better than me explain what it is about Lisp that makes it so good for AI? I've always heard that but being pretty far removed from that field I've never seen any cool Lisp AI code.

    I'm not (unfortunately) a LISP god, but I think I know enough of the theory to answer. It's mentioned in the article, actually, where it describes LISP as a language where code and data are of the same form - that is, code returns data which is, syntactically, no different than code. What this means from an AI perspective is that LISP is designed to be able (given a good enough head start) to write itself. If one understands AI as learning systems rather than just logic-processing systems, this ability, in some form or another, is key.

  • There is a complete course [] on programming taught using the scheme language available from Ars Digita University, including, video (downloadable or streamable), problem sets, solutions, etc. It is closely based on the MIT course "6001 Structure and Interpretation of Computer Programs."

    The text for the course is available here [].

    This was pretty much all I did last October.

  • by agentZ (210674) on Tuesday May 01, 2001 @10:24AM (#253368)
    Would anyone know if his co-author Robert Morris is the same Robert Morris (or his father) of the infamous Morris internet worm from the late 80's?

    Doubtful. Robert Morris Sr. had a long career with the NSA and is now rather old to be working on a start-up company. His son, Robert Tappan Morris, has stayed in academia AFAIK. Last I heard he was an Assistant Professor at MIT [].

    (Although if the latter was involved, perhaps it just goes to show that the original Internet worm was caused by mis-matched parens?)

  • by Moghedien (237619) on Tuesday May 01, 2001 @09:47AM (#253374) Journal
    Or why not learn Caml []? It's fast []! Yay.
  • by markmoss (301064) on Tuesday May 01, 2001 @11:35AM (#253384)
    I remember those LISP scripts in autocad. You could do amazing things with them, if you didn't mind that it was about as fast as a 3-legged turtle. But Autocad on a 286 was barely fast enough to be usable anyhow (redrawing the screen was time for a short coffee break). And Autocad was originally written for 8088's...

    In some ways, LISP was a natural language for CAD. A CAD (vector graphics) data file is a list of objects such as lines, circles, etc., so the program has to handle lists of objects of various types, and figure out what the type of each object is on the fly. Well, that's what LISP does. And in the early 80's when the first version was written, there weren't that many languages to choose from that did run-time binding. Of course, from performance considerations they had to write most of AutoCAD in C or assembly, including somehow faking the run-time binding, but my guess is the designers prototyped and thought in LISP, then hand-translated to lower-level languages.

    Neither list processing nor run-time binding is very special anymore. See Python, for example. And think I'd rather work in Python, although I haven't yet. It seems to me to be a little less error-prone in a couple of respects: grouping of statements is quite visible, while in LISP all grouping is controlled just by parentheses, and in Python you have the option whether or not to specify the types of objects, while in LISP you have no choice but to hope that it gets it right when it looks at the data at runtime.

    LISP's other special characteristic is that it has exceptionally good support for programs that write programs. Most of the time, writing a program that changes code is some sort of horrible mistake. But the web-site generating program described in the article needs to write code, so LISP was a natural match. And I can't think of any other language that would do that so well. (Partly because of those insane silly parentheses; this method of structuring the program is much friendlier to code than to coders...)
  • by markmoss (301064) on Tuesday May 01, 2001 @12:32PM (#253385)
    Is the age of a language proportional to the number of jokes that people have invented about it? I don't remember any jokes about FORTRAN, and it's older than LISP. LISP is just funny. Or in quasi-LISP:

    (not (remember I (about jokes FORTRAN)))
    (is LISP (funny just))

    Now do you see why people laugh?
  • by hding (309275) on Tuesday May 01, 2001 @10:11AM (#253391)
    LISP isn't really good for much, outside of artificial intelligence or other heuristical analysis-type applications.

    Really? Discounting the fact that the article linked to in the story demonstrates a quite non-AI use for Lisp, there are others as well. I, for example, use it for business programming.

  • by hding (309275) on Tuesday May 01, 2001 @10:16AM (#253392)

    Have you actually used a Lisp environment in the past twenty years or so? Every major Common Lisp implementation has a compiler, and at least one doesn't even have an interpreter. What specifically about the condition system do you find inadequate compared to other languages? It definitely offers support at a level at least as high as something like C++ or Java.

    As far as doing real work in functional languages, perhaps you ought to ask the Erlang [] people about that. Or check out this [] link.

  • I wonder if it will take the C++ guys longer to rewrite it than the lisp guys took to write the original?

    I use C++ all the time, and I am still amazed at the poor quality of most c++ projects out there.

  • by pavonis (415389) on Tuesday May 01, 2001 @10:00AM (#253420)
    I certainly don't qualify as a LISP zealot, but for anything involving work with strings (an HTML-writer would be a pretty good example), many kinds of artificial intelligence and logic, databasing, what-all- any sort of more high-level task- LISP can be extremely straightforward. Often the logic of what you are doing is made extremely transparent, which can both make maintaining it easy, and reveal possible efficiencies that might otherwise be missed.

    While there are more libraries and better compilers for LISP than is commonly realized, it is relatively rarely used for anything directly touching hardware or demanding high performance. But it is very easy to tie in C or assembler code to deal with such things.

  • by Brummund (447393) on Tuesday May 01, 2001 @11:09AM (#253427)
    How can this be moderated to 4, informative? Is all people on slashdot PHP and C freaks?

    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. []

  • by e40 (448424) on Tuesday May 01, 2001 @12:26PM (#253434) Journal

    OK, kids. Here's [] a script I run on my website each night to produce a page which references files which have changed in the last day.

    How would you write this in your favorite programming language? Don't forget to have the program parse the page and insert the new stuff at the beginning, because the version below does. Yes, you could hack this with a pattern matcher. Gross.

"Just Say No." - Nancy Reagan "No." - Ronald Reagan