Using Lisp to beat your Competition. 418
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.
Re:CL vs Scheme (Score:2)
Re:Any karma whores out there... (Score:2)
Here is a list of online books and references which I found useful:
The CLIM perspective [uni-hamburg.de], [harlequin.com] user's guide [xanalys.com], and specification [mikemac.com].
Re:Interesting. (Score:2)
LisP = "Lambda calculus" (Score:2)
Re:parent is flamebait (Score:2)
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.
Re:Emacs vs. modern LISP (Score:2)
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.
--han
Re:Lisp teaches bad programming. (Score:3)
Graham on Lisp is like Schwartz on Perl... (Score:3)
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 [python.org] 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 [webcom.com]. 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 [cpan.org]. But it's still worth a look.
Re:What IS Lisp based off? (Score:2)
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.
Re:What IS Lisp based off? (Score:2)
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.
Re:"first Web-based application"? (Score:2)
Re:Lisp is great and all but... (Score:3)
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.
Re:"first Web-based application"? (Score:4)
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.
Re:CL vs Scheme (Score:5)
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.
Re:"first Web-based application"? (Score:2)
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.
Re:what I learned in school (Score:3)
Re:What IS Lisp based off? (Score:2)
Re:Boy it sure was (Score:2)
Re:What IS Lisp based off? (Score:4)
But learning to think differently is something that is definitly worth it!
Re:CL vs Scheme (Score:2)
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.
Re:Lisp as an Alternative to Java (Score:3)
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.
Re:What IS Lisp based off? (Score:3)
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 [gnu.org] Emacs [gnu.org]. 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 [gimp.org] 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 [autodesk.com], the makers of the industry leading CAD software AutoCAD [autodesk.com] use their own dialect of Lisp, called AutoLISP, for programming and customising the AutoCAD software.
Siag Office [siag.nu] 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 [gnucash.org] makes use of the Guile library to provide Scheme as an extension and scripting language for the application.
Speaking of Guile [gnu.org], 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 [mit.edu] Window Manager, the TeXmacs [texmacs.org] editor (integrating Tex support into an Emacs like editor), and many others.
One last example is the Sawfish [sourceforge.net] 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 [mit.edu]. 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 [mit.edu].
Re:I can't stand articles like this (Score:2)
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.
Re:I can't stand articles like this (Score:2)
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...
Mirrored, and ASCIIfied. (Score:5)
Re:CL vs Scheme (Score:2)
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.
Re:Lisp and Maintainability (Score:2)
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.
Uppity Languages (Score:2)
What next? A decent application for Forth [bournemouth.ac.uk]? Ada? Eiffel? C++? Oops. What that out loud?
Re:Symbolics' LISP OS (Score:2)
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.
Implementations (Score:2)
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 ...
Re:Lots of messages marked funny here (Score:2)
'CDR CAR'?
Lots of messages marked funny here (Score:4)
Re:what I learned in school (Score:4)
(lisp (taught (me (to (count (parenthesis))))))
or maybe
(taught
(me)
(lisp)
(to
(count parenthesis)))
Interesting. (Score:3)
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?
Re:What IS Lisp based off? (Score:4)
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.
Re:CL vs Scheme (Score:5)
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!
Peace,
(jfb)
Y the argument falls apart. (Score:4)
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 [fh-koeln.de], 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.
ML and Haskell? (Score:4)
Many "modern" functional languages, like ML and Haskell [haskell.org], 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 [haskell.org], 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."
Re:What IS Lisp based off? (Score:3)
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?
Lisp.
--
Re:What IS Lisp based off? (Score:4)
Theoreticians do love functional languages, but Lisp is primarily popular among AI researchers.
--
Re:LISP is really a simpler form of XML (Score:4)
FWIW...
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 [redhat.com] for specifing game variants.
--
Re:don't get too excited about this... (Score:3)
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.
Re:What IS Lisp based off? (Score:4)
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.
Lisp is great and all but... (Score:3)
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.
Re:You're missing a few important points (Score:3)
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:
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).
Java too (Score:3)
A better functional language ML/Caml (Score:4)
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 [inria.fr]
It is available from Bell labs [bell-labs.com]Re:Abuse! (Score:3)
http://abuse2.com [abuse2.com]
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:
http://www.uidaho.edu/~scot4875/ [uidaho.edu]
LISP is really a simpler form of XML (Score:5)
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 [slashdot.org] - 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 [slashdot.org] - 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
"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 [slashdot.org] -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.
AliasWavefront is mostly LISP too... (Score:3)
Re:What IS Lisp based off? (Score:3)
Re:Y the argument falls apart. (Score:4)
Perl is a Swiss Army Chainsaw, not a Swiss Army Knife.
competitive advantage (Score:3)
As opposed to, say, a competitive advantage against...?
Re:What IS Lisp based off? (Score:3)
LISP has had highly sophisticated I/O for many decades. This is why it's so widely used in parsers, text processors, editors [xemacs.org] and so on. The (Common LISP) I/O specification is here [ida.liu.se].
in fact, of course, LISP has a condition handling system at least as sophisticated as any other language. The specification is here [ida.liu.se].
Originally LISP was a compiled language [stanford.edu]. 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 [ida.liu.se].
Only a few toy LISP systems lack a compiler.
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.
Kewl (Score:4)
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!
Re:don't get too excited about this... (Score:5)
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.
Things I love/hate about lisp (Score:5)
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.Please read the article, CAREFULLY (Score:3)
Graham addresses this issue... (Score:4)
Re:LISP vs Python (Score:4)
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.
Re:Interesting. (Score:5)
Probably the right decision... (Score:5)
I would argue that everything should be done in Lisp
Reminds me of CODE WARS, episode 4. (Score:3)
LUKE: You mean it controls your algorithms?
BEN: Partially. But it also obeys your commands.
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.
HAN: It's all a lot of static casts and nonsense.
BEN: I suggest you try it again, Luke.
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.
BEN: Stretch out with your feelings.
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.
Yeah but... (Score:3)
Re:Abuse! (Score:5)
.NET and Scheme (Score:5)
"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.).
I'm a little scared of the flame I'll get for bringing up .NET, but take a look at the site [northwestern.edu]. It's some interesting stuff.
Re:You're missing a few important points (Score:3)
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.  But 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...?
Re:Abuse! (Score:3)
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.
Re:Things I love/hate about lisp (Score:5)
>
> 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.
Re:Lisp is great and all but... (Score:5)
> 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.
Re:PDF? Quit your whining... (Score:3)
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.
-Steve
LISP is the right tool for that job (Score:3)
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.
Intriguing Read... (Score:3)
For the link paranoid.
http://www.naggum.no/worse-is-better.html
Very cool reading.
Why Lisp when there is Haskell? (Score:4)
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 [haskell.org] (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 [barnesandnoble.com]. 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.
Re:Any karma whores out there... (Score:4)
Re:Interesting. (Score:5)
Yes it is the same Robert Morris, but for Pete's sake, don't mod me up so everyone knows!
Getting started with LISP (Score:3)
Re:Any karma whores out there... (Score:3)
http://www.alu.org
And a couple of other:
http://www.cons.org
http://www.franz.com
http://www.xanalys.com
Extreme Rapid Development (Score:3)
http://www.sdmagazine.com/articles/2001/0103/0103
Lisp as an Alternative to Java (Score:4)
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."
got to love the lisp (Score:3)
yeths, we all love theth lispths, some timeths iths helpfull in a cthndy Brady kind of way
________
thoughts on Paul Graham and Common Lisp (Score:5)
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:
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 [quadium.net], 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 [nec.com] (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 [paulgraham.com], and Winston and Horn's LISP, 3rd Edition (but ignore them when they disparage car and cdr [everything2.com]), 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 [xanalys.com] 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 [slashdot.org].
--
Re:What IS Lisp based off? (Score:3)
Abuse! (Score:5)
What IS Lisp based off? (Score:3)
Re:Interesting. (Score:4)
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.
Re:Lisp as an Alternative to Java (Score:4)
(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".
Re:bzzt. (Score:4)
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))
Lisp for AI (Score:3)
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.
free video course in lisp (MIT Scheme) (Score:4)
The text for the course is available here [arsdigita.org].
This was pretty much all I did last October.
Enjoy.
Bryguy
Re:Interesting. (Score:3)
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 [mit.edu].
(Although if the latter was involved, perhaps it just goes to show that the original Internet worm was caused by mis-matched parens?)
Re:CL vs Scheme (Score:3)
Re:What IS Lisp based off? (Score:3)
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...)
Re:Lots of messages marked funny here (Score:3)
(not (remember I (about jokes FORTRAN)))
(is LISP (funny just))
Now do you see why people laugh?
Uses of Lisp (Score:3)
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.
Re:What IS Lisp based off? (Score:5)
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 [erlang.org] people about that. Or check out this [bell-labs.com] link.
Re:don't get too excited about this... (Score:3)
I use C++ all the time, and I am still amazed at the poor quality of most c++ projects out there.
--jeff
Re:Lisp and Maintainability (Score:4)
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.
Re:What IS Lisp based off? (Score:5)
Allegro CL, like implemented by Franz [franz.com] , 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. [google.com]
try this in your favorite programming language (Score:3)
OK, kids. Here's [dnai.com] 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.