Nameless wrote: « Python has readable syntax, a huge library, and bindings for what seems like every major in linux. Perl has CPAN. It seems with those languages if you want to do something all you have to do is import functionality from a library someone had written and use that.
In lisp you'd have to "roll your own". Why should I keep on learning lisp when there are python and perl? » You question is a valid question. Unfortunately, so far in the 14 replies in the thread, vast majority are one-liner drivels from reactionary lisp fuckheads, many of which long time dwellers of comp.lang.lisp. A common scene in any programing newsgroup. They feel attacked, reasonably by your irrespective and incentive tone, and they have the need to sputter drivel back, to entertain themselves. (I wish perl and python programers take a glimpse of that thread to realize what computing factions are driveling behind each other's back) Although your message is written in a taunting style, but it has a valid point, and in fact is a Frequently Ask Question among the vast majority of programers in the computing industry. Namely, today, languages like Perl, PHP, and to a lesser degree Python, are so popular, and ubiquitous, widely deployed and widely demanded in the job market, and also, that these languages in general and in comparison to Lisp, have far wide library support and as well as community support, and also, that these comparatively young languages are relatively high-level modern languages, that they are at a level above C, Java, making them ideal for saving programer's time as does lisp. So, what are some reasons, if any, should today's programer invest time into another language lisp (especially it has trivial percentage in programing job market), while not using the time, to perhaps master a industrial language they already know, such as Perl, or even venture into another language like Python, PHP or the new kid on the block Ruby? So far, “D Herring” and “fireblade/bobi” has given their personal take on this question. Lars Rune Nøstdal, provided a link http://wiki.alu.org/The_Road_to_Lisp_Survey that details lispers's stories on why lispers lisp. Please allow me to give my take, and i believe it is a most important _technical_ reason, why, Perl, Python, etc languages today simply cannot replace lisp. And why, if you are a programer with serious intention of refining your craft, then learning lisp is a good investment. (one non-technical reason in learning lisp, is that the widely popular programer's text editor emacs has lisp embedded as its extension language. As a coder, knowing emacs and lisp, will enpower you greatly in the long term.) I think the one most important techincal aspect, that lisp is in fact superior and cannot be replaced by the current crop of high-level languages, is the peculiar fact that the language deals with symbols. Namely, sometimes called symbolic computing. I have written a exposition on this issue before. It is archived at this page: “What is Expressiveness in a Computer Language” http://xahlee.org/perl-python/what_is_expresiveness.html at the section Symbolic Computation. There are many “papers” or articles that address the question of what does it mean when someone says lisp is a symbolic language. In my opnion, they are all fuzzy, or filled with academic jargons that is practically and most likely theoretically useless. In the following exposition, you will see what lisp's “symbolic computation” in a way that makes you understand. I excerpt the section below. SYMBOLIC COMPUTATION Lisp differs from most imperative programing languages in that it deals with symbols. What does this mean? In imperative languages, a value can be assigned a name, and this name is called a variable. For example, “x=3”, and whenever this “name” is encountered, it is evaluated to its value. It does not make any sense, to have variables without a assigned value. That is, the “x” is not useful and cannot be used until you assign something to it. However, in lisp, there is a concept of Symbols. As a way of explanation, a “variable” needs not to be something assigned of a value. Symbols can stand by themselves in the language. And, when a symbol is assigned a value, the symbol can retain its symbolic form without becoming a value. This means that in lisp, “variables” can be manipulated in its un- evaluated state. The situation is like the need for the “evaluate” command in many languages, where the programer can built code as strings and do “evaluate(myCodeString)” to achieve meta-programing. For example, in imperatives languages once you defined “x=3”, you cannot manipulate the variable “x” because it gets evaluated to 3 right away. If you want, you have to build a string “"x"” and manipulate this string, then finally use something like “evaluate(myCodeString)” to achieve the effect. If the imperative language does provide a “evaluate()” function, its use breaks down quickly because the language is not designed for doing it. It's extremely slow, and impossible to debug, because there lacks facilities to deal with such meta programing. In lisp, variable's unevaluated form are always available. One just put a apostrophe ' in front of it. In “x=3”, the x is a variable in the contex of the code logic, x is a name of the variable in the context of meaning analysis, and x is a symbol in the context of the programing language. This Symbols concept is foreign to imperative languages. It is also why lisp are known as symbolic languages. Such makes meta-programing possible. The power of symbolic processing comes when, for example, when you take user input as code, or need to manipulate math formulas, or writing programs that manipulates the source code, or generate programs on the fly. These are often needed in advanced programing called Artificial Intelligence. This is also the reason, why lisp's “macro” facility is a powerful feature unlike any so-called “pre- processors” or “templates” in imperative languages. Mathematica for example, is sometimes known as a Computer Algebra System. It too, works with symbols in the language. They can be manipulated, transformed, assigned a value, evaluated, hold unevaluated etc. One way for a imperative programer to understand symbols, is to think of computing with strings, such as which Perl and Python are well known for. With strings, one can join two strings, select sub strings, use string pattern (regex) to transform strings, split a string into a list for more powerful manipulation, and use “evaluate()” to make the string alive. Now imagine all these strings need not be strings but as symbols in the language, where the entire language works in them and with them, not just string functions. That is symbolic computation. Here we see, a expressibility unseen in non-lisp family of languages. -------------------------- End excerpt. (if there is some demand, i will add a concrept, little programing example, that shows, how lisp's symbols and macros concepts, set it apart from new scripting languages) This lisp's symbol concept, as far as i know, does not exist in some other high-level functional programing languages such as Haskell. I'm not familiar with many functional languages except Lisp and Mathematica. I'm curious, as to how Haskell, which itself is quite with capable of symbolic computation i think, deals with it even though the language doesn't employ the concep of lisp's symbols per se. Xah [EMAIL PROTECTED] ∑ http://xahlee.org/ -- http://mail.python.org/mailman/listinfo/python-list
