Slashdot Mirror
Using Lisp to beat your Competition.
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.
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.
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.
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.
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.
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.
So Yoda was a Lisp Master!
"Pinky, you've left the lens cap of your mind on again." - P&TB
"I can see my house from here!" - ST:
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!
Erlang Developer and podcaster
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.
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.
Topher
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.
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?
If tits were wings it'd be flying around.
You seem to be using an older dialect of Lisp. I think you meant
(lisp (taught (me (to (count (parenthesis))))))
or maybe
(taught
(me)
(lisp)
(to
(count parenthesis)))
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?
Trolling is a art,
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.
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!
Peace,
(jfb)
To spur "enterprise Linux," Big Bang, the distributed two-phase commit.
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.
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."
cpeterso
> 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?
Lisp.
--
Sheesh, evil *and* a jerk. -- Jade
> 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.
--
Sheesh, evil *and* a jerk. -- Jade
> Now that XML is around and the world is saying it?s the greatest thing since sliced bread - I have an analogy.
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 for specifing game variants.
--
Sheesh, evil *and* a jerk. -- Jade
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.
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.
This is my signature. There are many signatures like it but this one is mine..
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.
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).
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.
ReadThe ReflectionEngine, a cyberpunk style n
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 labsCheck 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.
http://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/
-- Virtual Windows Project
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.
/. Say
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
"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.
-- Virtual Windows Project
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.
---
Play Six Pack Man. I
LISP is also famous to engineers as the macro language used in AutoCAD.
As opposed to, say, a competitive advantage against...?
Best Slashdot Co
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.
in fact, of course, LISP has a condition handling system at least as sophisticated as any other language. The specification is here.
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.
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.
I'm old enough to remember when discussions on Slashdot were well informed.
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!
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.
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.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?
To a Lisp hacker, XML is S-expressions in drag.
To a Lisp hacker, XML is S-expressions in drag.
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.
To a Lisp hacker, XML is S-expressions in drag.
... 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.
... the first time.
I would argue that everything should be done in Lisp
To a Lisp hacker, XML is S-expressions in drag.
BEN: Remember, a Lisp Programmer can feel the Recursion flowing through him.
... luke gets his parentheses wrong and crashs. Han laughs heartily...
... Ben smiles quietly...
... Ben fires up emacs and separates out the parentheses...
... Han shakes his head. Luke runs the code, and it crashes again. Luke lets out a yell and attempts to smack the monitor...
... Luke stands in one place, seemingly frozen. Luke counts out fifteen levels of parentheses in his head and adds a sixteenth. The code runs.
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.
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.
Someone you trust is one of us.
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.
Someone you trust is one of us.
"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. It's some interesting stuff.
A speech...
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.  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...?
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.
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.
-Steve
"I opened my eyes, and everything went dark again"
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.
Im not wure who wrote this but this was one of my first turn on's to functional programming languages.
For the link paranoid.
http://www.naggum.no/worse-is-better.html
Very cool reading.
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.
There's a great site with tons of links and info on Lisp right here.
If you celebrate Xmas, befriend me (538
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.
circa75.com
A good start is Association of Lisp Users:
http://www.alu.org
And a couple of other:
http://www.cons.org
http://www.franz.com
http://www.xanalys.com
/* 0x2b | ~0x2b is in fact -1 */
Peter Norvig (Division Chief, Computational Science at NASA) recently reviewed 4 Dynamic environments and Lisp ranked _very_ highly. Here is the review:
e /0103e.htm
http://www.sdmagazine.com/articles/2001/0103/0103
http://www-aig.jpl.nasa.gov/public/home/gat/lisp-s 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."
yeths, we all love theth lispths, some timeths iths helpfull in a cthndy Brady kind of way
________
Does anyone actually have a Java program designed to control air traffic, or for the operation of a nuclear facility?
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, 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, 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.
--
TO BUY A NEW CAR WOULD MAKE YOU SEXUALLY ATTRACTIVE.
: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.
Cypherpunks: Civil Liberty Through Complex Mathematics. Those who live by the sword die by the arrow.
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
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?
I have no signature
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))
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.
The text for the course is available here.
This was pretty much all I did last October.
Enjoy.
Bryguy
microsoftword.mp3 - it doesn't care that they're not words...
Or why not learn Caml? It's fast! Yay.
I've come to... anesthetize you!
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.
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.
--jeff
ipv6 is my vpn
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.
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.