Ask Kent M. Pitman About Lisp, Scheme And More

Kent M. Pitman has been programming in Scheme and Lisp, and contributing to the design of those languages, for a long time -- 24 years. He was a technical contributor and an international representative for the ANSI subcommittee that standardized Common Lisp, and in that capacity directed the design of Lisp's error system. Scheme may be better known as a teaching language, but both Scheme and Lisp have applications (as any Emacs user knows) that go far beyond this. Now's your chance to ask him about the pros and cons of those two languages, circa 2001 A.D. Kent also has an interesting, ambivalent take on Free software that's worth noting in an atmosphere where complex issues are often oversimplified and radicalized. Since he's someone who's helped develop standards, this is perhaps a timely issue on which to probe his opinion. It's also a good time to get acquainted with things he's written, which might interest you just as much as his programming. (Soap opera parodies, anyone?) So suggest questions for Kent below (please, one per post) -- we'll pass along the highest-rated ones for him to answer, and Kent will get back soon with his answers.

Comments

Lisp becoming more used

[zairius]

As we move closer to having infinite memory and infinite processor speed do you see Lisp being used more in the mainstream?

John Casey

Re:Lisp becoming more used

[bliss]

"As we move closer to having infinite memory and infinite processor speed do you see Lisp being used more in the mainstream? "

Uhhh apart from emacs where is lisp in high demand in the free software world?

Re:Lisp becoming more used

[Anonymous Coward]

No way, Lisp is way outdated, and it isn't even a pure functional language. People will want to use Haskell, Erlang, or Goatsex instead.

Re:Lisp becoming more used

[Anonymous Coward]

Lots of places. Sawfish for instance in the GNOME desktop.

Re:Lisp becoming more used

[Anonymous Coward]

Or, in other words, `do you accept that, because sloppy/inefficient coding is the future of software development, its only a matter of time before Visual Scheme becomes a disgusting reality?`

Re:Lisp becoming more used

[Anonymous Coward]

This was the kind of stupid asshole I was talking about, Kent.

Re:Lisp becoming more used

[Anonymous Coward]

all haskell users use goatsex. It is included in the haskell standard library (the giver)

Re:Lisp becoming more used

[sharkey]

Too bad "Infinite Justice" is likely to make it illegal to use all that memory and speed.

Re:Lisp becoming more used

[sv0f]

As we move closer to having infinite memory and infinite processor speed do you see Lisp being used more in the mainstream?

Common Lisp applications of nontrivial size (i.e., NOT "hello world") are no larger than, and typically smaller than equivalents written in more mainstream languages (e.g., C++ and Java). This is sometimes obscured by the fact that programs in more mainstream languages have small disk footprints but large memory footprints due to large, dynamically-linked libraries. Common Lisp applications typically 'carry' all of this in the application image itself.

Round about the time average computers started sporting 8 megs of RAM, the memory demands of Common Lisp and more mainstream languages reached equilibrium. At this point, the last hangers-on ditched their workstations and joined other developers on PCs.

Re:Summary?

[bliss]

he's a man who is influential in the programming language called lisp.

command on the left

[Tablizer]

I think LISP would be more readable and easier to transition to if the command was on the left side of the parenths instead of between.

How hard would it be to change the interpreter(s) for that?

Re:command on the left

[Jackster]

The reason it in inside is it is then part of the list that is denoted by the parentheses, and can be more easily manipulated by a another scheme procedure reflectively. Reflection is the property that code can examine and change code at its same level of abstraction and run it. I saw an example where you could pass an expression like
(+ 2 (* x (/ x 3))) into a "derivative" method, which would examine that expression, MODIFY it, and return a completely valid new scheme method that was the actual mathematical derivative.

Very cool. The reason it could easily do this recursively is that the operators were bould with the arguments inside the same list.

Re:command on the left

[Mark_pdx]

Cadence did exactly this in SKILL (a proprietary version of LISP used in chip design CAD) and
it's absolutely awful. Your code and stack traces become completely unreadable. LISP only makes
sense like it is, with the operator inside the paren. You just need to program LISP long enough
until your brain "gets it", then you will be writing code very quickly....

Re:command on the left

[dirtyhippie]

I'd be very surprised if it modified the original, but instead returned a new one. I suppose you didn't mean that though.

Re:command on the left

[Berkana]

having the command on the left of the parenthesis is possible with lisp, but would defeat one of the great features of Scheme.

If I'm not mistaken, you mean

defun( . . .)
as opposed to
(defun . . .)

In scheme, the first item in a list can itself be a list. The distinct possibility here is that when the first item is evaluated, the return value may be a procedure, which then operates on the rest of the list.

This would not be possible if the operator were on the outside of the parenthesis. For example,

((operator-maker var1 var2) x y z)

will allow you to construct an operator, and then apply it to x y and z.

Lisp doesn't have this allowance, because variable name space and the function name space are separate, so to call a resultant name as a function, you need to use "funcall"

Re:command on the left

[Tablizer]

Your code and stack traces become completely unreadable

Why would moving the command to the left cause this? Almost every other language puts it on the left without busting stack traces. Perhaps Cadence is just incomp?

Re:command on the left

[divbyzero]

I think you're looking for the language Dylan, which is largely inspired by Lisp, but with infix notation. I, however, rather like Lisp's notation.

Re:command on the left

[Mark_pdx]

I should have elaborated. You can write code in
either format (lisp or "C" style) but only
get stack traces in one or the other.

Even if you write all your the "correct" (LISP),
you still run into someone else's code written in
the other style, and then can't match the stack
to the source.

From the LISP point view, the question is "why have the first element of a list outside the parens, and the rest of the elements inside"?

There's no distinction between
(myfunction a b)
and
(x y z)
until you evaluate.

Re:command on the left

[Tablizer]

>> There's no distinction between
(myfunction a b)
and
(x y z)
until you evaluate. <<

Yes, but the second one could be considered just a list. For example, it could be just considered a shortcut for "list(x y z)". Thus, when the interpeter sees "(5 noggle burp)", it would assume it is "list(5 noggle burp)". That gives you the best of both worlds perhaps.

I suppose it all depends on one's coding style. Somebody will always say, "but that makes it harder to do X", where the other perhaps rarely does X because they use a different approach altogether.

Educational Languages?

[FortKnox]

Lisp and Scheme have long been viewed as just "Educational Languages". Do you see any future with the two languages in commercial software?

Re:Educational Languages?

[ezzewezza]

commercial software like yahoo stores written in lisp?

Re:Educational Languages?

[Junks Jerzey]

Lisp and Scheme have long been viewed as just "Educational Languages". Do you see any future with the two languages in commercial software?

You're confusing the two. Scheme has always been an educational language, because that's what it was designed as. But Lisp has been hardcore for a long time now: AutoCAD, Emacs, Mirai (high end 3D modelling/texturing/animation system), Yahoo Store, scripting for the Crash Bandicoot series and the upcoming Jax & Dexter for the PlayStation 2, it's used by companies such as British Telecom and Boeing, and so on.

Re:Educational Languages?

[Anonymous Coward]

Yes, all of the example given are LISP based efforts. But 5 instances of active LISP projects do not imply a healthy development community. I think calling LISP programming (or programmers) a common thing is perhaps unsubstatiated at this time.

Re:Educational Languages?

[Anonymous Coward]

Actually, I know of commercial products I've used that have Scheme or Scheme-based scripting languages. For VLSI custom microprocessor design at our site, we use the Cadence design tools. It's internal scripting language called Skill is derived from Scheme/Lisp (list based with commands like cdr and car) and modified to make it a little bit more C-like. I know of another VLSI tool that used to use Scheme, but lately has shifted to TCL instead. So these are the first 2 programs I know of that have used Scheme as a scripting language in a commercial product.

University Students

[akula1]

It seems that more and more universities are focusing only on C++/Java, even to the point of discouraging learning other languages. Do you see this as continuing trend? If so, how do you think this will shape the next generation of computer scientists?

Re:University Students

[mrdlinux]

I do believe they have a quote for this: "Those who do not learn from history are bound to repeat it." Which has also been stated as "Those who do not learn Lisp are bound to reinvent it." Witness Python and Ruby.

Scheme in CS

[Anonymous Coward]

It seems many of the more popular CS programs in the world use Scheme as a teaching language. A lot of times, students complain about this, saying they'd prefer to learn about C or another language that is considered "apt for industry." I used to be like this too, but have now discovered the error of my thinking. How have you convinced others that while the latest programs might not be written in Scheme, that it is worth a student's time to learn Scheme. Many seem stuck to the point that if they won't use it outside of school, they shouldn't learn it. How can we convince them otherwise, to become scholarly citizens instead of drones?

Re:Scheme in CS

[Anonymous Coward]

Why not learn C++, and OOD instead of scheme? Its in the industry, and it teaches them the theory they need to know.

I learned C++ and OOD in school, and have profitted because of it. Scheme would have been a waste of my time.

Re:Scheme in CS

[DeepMind]

I've been studying Scheme in my CS class. However, it was a fork called "SWIT" (Scheme WIth Types, somewhat useless).

I didn't learn anything but enabling vim's bracket matching option :)

The previous year (and the next year as well), this class was dedicated to Prolog, which I think as being more useful and less boring.

Julien.

Re:Scheme in CS

[Mark_pdx]

Many EDA (electronic design CAD) tools use LISP variants. Cadence's SKILL, Avanti uses Scheme. It's 10X faster to write code than procedural languages, and the code is rock-solid (if you know what you're doing) because you can easily test the pieces as you build up your code. I spend 10X less time debugging LISP than procedural languages.

Even if you don't use it, any programmer should at least code enough lisp to understand how elegant programming can be. Become one with the stack. Witness the power of (mapcar It's a completely different kind of mindset than the procedural languages.

Re:Scheme in CS

[Jon Howard]

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

• Companies making it big with lisp
• Lisp career listings

Re:Scheme in CS

[Osty]

Why not learn C++, and OOD instead of scheme? Its in the industry, and it teaches them the theory they need to know.

OOP is not C++-specific. Believe it or not, you can use other programming paradigms in scheme than just functional programming. You can write procedural code, if you wish, or even OO code. The point of using Scheme in introductory CS classes is two-fold.

1. It levels the playing field. Students coming into the class already knowing C++ or Java or even Basic no longer have as much of an advantage over students that come into the class knowing little or nothing about programming. (and while you might argue that the latter people shouldn't be learning CS anyway, that's a very narrow-minded and short-sighted view, and one that's not even worth acknowledging)
2. It allows the teacher to focus on concepts rather than language idiosyncracies. Scheme can be taught to the students within the first two weeks of class. After that, they'll have all the tools necessary to learn about different programming paradigms and other CS concepts. This is much better than Java, for instance, which more or less forces you into OO design.

Even though it's unlikely scheme is going to directly affect your job marketability, there are good reasons for using it in education. Foremost of the reasons is that a four-year Computer Science degree is aimed at doing more than just developing currently-marketable talents. You're learning how to think and problem-solve, and how to learn, so that in five years when Java is no more, or when C++ finally goes by the way-side, or when whatever marketable skill you have is no longer applicable (and that will eventually be the case), you are capable of quickly grasping the new technologies because you have learned how to learn. If you don't want to learn this, don't bother with a university degree. A two-year tech college, or even a couple of well-chosen certifications (guh, don't even get me started on the uselessness of those) will be much better for you, and save you money in the short run. (In the long-run, you're going to continue to pay out the rear to keep your "education" up-to-date by taking more classes or certifications.)

Re:Scheme in CS

[sesquiped]

I can't speak for other places, since I'm still an undergraduate, but here, we give them a choice (specifically look at the contrast between 15 and 17 on that page).

A few years ago, some people were fed up with the then-only introductory CS course sequence and decided to make a totally new one, based on functional languages (Scheme and ML in the first semester) and more heavily focused on theory. It started pretty small, but it's been steadily growing in popularity every year. At present, it's about half the size of the "traditional" intro course (which focuses entirely on OO and design in Java), which I think says a lot about what students will do if you give them a choice.

Re:Scheme in CS

[King Babar]

It seems many of the more popular CS programs in the world use Scheme as a teaching language. A lot of times, students complain about this, saying they'd prefer to learn about C or another language that is considered "apt for industry."

Yup. And the problem is, those students are right. Curiosity really does kill the cat. That is, if students really do construe their years in college as training for industrial jobs, then those future employers will require them to have had (N+1) years of experience in experience using a language that was only invented N years ago. Somehow, they'll get by; the clever cat will get the chance to kill some mice. Then M years from now, they'll be let go for not having M+1 years of experience in the language invented this year. They are the old cats who can no longer (it is thought) learn new tricks. And there's always a new litter of kittens... There is nothing new here. Of course, if these students view college as just a credential to enter this kind of rat race (or a race to eat rats), then they risk missing out completely on the world of ideas. In the end, an initial failure of curiosity leads exactly where lack of curiosity has always led: a dead end.

I honestly don't know how anybody can stand to learn to live without curiosity, but that is what I see around me every day. And, really, you don't need very much to get started. Suppose you're a CS major, and you've heard you need to learn Java to get a "real job". All it takes is the single spark to ask "Why Java?" Regardless of whether Java is the One True Answer or not, the mere action of trying to understand why it is even an answer will take you much deeper than most undergraduates I know ever get. It's addictive; it's fun; it's never boring. Yet real curiosity is so very rare.

The failures brought about by an essential lack of curiosity are all around us. I wish I understood how people could really be happy that way. Not because I want to become one of them, but so I would no longer find them so completely frightening, so alien, so unlikely to care about anything beyond their own comfort.

Re:Scheme in CS

[Anonymous Coward]

While I agree that "a four-year Computer Science degree is aimed at doing more than just developing currently-marketable talents" , I must disagree with the implication that this is a necessary or sufficient reason for using Scheme as the teaching language of choice.

I take serious offense at this notion that advanced conceptual computer science can only be taught in a commercially-backwater language like Scheme or LISP. It is the same ivory tower elitism at work here as that which so often causes types like Harvard anthropology majors or Berkeley political science majors to view the rest of modern, industrialized society with disdain.

I went to MIT over ten years ago and I was taught Scheme by Hal Abelson and Gerald Sussman. I also worked in Common LISP on Symbolics LISP machines and Texas Instruments Explorers. These things I learned were supposedly the pinacle of computer science education of the day. I mention this not to brag, but rather due to the specific topical relevance of my past experience. In short, I feel qualified to say that -- in my experience -- Scheme and LISP offered nothing that I could not have also learned through the use of a more commercially-relevant language. In fact, in my personal opinion, I would almost go so far as to say that some of the vaunted abstract concepts that they go through pains to indoctrinate their students with verge on being counter-productive in the real world.

Do not misunderstand, I greatly value my education and experience. However, I think that much of the rationale behind using a niche language like Scheme for teaching has as much to do with the understandable, albeit still slightly egotistical, desire on the part of many educators "to make their mark on" or to create their "legacy" in the history and development of the relatively nascent field of computer science, as it has to do with any inherent conceptual advantages behind the languages themselves.

Re:Scheme in CS

[Anonymous Coward]

More importantly, the concept of code generation and evaluation as part of the language semantics is NOT possible in C or C++. This really is a powerful concept, and is not feasible in most other languages. I think being exposed to that is a big deal.

Re:Scheme in CS

[Black Parrot]

> Scheme can be taught to the students within the first two weeks of class.

Actually, a single lecture is enough to get them started on the study of recursion. You can postpone coverage of the bells and whistles (such as there are) until later in the semester.

Add:

1b. Scheme is different enough from the languages that the students already know that it will rock the boat for any nascent notions that there is only one way to do things (and that "their" language does it "right", which, alas, seems to be a dearly held belief for many Slashdaughters).

3. The simplicity of Scheme lets you expose students to simple correctness proofs during their first semester in CS. (You essentially treat Scheme code as a funny kind of algebraic syntax, and "solve" the code directly.)

4. It exposes students to functional programming (which otherwise they will only see for a couple of weeks during their programming languages class).

CS is not (usually) taught as a trade program. One of the major goals of a college education is to expand your mental horizons. Scheme does that.

Re:Scheme in CS

[Anonymous Coward]

OOP is not C++-specific. Believe it or not, you can use other programming paradigms in scheme than just functional programming. You can write procedural code, if you wish, or even OO code. The point of using Scheme in introductory CS classes is two-fold.

In fact, Lisp was the first object oriented language with an ANSI standard. (Simula had an ISO standard before Common Lisp). CLOS is still probably the most powerful object system in existence, with Cecil's as powerful, but somewhat non-conventional. CLOS supports:

• full multi-methods (visitor pattern and more for free)
• first-class method combinations (you can do more with methods than just call the "superclass's" method in it, e.g. you can add the results of all the methods that match the type signature of the arguments passed to it or define your own way of combining them)
• you can dynamically redefine classes and dynamically redefine the class of an object (there are methods you can extend to help tweak the conversion process)
• a full Metaobject Protocol, which allows you to modify the internals of the object system without actually changing any of the code in it. This can be used to improve the efficiency, expressiveness, and power of the object system in any way you want. e.g., UncommonSQL lets you create CLOS objects whose data comes from a database so the information is persistent across sessions

-- Rahul Jain

Re:Scheme in CS

[Osty]

I take serious offense at this notion that advanced conceptual computer science can only be taught in a commercially-backwater language like Scheme or LISP. It is the same ivory tower elitism at work here as that which so often causes types like Harvard anthropology majors or Berkeley political science majors to view the rest of modern, industrialized society with disdain.

I think you misunderstood the point I was trying to make (which is as much my fault as yours, as I only mentioned it once, in passing). That major point was that scheme/lisp makes for a very good introductory language. You know, your first one or two CS classes, where you start learning the core concepts, but before you could even dream about being able to apply your new-found knowledge to real world tasks. It's extremely important in those early stages to be able to level the playing field. It's great if a student comes into the curriculum already knowing C++, Java, or whatever else (as long as s/he hasn't formed any bad habits, anyway, which is unlikely). However, there are always going to be neophytes that are interested in computer science but have never had the time or opportunity to learn a language on their own. Choosing a language such as scheme (for example. You could pick any easy-to-learn-but-obscure language, if you really want) makes it so that those with prior language knowledge aren't at too much of an advantage, and those that have no prior knowledge are not at too much of a disadvantage. There's always the oddball that comes into such a class already konwing scheme, but that's much rarer than if said class were taught in Java (for example). Also, as a vehicle for teaching early CS concepts (the major types of paradigms, for example), scheme excels. With C++, you can't write functional code ("functional" meaning "functions are first-class objects, a la scheme, lisp, sml, etc" not "working"). With Java, it's hard to write anything but OO code. With scheme, you can introduce all through concepts within the bounds of a single language. This is perfect for presenting the concepts without relying overly much on syntax.

I went to MIT over ten years ago and I was taught Scheme by Hal Abelson and Gerald Sussman. I also worked in Common LISP on Symbolics LISP machines and Texas Instruments Explorers. These things I learned were supposedly the pinacle of computer science education of the day. I mention this not to brag, but rather due to the specific topical relevance of my past experience. In short, I feel qualified to say that -- in my experience -- Scheme and LISP offered nothing that I could not have also learned through the use of a more commercially-relevant language. In fact, in my personal opinion, I would almost go so far as to say that some of the vaunted abstract concepts that they go through pains to indoctrinate their students with verge on being counter-productive in the real world.

Just to fill in a little bit of my own background, I graduated from the University of Illinois - Urbana/Champaign a little over a year and a half ago. When I began my education there, the initial CS course for CS majors was taught in scheme, so perhaps I'm a little biased. However, roughly two years into my education, the school began moving classes over to java, beginning with that class. Having younger friends who took this class in java, I saw a noticeable deficiency of various core concepts that they should've been taught in that class. I'm not blaming java 100% for that, but it surely owns some of the guilt. As far as later classes go, I have no problem with them using whatever language is appropriate (typically prolog and lisp for AI work, C++ or java for data structures, and so on), but to teach an introductory course in an infelxible language is doing a disservice to the students.

Re:Scheme in CS

[Osty]

-- Rahul Jain

Why am I not surprised to see Rahul kicking in with the LISP material? Excellent points, all.

Re:Scheme in CS

[mandolin]

It levels the playing field. Students coming into the class already knowing C++ or Java or even Basic no longer have as much of an advantage over students that come into the class knowing little or nothing about programming.

Of course those who learned Scheme in high school will have that advantage.. (no, I didn't. I'm from the Pascal era.)

This is much better than Java, for instance, which more or less forces you into OO design.

Since my skills in Scheme are, shall we say, not up to snuff, I will put this next bit in the form of a question:

How does Scheme, as a lisp (successor? derivative? argh) not force you to design more recursively and/or functionally (ie, functional programming)? Certainly straight-up procedural programming is not encouraged except as a speed "hack"?

Re:Scheme in CS

[Anonymous Coward]

Witness the power of (mapcar It's a completely different kind of mindset than the procedural languages.

And then return to that mindset, but with more flexibility, with LOOP? :)

-- Rahul Jain

Re:Scheme in CS

[Anonymous Coward]

The previous year (and the next year as well), this class was dedicated to Prolog, which I think as being more useful and less boring.

And then you can do something even more interesting, like implement a Prolog compiler in Lisp and then extend it to do even more! (this is done in Paradigms of Artificial Intelligence Programming by Norvig if you haven't seen my other post about it)

-- Rahul Jain

Re:Scheme in CS

[ed1park]

Your "leveling the playing field" argument is a minor point, if not irrelevant. Certainly not a reason to force a niche/esoteric language on a class.

Your second point is a little more controversial. Scheme does not necessarily allow you to focus on concepts rather than language idiosyncracies. One could argue that this unforced programming model is an idiosyncracy of the language itself. (eg: Too many methods can make for a messy codebase/unmaintanable code)

Besides, learning the idiosyncracies of a language is important early on. Anyone can understand the concepts (unless the concept itself is idiosyncratic ;). It's the idiosyncracies that take time to learn and master.

And a good teacher will always be able to get the concepts across, whether the topic is organic chemistry, quantum physics, or computer programming. Difficulty in teaching a concept just because you are using Java as opposed to Scheme is a poor excuse.

Regardless, both these points seem geared to helping the teacher, rather than the student. And they are much less relevant to the merits of the language itself.

If anything, a lecture or two should be enough of an introduction along with an *optional* full semester class for the feisty ones. :)

A CS degree will not help you to think, learn, and problem solve any better than the certifications you disdain. And to think that scheme or any language is a vital part of this process is misleading at best.

If anything, 4 years of any subject will most likely weed out the completely incompetent. The great programmer will kick ass regardless of academic background (eg: Stallman:Phd, Carmack:college drop out).

I'm sure there are even those who've received the equivalent of an ivy league education from the local library for a $1.50 in late charges. :)

Focus, curiosity, and hard work are much more important than any language or teaching style.

On a side note... If scheme/lisp makes for such better programmers, then why isn't the market clamoring for more?

Probably because it's overrated.

Re:Scheme in CS

[Osty]

How does Scheme, as a lisp (successor? derivative? argh) not force you to design more recursively and/or functionally (ie, functional programming)? Certainly straight-up procedural programming is not encouraged except as a speed "hack"?

Scheme (and lisp, though I haven't played around much with CL) is flexible enough to let your program procedurally or OO. It's a functional language, and relies a lot on recursion, but that doesn't mean you have to recurse. There is syntactic sugar to write things such as for loops or while loops (obviously I'm using the C/Java style syntax here, because it's been forever since I've used scheme). That syntax may very well translate into recursion calls, but as far as programming goes, it looks procedural. OO, when I learned Scheme, was more of a message-passing type of paradigm (think ObjC, if you're familiar with that), rather than a class.method type of syntax. The point is not the syntax, but the concept, and scheme lets you explore all three major paradigms within a single language. The best C++ can do is two out of three, and Java's pretty much a one-pony show (OO, and screw you if you want to do anything else), though I guess you could hack your way into a procedural paradigm (lots of static methods, for instance).

As far as I know, it's encouraged that you program recursively in scheme (specifically, use tail recursion if at all possible, for performance reasons), but that wasn't really my point. My point was that you can get a taste of all three with only one language, one syntax.

Re:Scheme in CS

[Anonymous Coward]

you should pay for their tuition so they won't have a problem learning bullshit.

Re:Scheme in CS

[mvw]

More importantly, the concept of code generation and evaluation as part of the language semantics is NOT possible in C or C++.

Which is bull, because all these languages, even assembler, are computationally equivalent (Turing complete).
It is just more work and uglier to achieve.

Re:Scheme in CS

[Shillo]

> Which is bull, because all these languages, even assembler, are computationally equivalent (Turing complete). It is just more work and uglier to achieve.

No, the original poster is quite right. Code generation and evaluation means that a LISP program can parse and rewrite itself. The 'rewrite' part is possible but ugly as hell in C (dump the source, exec the compiler, dl_open... you get the idea?). LISP macrosystem and Scheme syntax transformer allow you to modify the /compiler/ in a Turing-complete way. (and no, #defines are not Turing complete, nor they can parse their arguments).

--

Re:Scheme in CS

[mvw]

The 'rewrite' part is possible but ugly as hell in C (dump the source, exec the compiler, dl_open... you get the idea?).

That's why I used 'ugly' in the first place, if you cared to read.

On the other hand this is a somewhat artificial uglyness, because compilation is usually delegated to external programs (the compiler) and not integral part of the run time system, which makes it harder to use and to get perceived more artificial than the built in byte code compilation of those interpreted functional languages. This has nothing to do with the language, why not have C++ running on a VM and with an easy integrated compilation function? (Will something like this not be part of .NOT?)

(and no, #defines are not Turing complete, nor they can parse their arguments).

I didn't claim that. But templates (which are one of the means Stroustrup tried to get rid of the preprocessor) offer such computation power at run time: This link to template metaprogramming should give an example.

Regards, Marc

Re:Scheme in CS

[jaoswald]

Your use of "interpreted functional languages" indicates an ignorance of current Lisp practice. Lisp implementations typically *compile* to efficient native code. Even if you ask it to compile a new function at run-time.

You've also omitted all the problems of re-linking C++ code after you've compiled it, and forgotten about the problem of what to do when you re-define a base class. When the class members all change their positions, how do you go back and fix all the accessors? In C++ you need to do a full recompile of the system. Not so in Lisp.

C++ templates are an impressive hack, but are much less elegant than Lisp macros (the macro expansion is described in the Lisp language itself, so there isn't any new, messy syntax.) Plus, templates lead to enormous code bloat.

Re:Scheme in CS

[mvw]

Your use of "interpreted functional languages" indicates an ignorance of current Lisp practice.

I apologize for that statement. What I wanted to approach was that when talking about languages, one often includes the development/execution environment of the typical language implementation.

In case of Lisp these are the integrated systems like the ones you describe.

In case of C++ the environment is split into compilers, linkers, assemblers with very loose coupling. And thus lead to this big recompile in that case you describe.

But I see no reason (which doesn't mean that there is one :-) that one builds a C++ system that has many of those Lisp features. I guess it would have to modify or get rid of the present object and library file models.

How do the Lisp implementations solve the problem of linking libraries from different vendors?

LISP on Windows

[Multiple Sanchez]

Does the relative absence of a good, free LISP interpreter for Windows ever give you pause?

Re:LISP on Windows

[eblake]

You can run GNU emacs (or xemacs, if so inclined) on Windows. Pre-compiled binaries can be found here. Therefore, there ARE free LISP interpreters available for Windows, and all other platforms which emacs has been ported to.

Re:LISP on Windows

[Ehud]

CLISP is alright. It doesn't compile to native code, but it's still very fast. It's at clisp.sourceforge.net, I think.

Re:LISP on Windows

[Anonymous Coward]

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

Re:LISP on Windows

[hding]

The right link for XAnalys is actually here (no 'i').

Re:LISP on Windows

[Anonymous Coward]

MIT's scheme implementation, called "scheme" or occasionally "c-scheme" works just fine on windows...

Re:LISP on Windows

[sv0f]

Does the relative absence of a good, free LISP interpreter for Windows ever give you pause?

People stopped using Lisp interpreters decades ago. Everything's compiled now, and has been for a while. In fact, Common Lisp implementations led the way in the arena of incremental compilation, e.g., Macintosh Common Lisp has had this capability for over a decade, even on hardware of trivial power compared to what we have now.

Franz and Xanalysis have free trial versions of their Windows environments. CLISP works under Windows. For an amazingly cheap native Windows Common Lisp, check out Corman Common Lisp.

Re:LISP on Windows

[Anonymous Coward]

Corman is pretty hot. But its runtime performance is only about half as fast as the typical compiled language for the things that typical compiled languages usually do. That's good enough about 97% of the time. If you don't do the other 3% of apps that need high performance, it's fine. But, it is nowhere near full-featured for things like what comes as components with Delphi or VB right out of the box. For just developing in the face of algorithmic complexity, it's a great choice, but it's not a great choice for developing the next killer shareware program end-to-end.

CLISP on Windows is very slow. Maybe 20 or more times slower than Corman. This is still acceptable for many apps. But for developing Windows-style apps and components, it is way behind Corman.

Re:LISP on Windows

[Lemmy Caution]

I like LISP, but I have to agree with the above poster (and in the interests of having his question posed to Kent Pitman, advocate that he get modded up.)

The free implementations of LISP on Windows are usually crippled or limited, with limits in stack sizes or ability to save images, etc. And vital libraries are often missing from the free versions. CLISP is a nice try, but it's far from a fully useable implementation. GCL doesn't work with (any reasonable recent versions of) cygwin. The trial versions of Franz look promising, but it's hard to justify paying the prices for the Windows implementation when such good implentations are Free in *nix.

I think that this is a fixable lack, but it should be pointed out as a lack.

Re:LISP on Windows

[J. Random Software]

As environments go, Emacs-Lisp is awfully primitive. No lexical variables, no package system, no reader macros, and worst of all no object system. There's a "cl" package that tries to emulate some of these, but since the interpreter can't special-case them the speed hit is often stunning.

Where has Lisp been?

[mikewelter]

I've suggested to my employer that we use Lisp to generate some source code as a product of pattern matching. His response was "where has Lisp been for the last seven years?" He's right. No new books. No press. No interest. Do you see Lisp falling off the end of the earth?

Re:Where has Lisp been?

[Anonymous Coward]

http://www.amazon.com/exec/obidos/ASIN/0766815498/ qid=1002909421/sr=1-7/ref=sr_1_11_7/104-1175732-17 94308

http://www.amazon.com/exec/obidos/ASIN/007000484 6/ qid=1002909421/sr=1-6/ref=sr_1_11_6/104-1175732-17 94308

http://www.amazon.com/exec/obidos/ASIN/052156247 3/ qid=1002909421/sr=1-14/ref=sr_1_11_14/104-1175732- 1794308

http://www.amazon.com/exec/obidos/search-handle- fo rm/104-1175732-1794308

http://www.amazon.com/exec/obidos/ASIN/092987053 0/ qid=1002909421/sr=1-18/ref=sr_1_11_18/104-1175732- 1794308

http://www.amazon.com/exec/obidos/ASIN/156592261 1/ qid=1002909421/sr=1-21/ref=sr_1_11_21/104-1175732- 1794308

http://www.amazon.com/exec/obidos/ASIN/087930518 5/ qid=1002909421/sr=1-24/ref=sr_1_11_24/104-1175732- 1794308

http://www.amazon.com/exec/obidos/ASIN/071678269 3/ qid=1002909581/sr=1-31/ref=sr_1_2_31/104-1175732-1 794308

http://www.amazon.com/exec/obidos/ASIN/013605940 6/ qid=1002909581/sr=1-36/ref=sr_1_2_36/104-1175732-1 794308

Re:Where has Lisp been?

[Anonymous Coward]

Well for one:

The entire Crash Bandacoot series for Playstation...

Re:Where has Lisp been?

[Junks Jerzey]

No new books. No press. No interest.

Some Lisp and Scheme books published in the last ten years:

Paradigms of Aritificial Intelligence Programming (Norvig)
ANSI Common Lisp (Graham)
The Little Schemer (Friedman & Felleisen)
On Lisp: Advanced Techniques for Common Lisp (Graham)
Lisp in Small Pieces (Queinnec & Callaway)

Re:Where has Lisp been?

[Anonymous Coward]

Oh dim one, YHBT, by your employer. If Microsoft started selling Lisp tomorrow, your Boss would embrace it like the $1.50 whore he is.

Re:Where has Lisp been?

[Anonymous Coward]

They stole that from the crack.com guys, see http://www.abuse2.com. Abuse had a lisp interpreter that user's could use to add on new characters and game-types. I think the game was written in 10% Lisp and it runs damn fast.

Probably the main reason there is still a community around this game even though it came out in 95.

damn fun game if you haven't tried it.

Re:Linux -- Not an executable?

[Anonymous Coward]

What is the extension of the file you're trying to open? If it is something like .tgz, .tar.gz, or something similar then you need to download winzip to open it. If it is .rpm then you can't use it in Windows. If it is .iso then you can burn it to a cd-rom and boot the cd and the linux will come up after that.

"Good" applications for Lisp

[HyperbolicParabaloid]

I'm a professional programmer, mostly Java, primarily in the financial services industry. I've recently become interested in Lisp (UPS delivered Graham's book yesterday).
It seems to me that Lisp would be useful in areas such as derivatives ananlysis, where people come up with a new exotic type of option every day. I'm still learning about Lisp, but it seems that it might provide more flexibility to handle this constant evolution.
Is that analysis accurate? What general types of problems is lisp best suited for?

Re:"Good" applications for Lisp

[Andreas Rueckert]

Take a look at JScheme. You can embedd it into your Java spps.

Re:"Good" applications for Lisp

[sv0f]

It seems to me that Lisp would be useful in areas such as derivatives ananlysis, where people come up with a new exotic type of option every day. I'm still learning about Lisp, but it seems that it might provide more flexibility to handle this constant evolution.

Here are two reasons to use Common Lisp:

(1) It's numeric facilities are among the best thought-out of all programming languages, certainly better than those in more mainstream languages. For example, for decades Common Lisp programmers have not worried about integer overflows. Machine-sized integers are extended automatically to 'big integers' and contracted back as needed. Thus, one can compute efficiently and safely with integers in Common Lisp as a mathematical abstraction, regardless of their size. Contrast this with the bifurcated integer types of Java.

(2) Many of the major mathematical programming languages (e.g., MACSYMA) are Lisp-based. Emerging statistics packages such as R derive their semantics from the Scheme variant of the Lisp family. Lisp has proven capable of scaling up for the most demanding mathematical applications. This bodes well for its application in your area.

Re:"Good" applications for Lisp

[andorxor]

Then take a look at this paper:

Composing contracts: an adventure in financial engineering
by Simon Peyton Jones, Jean-Marc Eber, Julian Seward

"Financial and insurance contracts do not sound like promising territory for functional programming and formal semantics, but in fact we have discovered that insights from programming languages bear directly on the complex subject of describing and valuing a large class of contracts."

Should be definitely worth a read for you!

Re:"Good" applications for Lisp

[reflective recursion]

Where C and C++ tend to optimize for machine speed, Common Lisp tends to optimize for development speed. Where Java sits, I'm not so sure (as I don't use it). I would guess closer to C++ than CL. Common Lisp seems like a good choice to handle your need for "constant evolution."

Re:"Good" applications for Lisp

[Anonymous Coward]

> Java sits, I'm not so sure (as I don't use it).

Tries to do both, doesn't fully succeed in either.

Re:"Good" applications for Lisp

[SuperKendall]

From my expereience programming in both Scheme and C++, I find Java actually closer to Scheme than C++. At least the same though processes I used for Scheme seem to map over well.

One complaint I've seen C++ programmers have is that Java is more like Lisp than C++!

Re:Linux -- Not an executable?

[raz16]

IMHO you have downloaded something for Linux, just another OS.

Educational vs. production languages

[thinmac]

Lisp and scheme are both used in educational setting pretty commonly, but I don't know of any production projects (which isn't to say they don't exist) that use either language. Could you discuss the difference between what makes a good educational language and a good working language, specifically as to why it might be useful to learn in a language that you are unlikely to ever use in a work environment.

Re:Educational vs. production languages

[Publicus]

I could be wrong, but I believe that Emacs is written in Lisp. I know that it contains its own Lisp interpreter for writing extensions. Does anyone know what language was used to develop Emacs?

Re:Educational vs. production languages

[Ehud]

Franz has a few listed on their webpage: here.

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

Re:Educational vs. production languages

[SamBeckett]

Yahoo! Store is written in Common Lisp. It sold for $30 million a few years back.

Re:Educational vs. production languages

[Anonymous Coward]

too bad the source code for eamcs isn't available. If it was, you'd be able to answer the question yourself.

Re:Educational vs. production languages

[Anonymous Coward]

And now Yahoo! is falling apart.

Re:Educational vs. production languages

[jrockway]

That's correct. Emacs is pieced together in lisp, with small components written in C (the core). It's a good idea actually. Truly object oriented :)

Re:Educational vs. production languages

[Anonymous Coward]

After they rewrote Yahoo! Store in Perl or Java (it was one of those languages...)

Lisp as a Macro Language

[wiredog]

Are there any programs other than Autocad and Emacs that use lisp as the macro language?

Re:Lisp as a Macro Language

[rgmoore]

I can think of at least one other program that does: the Sawfish window manager that's now the default WM for GNOME.

Re:Lisp as a Macro Language

[dmelomed]

Abuse the game from crack.com had it's levels written in Lisp. And it was an awesome game too.

Re:Lisp as a Macro Language

[sv0f]

MACSYMA, the mathematical programming language. A lot of languages are based on Lisp's semantic model, so that understanding Lisp allows you to understand them. This is true of the rapidly-emerging R statistical language, the Curl language that was discussed on Slashdot recently, etc. I think that the internal representation of GCC is Lisp-based. Some have said that XML is basically a subset of the representational capabilities of Lisp. A development tool for Ninetendo games (Nichimen?) is Lisp based. I think that one of Adobe's web-creation programs is Lisp-based or was in its first version (i.e., because of Lisp's rapid prototyping capabilities). One of Autocad's competitors is, I believe, also written in Lisp. Many expert system authoring tools. Etc etc. (Any errors in the above unintentional.)

Lisp tends to lurk behind the scenes, the competitive advantage that company's don't want you to know they're using to run circles around you. Paul Graham talks about this on his website.

Re:Lisp as a Macro Language

[Anonymous Coward]

Some Gnome programs use Guile (an implementation of Scheme) as their Macro Leng. maybe because Guile is the official macro Leng. in GNU

Re:Lisp as a Macro Language

[kmcorbett]

Also: Interleaf the desktop publishing system. We put in a LISP interpreter to allow users to script desktop commands. Then we rebuilt the UI in LISP and put hooks in the publishing layer. We built a business around "active documents" with tools for hypertext, dynamic / data-based content, etc. Much hijinks ensued.

/kmc

List in Mathematics Programming

[Anonymous Coward]

Gregory Chaitin has a book called "the limits of mathematics." In it he claims that mathematicians should love Lisp because Lisp is basically set theory, and all mathematicians love set theory. I wholeheartedly agree with this, one only needs to look at Chaitin's Lisp programs to realize how quickly and succinctly one can arrive at astonishing incompleteness results in mathematics. So we know Lisp is great for stuff like this, really researhing a mathematical subject. Do you see Lisp continuing in this direction, showing and discovering theorems, or will it move into industry? Or has it moved into industry, and we just don't know it? Do the likes of NASA and JPL use Lisp and Scheme religiously? I would bet so.

Re:List in Mathematics Programming

[Anonymous Coward]

Mathematicians should love Haskell.
Oh wait, they do, nevermind me.

Re:List in Mathematics Programming

[sv0f]

Note also that Douglas Hoftstadter is/was a Lisp fan. He devoted three columns to it, which can be found in his "Metamagical Themas". (Note that this is an old dialect.)

Re:List in Mathematics Programming

[Black Parrot]

> In it he claims that mathematicians should love Lisp because Lisp is basically set theory, and all mathematicians love set theory.

To say nothing of recursive functions (in the mathematical sense). Lisp is, at its core, and implementation of Church's lambda calculus.

Re:List in Mathematics Programming

[kmcorbett]

...to say nothing of the Dog. I have heard that LISP is based on a _flawed_ implementation of the lambda calculus. Maybe Kent can explain. /kmc

I had to say it

[smileyy]

We're no closer to having infinite memory and infinite processor speed than we were 40 years ago.

mmmm...a set of bits of cardinality aleph-null...

Re:I had to say it

[Anonymous Coward]

Gee... I dunno. My home box is not approximately
10,000 times faster and has 10,000 times more
memory than state of the art computers 40 years
ago.

That's nowhere near infinity, of course...
but it MAY mean that lisp's time has finally come...

Too damn hard

[HyperbolicParabaloid]

There don't appear to be a lot of Lisp programming jobs out there right now. I suspect that is because there aren't many commercial Lisp projects, perhaps because there aren't many Lisp programmers....
If Lisp is so great, why is that so? Or, more positively, how do we overcome this bias against Lisp?

Re:Too damn hard

[sv0f]

There don't appear to be a lot of Lisp programming jobs out there right now.

When I've searched for Lisp jobs in the past, I've always found tens of hits on Monster. It is possible to get Lisp jobs in University towns and big cities across the country, and particularly easy on the coasts. What's cool is that people use Lisp to do cutting-edge stuff. These jobs are almost always challenging and your coworkers smart and intellectually-diverse cookies. You're not just surrounded by Perl monkeys.

Re: Too damn hard

[Inthewire]

There don't appear to be a lot of Lisp programming jobs out there right now. I suspect that is because there aren't many commercial Lisp projects, perhaps because there aren't many Lisp programmers....

Appropriate for a language touted for recursion, eh?

Re:adequacy

[Anonymous Coward]

Hey - just what the world needs - another site for morons to go on and on about how the world would be better if THEY were in charge. Is Inadequacy.org taken?

Re:hi, my question is...

[stevenbee]

That'th not a lithp. Thith ith.

Future of Scheme?

[Larne]

The IEEE spec has expired, I can't find any information about efforts towards r6rs, and not much seems to be happening on the SRFI front. On the other hand, there's an active Scheme community and dozens of implementions, and it seems more show up daily.

How do you reconcile these apparent contradictions, and where do you see Scheme going?

Re:Future of Scheme?

[Waffle Iron]

> The IEEE spec has expired
This seems to be true. When I tried to run my Scheme interpreter today,
this is what it output:
(but (are (sorry we))
(has (expired (IEEE-specification Scheme))))
(for (interest your (in Scheme)) thankyou)
(provide (to you) (are (hard (working we)))
(replacement (a technology)))
(may (meantime (the in))
(suggest we (try you (other (fine languages)))
(such-as (Python Ruby Haskell C# Java Forth))))
(for (are (sorry we))
(caused (any (inconvenience you))))

Re:Future of Scheme?

[Anonymous Coward]

The trouble is, you don't think.

The prerequisite FP question

[Larne]

What are your thoughts about Haskell, OCaml, and teh state of functional programming in general?

Re:The prerequisite FP question

[Vagary]

What's the future of functional programming? (Or: what will the languages derived from Lisp and Scheme be like?) It seems that these languages are encompasing concurrency, logic programming, imperitive, and object orientation; is this a plan for world domination? What happens next when you have a language capable of every major programming paradigm? What would be the next big thing after Java if you had your way?

Re:The prerequisite FP question

[Anonymous Coward]

>What are your thoughts about Haskell, OCaml,
>and teh state of functional programming in general?

Functional programming is more alive than ever. Like every advocate of functional programming for the past 20 years, I will also predict that functional programming will become mainstream within 5 years!

No, seriously, functional programming will be integrated fully with OO in 5 years. Then the power of functional programming will be obvious, the beautiful symmetry in all its facilities. The power of functional programming will be at the fingertips of every programmer. It will not be called functional programming, though, because the name has got a bad taste from Common Lisp.

Functional programming has taken this long to get mainstream, because there were hard technical problems that were not solved until recently. Those problems are also present in every other language, which just work around them. Functional programming languages couldn't "work around" these problems because they were functional, and tried to give the programmer all the power they need.

For example, the problem of recursion. Recursion is probably the most misused feature in any programming language. Functional programming is based on recursion. However, recursion has not been understood well until recently. How many current programming languages can ensure that recursion is not misused? How many languages can detect infinite loops by bad uses of recursion? None. (oh btw, recursion and while loops are alike, while loops have neither been understood!). However, there are mechanisms that can be used to make recursion well-behaved. None of those accidental infinite loops any more!

So, while waiting for the real solution, everyone *must* learn Haskell. It is vital! The next boom will be the introduction of functional programming to the masses. The masses will not know it's functional programming, but then, they did learn modularity (once it was renamed OO). Then anybody who does not know about functional programming will be without doubt behind the cutting edge, waiting to become redundant.

Haskell is very close to the ideal model. It's just not there yet. It's missing one crucial mechanism: symmetry. This is why Haskell does not have OO [Because Haskell already has its symmetric counterpart, algebraic datatypes!]

Worse is better...

[PHAEDRU5]

I love Lisp, and "The Little Lisper" is one of my all time favorite computer books.

However, I think Lisp will never be more than a niche language, for reasons Richard P. Gabriel has made all too obvious.

My question, for what it's worth, is "Why bother?"

Re:Worse is better...

[blif]

The Rise of ``Worse is Better'' is a interesting paper! the analysis "PC loser-ing problem" is right on the mark.

When I first started unix programming, one of the programs I had to maintain had intermittent and seemly random read failures. After much debugging, it turned out that the read call was occasionally failing with errno == EINTR because it was getting interrupted by an ALRM or something. The solution was trivial - I put in a retry if read failed with EINTR.

EINTR is very counter-intuitive and my mistake was quite understandble. I've encountered bunch of other things like that in unix; e.g. that malloc isn't guaranteed to be reentrant.

But, I love unix. Similarly, lisp is cool (I had a lot of fun with the little lisper) but I never have and never will be paid to use it and I don't think I'd really like to do any substantial work with it (though knowing it probably helped me learn perl more quickly).

Re:Worse is better...

[Anonymous Coward]

well, you need a way to break out of blocking calls...

signals and EINTR isn't really the best way, but its quite workable, and also decreased implementation complexity for unix kernels. Win win.

Re:Worse is better...

[Anonymous Coward]

There is a story about exactly this "feature" of UNIX. Other OSes at the time had the same problem [of course] and solved it transparently to the application programmer. UNIX does it this way, so (1) every single program must have the retry loop on every single call and (2) they don't. And the reason wasn't "decreased implementation complexity" but just because the UNIX programmers couldn't work out how to do it properly.

However, that "Worse is Better" article is just a bunch of tripe. Yes, if you assume that LISP is "better" you might come to that conclusion, but it saddens me how many people allow their preconceptions to warp their entire world view, rather than ditching their preconceptions. I'm talking here about the author of that paper, Richard Stallman, and a few others.

Re:Worse is better...

[Anonymous Coward]

"I'm talking here about the author of that paper, Richard Stallman, and a few others."

You're not saying the author of the paper is Richard Stallman, right?

Just making sure you actually read the paper before pronouncing it a bunch of tripe.

Lisp - Scheme - ML

[Tom7]

I know a lot of big academic (erstwhile) lisp shops, such as CMU, have transitioned away from lisp to ML and relatives. Some of the reasons we might give are:

- Sophisticated type systems, catching most bugs before your program is run, ensuring safety, etc.
- Much more efficient (http://www.bagley.org/~doug/shootout/craps.shtml) , partly due to compilation strategies using types
- Increased modularity and abstraction
- Pattern matching, (subjectively) more natural syntax

In fact, I'm one of those people. I've been scoffed at by lisp fans, but most had never used ML. But I have an open mind, so, in the face of more "modern" languages, what advantages do lisp and scheme offer? Do you think that these advantages are fundamentally impossible to achieve in a typed setting?

Re:Lisp - Scheme - ML

[Anonymous Coward]

It's amazing how cmucl happens to come in just behind SML/NJ on that test. Oh yeah, that's because LISP compilers use type analysis to generate code, I forgot all about that.
You know what's funny, is that Franz's commercial compiler is several times better than cmucl, too.
It's also really quite interesting that LISP provides a type system too.
And while it's at it, it offers method genericity, so I don't need to quality every method with a namespace. Of course Haskell has an excellent solution to this with its type classes, I doubt you were including it in your mental ML list because the syntax is much different.

I don't see increased modularity or abstraction in ML versus Common LISP. Perhaps you should elaborate.

Pattern matching is indeed convenient, to an extent, but not necessary when you have generics.

Re:Lisp - Scheme - ML

[Junks Jerzey]

There are two schools of thought:

1. We need to determine everything at compile time, so we can prove properties of our programs.
2. We should make everything as dynamic as possible, so we're not prematurely locked into a solution.

You could argue either way, but it's a split decision. Some schools lean one way, some the other.

Re:Lisp - Scheme - ML

[Peaker]

Do you think that these advantages are fundamentally impossible to achieve in a typed setting?

Common LISP has optional static typing, as far as I know..

The advantages have nothing to do with typing.
In LISP, one can write macros and reader macros to have Python, perhaps ML, or any other language run. This means that LISP encompasses all other languages through writing some macros, and is thus as powerful as them all, combined.

Re:Lisp - Scheme - ML

[Anonymous Coward]

WTF is cmucl?

He said CAML... duh?

Re:Lisp - Scheme - ML

[Tom7]

The "optional static typing" that lisp and scheme have are not the same as what you have in ML. One obvious difference is that the types are inferred in ML, so that you have to write down even less type information than, say, C. ML also has a more sophisticated type system than the annotations supported in some lisp and scheme implementations. (Recursive types come to mind.)

The "more powerful than them all" argument isn't very compelling. It would be nearly trivial to write a lisp interpreter in ML (modulo libraries). Does that mean that since Lisp "encompasses all languages", and lisp is easily implementable in ML, that ML is the clear winner? No, that's silly. Instead, it is the ease with which we can express clear and efficient programs that we should judge the power of a programming language.

Re:Lisp - Scheme - ML

[Anonymous Coward]

CMU Common LISP.

Duh?

Re:Lisp - Scheme - ML

[jacobm]

Actually, the PLT Scheme distribution comes with a tool called MrSpidey that does implicit static type analysis on your Scheme programs. It allows recursive types and all that fun stuff. The only problem is it doesn't work well when you use some of PLT Scheme's more advanced features, such as its class system.

Re:Lisp - Scheme - ML

[Black Parrot]

> I've been scoffed at by lisp fans, but most had never used ML.

I'm one of those who've never used ML (along with a dozen other languages I wish I had time to try), so this is not intended as a scoff. However:

> Sophisticated type systems, catching most bugs before your program is run, ensuring safety, etc.

I'm a fan of that too, which is why I almost always program in Ada. However, I also see the value of dynamic typing as used by the Lisp family of languages. It makes some stuff really easy, at the cost of having to be careful with the coding. (Horrors, that we should ever feel a need to be careful with our coding!) It's not really so hard, when you start thinking functionally: every function is a filter that accepts data of some particular type(s) and returns a result of some particular type(s). You need to enforce a discipline of ensuring that every function is called with an appropriate type or else of ensuring that every function checks the types of its arguments, but that's very doable.

> Increased modularity and abstraction

<noscoff>That's an interesting claim, since I always thought you could make Lisp as modular and abstract as you cared to.</noscoff>

> Pattern matching

Seen that in 1st-semester CS classes that use Scheme.

> (subjectively) more natural syntax

You may be on to something more than subjective, there.

Re:Lisp - Scheme - ML

[Anonymous Coward]

Lisp compilers have type inference. CMUCL does a reasonably good job of it, and the latest version of LispWorks contains many improvements, including looking at side-effects to analyze the changing types of variables (at least this is the impression I get from discussing some of the observations of a LispWorks beta tester).

The difference between implementing ML in Lisp (sans first-class-continuations) is that instead of interpreting, you can simply convert the code to Lisp eqivalents and let the Lisp compiler take over from there. This is why Lisp is full of sublanguages like LOOP and FORMAT with a totally non-Lispy syntax, but which are compiled just like any other Lisp code.

-- Rahul

Re:Lisp - Scheme - ML

[Anonymous Coward]

Fuck you. CMU loves C, and SML is used for nothing more than mental masterbation.

Grow up.

--A CMU Grad with a JOB!

Re:Lisp - Scheme - ML

[Peaker]

Writing an interpreter is not quite equivalent to macros/reader macros. Also, implementing a LISP interepreter, with macros, reader macros and other LISP semantics will NOT be trivial in ML :)
The resulting program you may have, if you write it, may be the winner-language, but that doesn't make ML the winner, as you wont' be able to use it from within ML itself, it will be a separate language.

relative benefits of using Scheme and LISP?

[Anonymous Coward]

Given that LISP and Scheme have traditionally been portrayed as research languages most suitable for AI work, and have not been accepted as widely as more traditionally structured languages such as C:

-What arguments would you give to convince programmers looking for easier ways to accomplish traditional computing tasks to use LISP or Scheme, mindful of the overhead required to learn LISP and Scheme and the lack of programmers who are intimately familiar with them?

For example, I start to develop an OpenSource text editor at SourceForge, and I choose Scheme. What advantages would I have over someone using a language such as Java or C++ that would outweigh the fact that I might not be able to find another developer who is familiar with Scheme?

-Do you feel that any work is being done at present to bring the two languages further into mainstream?

Thanks, I genuinely like both languages, and would like to seem them gain greater adoption by programmers et al.

Why learn lisp -- deeper reasons needed

[billr]

I've read some interesting articles about lisp, and I'm interested in learning to some extent.

One problem though is that most people stop at saying that feature X (which no other language can do) is really great, and stop there. Never having used feature X, I don't have enough context to say, yes that will help me solve problems more easily.

For example, somebody claims that LISP is better because a lisp program can write code as it goes, or something like that. Having never had that as an option I can't see circumstances where I'd want to do that.

Could you please describe in some detail the top features of lisp and why they are GOOD THINGS?

Also, I promise to not make fun of parenthesis if you don't state that infix notation is one of the reasons that lisp is good. ;)

Re:Why learn lisp -- deeper reasons needed

[billr]

Ha ha. prefix that is.

Re:Why learn lisp -- deeper reasons needed

[Anonymous Coward]

There's nothing wrong with prefix notation.
Most functions programmers create are not infix operators, and thus that they are the first element of a list isn't much different if they were moved outside a parenthesis.

The number of infix operators are small, and that people object so strongly to using prefix notation with things they would otherwise consider infix notation is a bit odd. You'd think they'd never owned a non-TI calculator, or that they couldn't see advantages in clarity or potential conciseness.
It also keeps retarded programmers from typing a/g+b+c*d/e without any spacing or the like.

Re:Why learn lisp -- deeper reasons needed

[chompz]

you can change the syntax to anything you want

Isn't that a strength?

Re:Why learn lisp -- deeper reasons needed

[Anonymous Coward]

You can't change the way it evaluates expressions. I'm sorry, RPN style code just plains sucks for both readablity and coding.

Re:Why learn lisp -- deeper reasons needed

[Xenophon Fenderson,]

Nice troll. Unfortunately, you are wrong.

Reverse Polish notation, also called "postfix notation", has the arguments first, followed by the operator. For example, "3 2 +". Lisp programs are typically written directly in the language's abstract syntax, using the prefix notation and parens with which many are familiar. For example, "(+ 3 2)".

Common Lisp's reader (aka parser) is, however, fully under program control. Through CL's readtables, one can extend the basic prefix notation, e.g. CL's sharpsign-S macro to read in structure objects is "#S(typename :field1 val1 ...)" as opposed to calling MAKE-typename the usual way "(MAKE-typename :field1 val1 ...)". One particulary perverse use of Common Lisp's readtables is a package that implements an infix syntax for basic arithmetic operators, e.g. "#I(2 + 3)".

Unlike static languages like C or Java, almost everything about the Common Lisp run-time environment is under program control. Even the object system can be modified (through something called the Meta Object Protocol). And idiomatic Common Lisp code is often times within a factor of two of idiomatic C code in terms of performance.

Overlooked practical aspects of Lisp

[hding]

Why do you think that people so often overlook many of the wonderful things in Common Lisp such as unwind-protect, the whole condition system (which you are of course closely associated with), and so on - things that make it very useful for day-to-day programming, and are there any such things that you'd particularly highlight, or conversely that you wish had become part of the standard but did not.

Incidentally, thank you for all of the insight so generously and regularly poured forth in comp.lang.lisp.

Good texts for learning Scheme?

[drenehtsral]

I have recently been working on learning Scheme in my spare time, with the eventual goal of writing a scheme based scripting system to run the guts of a massive adventure game/graphical mud sort of system, everything from environment simulation (predator/prey cycles, etc...) to 3d models (i.e. models will be geometry glued together by scripts so you could have trees that by a random seed and a growth level variable have grown over time and are unique to provide interresting landscape features). Scheme is appealing because it's simple, powerful, and adapts well to the idea of a threaded interpreter.
To further my goal of learning Scheme inside and out, i've been reading "The Little Schemer", as well as "Structure and Interpretation of Computer Programs". Do you have any other recommendations for good Scheme programming texts?

Re:Good texts for learning Scheme?

[thallgren]

Try reading Essentials of Programming Languages by Friedman et al.

Regards, Tommy

Re:Good texts for learning Scheme?

[HongPong]

In my freshman CS class we are using the Scheme book "Concrete Abstractions," which is more oriented around theory than "The Little Schemer." A fine paradoxical title for a book. The author's name escapes me though.

Re:Good texts for learning Scheme?

[Anonymous Coward]

You may want to give "How to Design Programs" a look (http://www.htdp.org) a try.

Re:Good texts for learning Scheme?

[Anonymous Coward]

EOPL is a *great* book, but you ought to have a really good understanding of Scheme *before* reading this book

Re:Good texts for learning Scheme?

[SuperKendall]

I'd reccomend "Scheme and the Art Of Programming".

I used that and "The Little Lisper" (which I assume your book is a decendant of) when I was learning Scheme in school.

Re:Good texts for learning Scheme?

[Anonymous Coward]

Try "The Little Schemer" and "The Seasoned Schemer" as these are a bit newer and more scheme than lisp. Also, a good scheme text although it does focus on basic programming structure is "How to Design Programs" by Matthias Felleisen.

Re:Good texts for learning Scheme?

[SuperKendall]

I'd also reccomend the "How to Design Programs" book then, just based on my experience with Matthias Felleisen as a teacher and Scheme advocate!

Re:Good texts for learning Scheme?

[banka]

Here at UT we're using Concrete Abstractions as well, the author is Hailperin, Kaiser, and Knight et al.

New programming language ideas in Lisp?

[cardhead]

What I'm most intereseted in is not Lisp as a mainstream language, but rather Lisp as a research language. When people talk about the new things in programming languages these days, they talk about lazy evaluation, polymorphicly typed functional languages (e.g. Haskell). Since the ANSI spec, it seems as if Lisp has stagnated. CLOS gave us objects, but very little new has come down the pike since then. At one time, much of the new work in programing languages was done with Lisp. Now Lisp seems to be in the position of C: an excellent language that has aged out of the cutting edge. I guess my question is, is this a correct assessment, if so, should something be done about it and what should that be?

cheers,
ric

Lisp vs the world.

[hjs]

What do you see as the unique strengths and weaknesses of Lisp?

What strengths does it specifically have over other functional languages (such as ML), over structured languages (such as C, Algol, etc), over object oriented languages (such as C++, smalltalk, simula, etc), and over scripting languages (such as TCL, perl, etc)? Can these other languages or classes of languages be enhanced to include these strengths? If so, how, and if not, why?

What about weaknesses? What do you see as the weaknesses of Lisp, both in general and in comparison to the above classes of languages? Can these weaknesses be eliminated? If so, how and if not, why?

I mean strengths and weaknesses not only in the formal sense of the language itself, but also in terms of its usability in today's world. For example, difficulty in delivering binaries or lack of accessibility of system libraries from within common implementations of a language would be considered weaknesses.

Re:Lisp vs the world.

[Anonymous Coward]

What do you see as the unique strengths and weaknesses of Lisp?

What strengths does it specifically have over other functional languages (such as ML), over structured languages (such as C, Algol, etc), over object oriented languages (such as C++, smalltalk, simula, etc), and over scripting languages (such as TCL, perl, etc)? Can these other languages or classes of languages be enhanced to include these strengths? If so, how, and if not, why?

Lisp's advantage is that it encompassess all the paradigms of all those languages. This is because

Lisp has powerful macros which are not limited to some simpler language (cpp), but they can use the entire Lisp language including any functions you have defined. Therefore, you can do things like create an object system that is an addon to the language, yet has more features than most object systems that are integrated tightly into other languages.

Also, you can create macros that let you write code like:

(loop for i across my-vector
and j across other-vector
for k = (* i j)
summing k)

to get the dot product of two vectors (there are nicer ways, but this is one interesting one).

Also, in the book Paradigms of Artificial Intelligence Programming, Peter Norvig creates an entire sublanguage in Lisp which can be used for Logic programming (as in Prolog), including pattern matching functions and many alternative search strategies, choosable and definable at run time. He also extends this system to be more powerful than Prolog in a few ways. The book actually covers more about optimization of complex algorithms than specifics of AI programming, so I think it's a great read for any programmer who values space and time (which, I hope, is all of them).

-- Rahul Jain

A welcome alternative to Franz Allegro

[Multiple Sanchez]

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

Re:A welcome alternative to Franz Allegro

[Anonymous Coward]

Franz's compiler is simply beautiful. Where you got efficient from, I don't know, since I can frequently r0x0t gcc's s0x0rz with it.

First nontrivial program

[quigonn]

When you first learn a language, you often do toy programs for some time, until you know the most important features of the language. Then you should be able to try your skills out in a bigger application. Now I would like to know what program that was when you learned Lisp.

Re:First nontrivial program

[Anonymous Coward]

I think he said on c.l.l that his first nontrivial program was a FORTRAN to LISP compiler. He had been a FORTRAN programmer before he got into LISP, so this was an area where he had quite a bit of knowledge. The paper he presented on this topic is on his web site.

He's discussed this a bit on c.l.l before, but I'm interested in hearing more about it.

-- Rahul Jain

Scheme as an XML Translation Language

[Evangelion]

I've become fairly interested lately in using Scheme (probably mzscheme) and the SXML package as a way to do arbitrary XML translations in my free time (if I had any).

From the looks of it, the ability to create a reflexive mapping between an arbitrary XML document and an interpretable programming language is too powerful to be ignored.

Do you think that in the future one of the primary roles of Scheme/Lisp is going to be in manipulation of XML documents, or is this going to be relegated as an academic curiostiy while the world struggles through parsing XML in Java?

Re:Scheme as an XML Translation Language

[Black Parrot]

> From the looks of it, the ability to create a reflexive mapping between an arbitrary XML document and an interpretable programming language is too powerful to be ignored.

I looked at XML and thought it was too much syntax for a relatively simple problem, so I already ditched it in favor of Scheme as a data representation language.

Other people are taking the same route, e.g., Xconq uses a Scheme-like language for its scenario data.

Notice that your "stylesheet" can just be a program that does arbitrary transformations on your data, and also that you can include executable code in either the data, the stylesheet, or both. (Sandbox those applications, though!)

FWIW, when I was first learning Scheme I spent an evening writing a program that would accept an ad hoc "SBML" (Scheme-Based Markup Language) as input, and spit out an HTML output.

There's an old claim that "those who don't know Lisp are doomed to reinvent it, badly". IMO that claim was a prophecy of the coming of XML.

Re:Scheme as an XML Translation Language

[brenfern]

The irony of course is that XSL is derived from DSSSL, which is in turn a derivative of Scheme. Except that XSL loses because a) It's not Turing-powerful and b) It has the same stupid syntax as XML (which people still seem to tolerate; even though they complain about Lisp's round brackets, XML's angle-brackets are obviously more in vogue right now)

I noticed with interest a few months back the curl project which was a step in the right direction but had flaws of its own.

Personally my feeling is that Scheme/Lisp will always be stuck firmly outside of the mainstream for at least another 40 years because it lacks instant appeal, particularly to those without a CS background. I think it is a shame even to relegate it to processing XML; it should really be replacing both XML and XSL!

Re:Scheme as an XML Translation Language

[BitwizeGHC]

For XML applications I find that the easiest thing to do is write a translator that parses XML and converts it to a Scheme data structure that represents the various elements and character data, and perform any further operations on that. The code to do this is both small and fast, and really isn't too different from using a DOM (although it may be a bit more flexible).

That is, when I need to use XML. Ususally I just format data in a Scheme-type syntax for my own applications, when no boss is breathing down my neck. My comic site was constructed in this way.

Re:Scheme as an XML Translation Language

[brenfern]

And a fine site it is too. Keep up the random rants!

Actually you hit the nail on the head when you speak of using Scheme-type syntaxes only when no boss is breathing down your neck. It is perplexing that it has to be this way, as authoring Scheme is incredibly simple compared with authoring XML/HTML. For starters, you can use standard bracket-matching in your favourite editor and don't have to fork out for a special editor (XML Spy, Dreamweaver etc.)

Well, I never!

[Anonymous Coward]

Dear Sirs,

I must voice my strong objection to people ripping of stale Monty Python sketches revolving around faked letters to the editor in a sad attempt to get cheap yuks.

We all know that the only way to reduce crime is to reduce the number of offences. Get it out in the open, I say! Who, at one time or another, hasn't set fire to a great public building? Lord knows I have.



Brig. Gen. John A. Biggboote, (Mrs.)
Bumwap-on-the-Thames, Sissyshire

general types of problems

[Anonymous Coward]

Well, judging from Emacs, it's really insanely great for creating huge, bloated, overkill applications that hog more system resources than sendmail taking it in the ass from a horde of Nigerian fraud spammers. I mean, come ON people! You're editing TEXT! PLAIN! ASCII! TEEEEEEEXT!

Lisp used in finance

[hding]

I use Lisp for something similar in finance. So, yes, it does work for that.

Basis set for programming languages?

[PseudonymousCoward]

As a Scheme and Common Lisp programmer, I got excited when I heard that the Java Virtual Machine would have automatic memory allocation and garbage collection. I thought it would be possible to build Lispish languages to run on the JVM. The rate at which Kawa has been developed, to implement a near-Scheme on the JVM has been frustrating to me. I attribute this at least in part to the absence in the JVM of a construct equivalent to Scheme's continuations. Do you think it is feasible to establish a "basis set" of programming language concepts on which all programming languages could be built, so that the distinctions between C, Scheme, etc would be "merely" syntactic? If yes, please enumerate your candidate set.

Re:Basis set for programming languages?

[chompz]

to say it again, you can change the syntax in lisp to be anything you want, you can even make a C intrepreter in lisp. It wouldn't be very fast, but it would work. You can define a strongly typed language in lisp, and make it do anything you can think of. lisp is the original VM, designed to allow the programmer to code the same way that they think. Very usefull programming language from that standpoint.

Re:Basis set for programming languages?

[Anonymous Coward]

Common Lisp is a strongly typed language.

Re:Basis set for programming languages?

[Anonymous Coward]

ambiguity in that statement. All the lisps that I know of have typed data. Common Lisp has typed variables also, but only when the programmer wants them. This makes it easier to compile if the programmer has provided much type info. Scheme does not have typed variables; you can have a variable 'a' bound to any type of data, but you never run the risk of interpreting a pointer as a number - CL shares this feature, making them both "safe" languages.

Re:Basis set for programming languages?

[Shelrem]

Well, lets see. A turing machine can be (and is) used as the basis set for all programming languages. Aside from that, any set of features that allows you to create a turing machine is the basis for all languages.

This may seem a bit of a snide comment, but i have a point. The question is not whether you can do it, the question is how easilly you can implement the features of the other languages, which is a hell of a nebulous thing.

It's an interesting question, though, because a corrilary is the question of what languages you can abstract in such a way that they can work together transparently. If you look at what Microsoft has done with .NET (shudder), their VM is geared towards the C++alikes and up, including C++, C#, VB.NET (not the older VB-- there were significant incompatibilities), Perl, and if it weren't for the political issues, Java would be on the list too. People are working on the lower level languages, but it's tough and ugly because the system is geared towards the whole OOP paradigm (from what i am told, the basic VM instructions look quite a bit like C# in design).

I guess i just think the question is a bit nebulous. I mean, he can answer, but it's hard to show that his set of functionality was any better than anyone else's unless you actually implemented it-- well, unless there was a glaring omission or something.

ben.c

Re:Basis set for programming languages?

[Tom7]

x86 machine code?

Which language?!

[jimdesu]

Hi there,

I'm a serious c++ programmer, and I'm interested both in using c++ in a functional manner as well as learning a true functional language. I looked at lisp, and then at scheme, and lately I've been looking at Haskell. Unlike the Java/C/C++/C#/ObjC/Pascal/68K wars I've been seeing, I've never seen any good flamewars between the various camps in the functional community. Everyone's so busy liking everyone else, how does an outside like myself choose which language to learn? Which is "best"?

Re:Which language?!

[alienmole]

My advice, based on my personal experience, is to learn Scheme and ML (try SML/NJ). Haskell is interesting, but in some ways too pure (no side effects, completely lazy). Scheme and ML cover two important parts of the functional language space, i.e. dynamically typed vs. statically typed. Scheme is a fairly easy language to get into, and makes a good bridging language to purer functional programming.

Given familiarity with Scheme and ML, most other functional languages are simply variations on these themes. Depending on what you want to do, for real-world work you might try using something like oCaml (although I find its syntax messy).

I don't think there is necessarily a *best* functional language. They have pros and cons, and I think which features are really important are still being hashed out. The existence of statically typed languages doesn't eliminate the need for languages like Scheme, for example - they excel at different things.

The best features of functional languages ultimately make their way into mainstream languages like Java etc. Automatic garbage collection, for example, has its roots in LISP. In future, you can expect mainstream languages to support things like closures and continuations (Stackless Python already does).

Re:Which language?!

[King Babar]

My advice, based on my personal experience, is to learn Scheme and ML (try SML/NJ). Haskell is interesting, but in some ways too pure (no side effects, completely lazy)

Not to prevent anybody from learning Scheme or ML, but your comments about Haskell are a bit puzzling. One of the greatest advantages of a pure functional language is precisely referential transparency, which does imply no side-effects, at least as we would think of them conventionally. Laziness has some very nice properties too (and fits nicely with transparency); moreover, if you really want more strictness for some reason, that can be gotten, too.

A really great text/introduction to Haskell is Paul Hudak's The Haskell School of Expression: Learning Functional Programming through Multimedia. Yes, that's right; Hudak's book aims to teach functional programming from the surprising angle of animation, music, graphics, and all the cool-looking stuff you'd expect to see in the latest "Java in 15 days" book.

Try it; you may well like it.

Re:Which language?!

[alienmole]

I've written real systems in Haskell, including one which does some fairly sophisticated financial analysis. Haskell is a beautiful, expressive, and concise language. But my experience has been that a completely side-effect free language can be a real PITA and hamper development in various ways. Monads and the like are an interesting theoretical construct, and I'm very interested in the theoretical aspects of mutation in programming languages, particularly the way in which it relates to capturing the concept of time.

However, for real-world development, being able to "cheat" when it's convenient, and mutate a value here and there, can be a real development timesaver. I find languages which don't let you do that to be less practical. Also, for those new to functional programming, starting out with a language that's a little less pure may make things a little easier, and avoid frustration.

The "surprising angle" of the book you referenced is not all that surprising, except possibly to a total newbie. Graphical programs are a perfect application space for pure functional programming. The raytracing competition winning entry written in oCaml a year or so ago is a classic example of this.

Re:Which language?!

[Anonymous Coward]

I take it you've never read comp.lang.functional. That place at least used to be full of "extended debates" about the relative merits of static vs. dynamic typing.

-- Rahul Jain

Re:Which language?!

[King Babar]

However, for real-world development, being able to "cheat" when it's convenient, and mutate a value here and there, can be a real development timesaver. I find languages which don't let you do that to be less practical. Also, for those new to functional programming, starting out with a language that's a little less pure may make things a little easier, and avoid frustration.

So, do you have any thoughts on O'Haskell? When I first saw this, I thought it would take over the world. But, being an academic project, it's development has progressed at a leisurely, academic pace. Which is very unfortunate. oCaml may yet rule the space, as you suggest.

The "surprising angle" of the book you referenced is not all that surprising, except possibly to a total newbie.

Yes, but it was the newbies I was addressing, albeit obliquely. :-)

OK, so the joke wasn't that funny. In any case:

Graphical programs are a perfect application space for pure functional programming.

Absolutely, but the usual imperative style for this is for-loops galore and more assignment statements than you can shake a stick at.

Re:Which language?!

[alienmole]

So, do you have any thoughts on O'Haskell? [chalmers.se]

So many languages, so little time... I haven't used O'Haskell.

My feeling is that the plethora of academic functional (and other) languages will eventually result in the most important and useful features and architectures becoming well-known and migrating to more mainstream languages. My personal and professional use of these languages is pretty much restricted to the ones which I like best, have active communities, and are evolving.

Absolutely, but the usual imperative style for this is for-loops galore and more assignment statements than you can shake a stick at.

I agree. Although one of the things I've learned from functional programming is that it's possible to program in functional style in imperative languages. For loops in themselves aren't necessarily bad; after all, you can prove their equivalence to a recursive function. The real issue is what you do inside those for loops - how you mutate variable values within the loop. Any time you find a variable having its value changed repeatedly within the same function, look at restructuring the function and possibly creating additional functions to eliminate that. Some simple code-refactoring rules along these lines can result in programs that are quite functional in their overall design and feel, even in languages like C, and even if you don't start out trying to design the program in a functional way (although it's obviously better to do that in the first place...)

New ANSI Standard

[Anonymous Coward]

Will we see a new ANSI CL standard with all the pretty things which newly designed languages like JAVA have? I'm thinking of things like Net Libraries, Threads and Foreign Functions.

And what do you think of using a bytecode standard (like .net's CLR) in CL? It would open markets for commercial LISP applications, which is a niche I have worked for four years until I had to change (now doing Java). I know that some people from Franz Inc have ruled it definitively out in comp.lang.lisp some time ago because the type system and garbage collection is not good enough for LISP, but I have a dream...

Re:New ANSI Standard

[jaoswald]

The point about the CL standard, as opposed to most other popular standards, is that it aimed to standardize *existing practice*. The standardization process was meant to ensure that several vendors could develop implementations of Lisp with which Lisp developers could use common code. ("Common," get it?) It was meant to eliminate the basic but gratuitous incompatibilities that made it hard to port code between previous dialects of Lisp. It was based very heavily on the many years of experience with various Lisp dialects (e.g., various ways to implement OOP) to decide what was worth mandating as "minimum acceptable", and what wasn't.

What this means is that most of Common Lisp is useful and WORKS RIGHT. As opposed, for instance, to C++, where much of the standard was based on Stroustrup et al. mucking around with their idea of how things should work, with very little real world experience using the language. Or Fortran 90, which I think was an ultimate "language designed by committee."

Furthermore, the standard isn't the be-all and end-all of Lisp. It's just the basic foundation. Lisp implementations are free to have all the "pretty" libraries they want, presumably determined by what customers ask their vendors to provide. When it all gets shaken out, and the community can determine what should be accepted practice, THEN we can standardize.

Who needs bytecodes when you have robust native-code compilation available at run-time? If you really need to run code on the client, emit Java bytecodes.

Re:just because he has a lisp

[Anonymous Coward]

last time I ever post a joke as me. can't you fuckers tell the difference between a joke and a troll?

Questions I've Come Across Learning Lisp

[Jon Howard]

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

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

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

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

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

Re:Questions I've Come Across Learning Lisp

[Anonymous Coward]

The number one thing the lisps lacked is a means of extending the languages with new standard libraries. As a result they have not really kept up with new emerging technologies well. For instance, everyone seems to have their own GUI interface, there is not a standard one. No standard SSL/network libaries, no standard OpenGL equivalent, no standard audio, etc.

Re:Questions I've Come Across Learning Lisp

[Xenophon Fenderson,]

I think the Common Lisp community could learn a lot by examining the Scheme Request for Implementation and the IETF RFC processes. Both groups seem to be able to set standards on a semi-ad-hoc basis. With the current hibernation of the ANSI standardization committee, there should be some kind of semi-formal forum to discuss extensions to the language and the standard libraries (e.g. the MOP, Gray streams, SERIES).

Lisp projects and success stories?

[DeathBunny]

Lisp doesn't seem to get the "mind share" and media attention that some programming languages (C, Java, Perl) do. You don't see a lot of books and articles about Lisp and, with the obvious exceptions of Emacs and Sawfish, most people would have trouble naming major applications written in Lisp.

Why do you think Lisp doesn't get mentioned more in the computer press?

Similarly, can you tell us about any major applications written in Lisp, or any great Lisp success stories?

Re:Lisp projects and success stories?

[Jon Howard]

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

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

Re:Lisp projects and success stories?

[Jon Howard]

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

Re:Lisp projects and success stories?

[Cassandra]

... with the obvious exceptions of Emacs and Sawfish, most people would have trouble naming major applications written in Lisp.

They still have, because both Emacs and Sawfish are written in C. On the other hand they do use LISP as a scripting language, as does GIMP btw.

Re:Lisp projects and success stories?

[PixelJuice]

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

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

Re:Lisp projects and success stories?

[Anonymous Coward]

Why do you think Lisp doesn't get mentioned more in the computer press?

No kickbacks from Billysoft?

Re:Lisp projects and success stories?

[DeathBunny]

Most cool! Thanks for the links.

Re:Lisp projects and success stories?

[Peaker]

Emacs is written in C??
As far as I know, emacs has a small C core, basically just running an elisp interpreter, on top of which everything is written in ELISP..

Re:Lisp projects and success stories?

[Anonymous Coward]

Most of the non-trivial editor objects are also written in C.

my question

[Anonymous Coward]

(what 'part (about (the lisp) syntax) (do you) like (the most) (?))

What will it take to make Lisp fashionable again?

[kfogel]

For myself and a number of friends, Lisp/Scheme programming has for too long been a kind of mystical Eden, fading in our memories, from which we have been mostly banished in our professional lives. But we can still recall how it felt to work in a language able to shape itself to any pattern our minds might ask: coding was more interesting and more expressive, and the rate of increasing returns over time was tremendous, because fine-grained -- almost continuous -- abstraction was in the nature of the language. Life was just more fun, frankly.

Alas! In our jobs and even in our personal projects, we are often forced to use C, C++, Java, Perl, or Python -- not because we prefer to write in those languages, but for two much less satisfying reasons: first, everyone else knows those languages, so we'll get more developers with them. And second, you can't count on users and testers having the right environment to run programs written in Lisp/Scheme, so right away you take a portability hit if you choose to develop in them.

Do you think there is a chance of Lisp/Scheme becoming "mainstream" again? That is, when someone contemplates starting a project, it would be as realistic for them to consider Lisp or Scheme as, say, Perl, without worrying about losing developers or initial testers? What will it take?

LISP was commercial twice in 1980s

[peter303]

(1) The first scientific workstations were LISP-based. Symbolics and Texas Instruments sold graphics workstations in the early to mid 1980s. My recollection is that in the late 1970s Mead & Conway developed elegant software for circuit design that made it easier for programmer types to design their own computer chips. Prof. Sussman of the MIT A.I. Lab and others used this to develop a LISP-accelerating CPU (mainly typed memory and instructions). T.I. got some commercial rights and Symbolics spun off of M.I.T.

A few years later commodity chip UNIX workstations from Sun and DEC took over the workstation market. Custom LISP processors could not evolve new generations as fast as commodity chips. Furthermore, clever LISP interpreters learned to emulate LISP hardware in coventional machine languages almost as fast as the custom hardware.

(I have worked on some oil-industry software with LISP at its core because it was first developed in the 1980s when LISP machines were the only viable workstations.)

(2) The second pulse was the "Expert System" frenzy of late 1980s. Applied A.I. was going to take over the world. Japan was going leap-frog the USA in doing this first. The expert system stock bubble and bust resembled the internet stock bubble on a smaller scale. There are a couple of survivors doing interesting things such as the CYC (enCYClopedia) project in Austin TX.

The first language of the expert system frenzy was LISP. Then a language specifically designed for logic inference called Prolog was used. And finally very fast implemntations in conventional languages such as C.

Re:LISP was commercial twice in 1980s

[puz]

(1) And there was the Xerox 1108 workstation.

(2) If the FGCS had embraced LISP instead of Prolog, it probably would not have been such a colossal failure, IMO.

What would you do differently?

[scruffy]

For a variety of reasons, Lisp and Scheme remain, in my opinion, marginal languages for computer programming. If you had the chance to redesign Lisp and/or Scheme, what would you change so that they would have become as popular as say C/C++/Java?

GIMP uses Scheme

[kgrgreer]

GIMP uses Scheme, which is of course a kind of Lisp

Re:GIMP uses Scheme

[Anonymous Coward]

The subset of Scheme GIMP supports is hella weak.

Language feature trickle-down

[WillWare]

I was a big Scheme/Lisp fan five or six years ago, but now I see most of my favorite Lisp-like language features available in Python, which is getting a huge amount of high-quality development mindshare these days. Some of the Lisp-ish features in Python that spring right to mind are functions as objects, closures, garbage collection, and dynamic-yet-strong typing, and convenient rapid-app development.

One needn't look far to find arguments that there is still something unique to Lisp that differentiates it even from very recent languages which have had ample opportunity to borrow from Lisp. But one rarely finds a really clear articulation of that uniqueness. Do you think concur with the view that Lisp is still unique, and if so, do you think that Lisp's putative advantage really is ineffable?

If there is an advantage but it's ineffable and therefore opaque to managers with purchasing power, that would explain why Franz, Harlequin, et al have had such a rocky road. Does the Lisp/Scheme community regard this as a worrisome issue? (Some folks on c.l.lisp clearly don't think so, but I don't know if they are just a noisy minority.)

Re:Language feature trickle-down

[metalogic]

If you don't know, and love, the macro system (and sexps), meta object protocol, multi-inheritance/dispatch, readtable, the much more mature condition systems, optimizing native compiler, compiler macro, etc, etc, then you're not qualified to claim yourself as a "big Lisp fan".

I beg to differ

[Jon Howard]

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

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

Available Jobs

[Jon Howard]

Check out this list for some lisp job listings.

Re:Simple Question

[Anonymous Coward]

(its (parenthesis (you idiot)))

lazy (or normal?) order evaluation.

[Anonymous Coward]

As a mathematician, the most appealing thing about Lisp is it's closeness to the lambda-calculus. When I actually program, however, I often find a more procedural language (eg Python) a great deal easier.

One of the things that mars the "niceness" of Lisp (and Scheme) is the fact that evaluation is strict --- this moves the language further from the theory of lambda-calculus as it means that some programs with normal forms (at least would have normal forms if written in the lambda-calculus) don't actually terminate.

Two questions:

1) How practical is it to implement an evaluation scheme in a Lisp-like language that is both efficient and has the property that every program with a normal form terminates?

2) Are there practical benefts to programming of doing so. Just the fact that a language is mathematically elegant doesn't necessarily imply that real benefits will acrue from using it.

Thanks.

Functional languages on Linux

[gemi]

For the many Lisp and Scheme implementations that exist for Linux, look at http://www.hotfeet.ch/~gemi/LDT. There are also many implementations for Haskell and ML.

VLIW-optimized LISP

[puz]

Several years ago I wrote a term paper on my idea of a LISP machine in which CONS cells were verctorized in the CDR direction. For example, 8 cells will be stored in consecutive memory locations and the chunk will be handled by the processor as a single data unit. The hardware would be a VLIW architecture where operations will be performed simultaneously on all 8 cells. The simulation of such hypothetical machine exhibited an 8-fold speedup for list operations such as REVERSE and APPEND which encoded data in the CDR direction. There was no functional difference with conventional LISP at the user level except that REPLCD was disallowed. Also memory efficiency was somewhat sacrificed. Another conclusion from my study was that the width of the VLIW did not have to exactly match the width of the chunk in order to reap the benefit of this architecture. For example, a 4-wide VLIW could be used to process chunks consisting of 16 CONS cells with a performance comparable to this implemented with a 16-wide VLIW.

What do you think of my idea?

Re:VLIW-optimized LISP

[jaoswald]

I assume you looked up previous research in "CDR coding," a well-known technique storing lists in consecutive memory locations by default.

This was widely used by machines that understood Lisp at the hardware level.

Re:VLIW-optimized LISP

[puz]

Thank you for your reply. My scheme is different from the conventional CDR coding such as the one used in the Symbolics 3600 machine where the emphasis is on _reducing_ memory space. Rather, my scheme _wastes_ memory space in order to attain higher execution speed.

Re:VLIW-optimized LISP

[Anonymous Coward]

This sounds like an interesting idea, but perhaps a better forum would be c.l.l, where Kent maybe could give you a better (longer) answer, and spawn discussion with other folks as well.

Someone has to ask it

[sjc12xu]

emacs or vi ?

pass it as a string

[Tablizer]

>> pass an expression like
(+ 2 (* x (/ x 3))) into a "derivative" method, which would examine that expression, MODIFY it, and return a completely valid new scheme method that was the actual mathematical derivative. <<

Why not pass it as a string? It would most likely come in as user-entered data anyhow. The people that create the data are not usually the ones who create the software. Smalltalk fans keep forgetting this also.

BTW, I don't think it is good practice to modify the original in most cases.

BTW2, why did I get tagged as "redundant"? Where is the alleged orgininal? It is like sending an application to the government, only to get rejected because you "are missing one of the 500 listed requirements", but it does not say which one is missing or wrong. Hit and run rankoid jerks!

Re:pass it as a string

[Cassandra]

Why not pass it as a string? It would most likely come in as user-entered data anyhow.

Because you will want to convert that string into a tree representation internally. There are huge advantages with a tree representation when computing a derivative. For one thing you will be able to use the chain rule: d[f(g(x))]/dx=f'(g(x))*g'(x).

Re:pass it as a string

[puz]

Part of the strength of LISP lies in the ability to execute data using the EVAL function. There are many cases where you want to do so. For example, you can easily write a theorem prover by calling EVAL on a prefix Boolean expression with exhaustive combination of the input variables.

Re:pass it as a string

[Tablizer]

Part of the strength of LISP lies in the ability to execute data using the EVAL function.

That does not contradict left-side commands and using strings as the input.

I don't do mathematical processing of code, so can somebody show a non-math advantage of not having the command the left side that overpowers the readability drawbacks? (refering to nearby derivative example.)

:TEACH;LISP

[SimHacker]

KMP wrote a great program on ITS called "Teach-Lisp", that helped me and other people to learn Lisp. And he wrote a wonderful hack called "EVAL-IN-OTHER-LISP" that used an interprocess communication mechanism in ITS called "Core Link Interrupts," which enabled one Lisp to send Lisp expressions to another Lisp interpreter to evaluate. He used it to mischeviously change the output base of my Lisp process to Roman numerals, among other things. I suppose that qualifies KMP as a pioneer of "distance learning".

KMP also wrote an animal guessing game that would get upset and warn you not to use naughty words. If you didn't relent and kept on cussing, it would get angry at you, and send some email to you and KMP, telling on you and demanding an apology. So you couldn't play the game again until you emailed an apology to his program.

It's great to know KMP is still teaching lisp.

But I've always wondered: who was the bright-12-old (who's now about 28) who benefited from recycling Jerry Pournelle's account?

====

From http://catalog.com/hopkins/text/pourne-smut.html:

Date: Fri, 31 May 85 09:39 EDT
From: Kent M Pitman <KMP at SCRC-STONY-BROOK.ARPA>
To: CStacy at MIT-MC.ARPA
cc: Klotz at MIT-MC.ARPA, KMP at SCRC-STONY-BROOK.ARPA, Gumby at MIT-MC.ARPA
Subject: Pourne

Date: Fri, 31 May 85 01:11:16 EST
From: Jerry E. Pournelle <POURNE@MIT-MC.ARPA>
To: KLOTZ@MIT-MC.ARPA

I find this thoroughly distasteful. If you have some authority to order me off the net, do so. If not, leave me alone.

Personally, I'd just turn off his account. It's not like it's the first time, and he not only flaunts his use of our machines but stabs us in the back with grumblings about why he doesn't like this or that program of ours when he gets a chance. (Am thinking particularly of an article he wrote which condemned Lisp for reasons amounting to little more than his ignorance, but which cited Teach-Lisp in a not-friendly light... The man has learned nothing from his presence on MC and sets a bad example of what people might potentially accomplish there. I'd rather recycle his account for some bright 12-yr-old...)

====

-Don

Re:What will it take to make Lisp fashionable agai

[Tablizer]

Realistic evidence!

If you want to "sell" a language, then show side by side code examples of it kicking say Python's or Smalltalk's butt.

It is easy to brag at the starting line that you have a better race car engine using intellectual cliches, etc., but nobody wants to "race their car" and show it actually beating the competition with realistic examples. (No more foobar examples under rigged conditions.)

OO fans refuse to race also, using mounds of cliches instead.

(Note that I am talking about things like code size and change-scenarios, not necessarily execution speed.)

A Serious Question

[jason_z28]

Why would anyone want a lisp? I mean, it only provides others the opportunity to make fun of you for your defect. Why would anyone want that?

Lisp OS questions.

[Berkana]

I have been planning on writting a Lisp based OS, but I like Scheme's conventions, and some of it's design features. Unfortunately, there's no complier for Scheme that's fit for the task out there. Do you have any recommendations? is CL fit for the task?

What do you have to say about Lisp OSes? What do you think of the past efforts? I hear that the old Lisp machines (genera, etc.) can do cool things that even modern machines can't do, but I've never heard anything specific. Do you know what these are?

(My OS, HomunculOS (tm), will hopefully have it's own dialect of Lisp (If I can get around to doing this) that is hybridized with the best of Scheme. Modular, capability based, orthogonally persistent, only as much low level coding as necessary, for portability. Scheme shell text interface. )

Re:Lisp OS questions.

[dbremner]

You might consider reading the archives of the LispOS mailing list - it's always easier to learn from the mistakes of others.

From what I've heard, the Lisp machines were awesome for Lisp hackers because the entire OS was written in Lisp. Easy to modify, and possible to understand.

Re:Lisp OS questions.

[NonSequor]

I wish you luck. An OS written entirely in Lisp is exactly what I want.

Re:Lisp OS questions.

[Peaker]

capability based, orthogonally persistent,
Ooh, an orthogonally persistent pure capability operating system, written in a safe language, is my long-term OS dream.. :)
I also plan on writing an OS like that sometime.
However, I don't believe this OS should be more than a basis for more work. For example, it shouldn't define that the text interface should be Scheme, or whatever, and it shouldn't enforce a specific language (LISP), but rather just allow any language that supports capabilities (unforgable object references), and is safe (no unsafe manual memory management).

It's not just me is it?

[demo9orgon]

After trying to "self-learn" lisp in the 80's I get this physical reaction to the word "lambda"...a cold sweat combined with the involuntary retraction of my testicles to a protected location in my abdomen (damn unpleasant shit)...I usually avoid that second one by mentally going through the mechanincs of "hello world" in C, or any half-a-dozen other programming languages.

Lisp is one of those meta-languages you either learn or avoid. I write practical stuff all the time, daily in fact, and I've never had something that required the arcane stuff in LISP.

Re:It's not just me is it?

[Anonymous Coward]

Nope, it's not just you.

I have a similar issue whenever I see any book (particularly CS books) use an omega, theta, or any other Greek character when a simple x or y would suffice. I'm always concerned that they are saying something more by using that character that is obvious to everyone who's deep in the field, but not me. It's almost to the point that when my brain goes immediatly into abort mode at the first sign of Greek.

Of course, seeing a laguage element named 'lambda' continually blocked me whenever I looked at Lisp.

However, I then stumbled upon a book named "Simply Scheme" which is a very entry level book on the Scheme language. The book was my Rosetta Stone that helped me wrap my head around the structures and concepts of Scheme and Lisp like lanaguages.

It's worth the trip to delve into the "arcane" world of Lisp and Scheme. Very enlightening whether you ever use it again or not.

Re:It's not just me is it?

[Anonymous Coward]

You're afraid of lambda; I guess you never write functions then... or read documentation. Sad that your mind couldn't reach past named-functions. lambda is very practical, but you would never understand, would you? Never got past Hello World even.

Scheme and JIT compiling

[relinquish]

I've written a few rudimentary scheme interpreters and have ideas for a new one.

I'm suprised I've never seen scheme and JIT compiling mentionned together.

First, it seems JIT compiling would elegantly solve the problems linked to eval and macros (and their specific environments). When you program a simple scheme interpreter, eval and macros actually are no problem as long as you're not aiming for speed. But they do become a problem once you start compiling code. Thus the ability of compiling a macro or an eval at execution time seems to me like an elegant solution.

Secondly, scheme's structure allows for easy code analysis that could render a JIT compiler extremely efficient.

In my opinion this could be a killer combination in provoking LISP's regained acceptance.

So what do you think - are scheme and JIT compiling a perfect match?

Re:Scheme and JIT compiling

[Anonymous Coward]

Most commercial LISP systems already dynamically compile their macros.

Re:Scheme and JIT compiling

[Anonymous Coward]

Actually, if you look at many Lisp environments, they either byte-compile code that is EVAL'd (e.g. cmucl) or they fully compile it (e.g. MCL, by default), so it's probably useful because it is done :)

-- Rahul Jain

Lisp in a hardcore science/engineering environment

[sean-mccorkle]

I had an all-too-brief love affair with Lisp back in college in the 70s, but I never used it in my subsequent career in various scientific environments, thinking of it as an interpreter (somewhat slow) for doing symbolic processing rather than number crunching. However, a report from JPL recently came to my attention, which suggests that Lisp (using new compilers/interpreters) is competitive with Java or C++ in terms of programming time and execution speed & memory. While the authors themselves admit the study is not very conclusive or scientific, it did re-kindle my old love with the language.

Do you think its worthwhile pursuing Lisp solutions to everyday-type problems in scientific/engineering enviroment, which are numerically intensive or data-intensive? (for example, a particle physics monte-carlo simulation, or searching gigabytes of DNA sequence for patterns)

Sean McCorkle
Genome Group, Brookhaven National Laboratory

A question for Kent

[MarkusQ]

Do you have a maclisp manual I could borrow?

-- MarkusQ

Advice to Aspirants

[Anonymous Coward]

Kent,

I am one of the lucky ones who programs professionaly in Common Lisp. I certainly appreciate your hard work and the hard work of everyone else who helped to bring us the ANSI standard - which serves to reify much of the esoteric knowledge the Lisp community has developed in the many years since the language was born.

While I do not need to be sold on Lisp, I know many people who do not fully appreciate the power of the language. To a large degree, this is due to misconceptions about the language. Specifically, there seem to be a number of what I would call 'cultural misconceptions'. Because many people have never worked in a tightly interactive development environment with incremental compilation, language-level introspection, and real code/data equivalence (not to mention the differences between CLOS and what the rest of the world seems to have come to believe is the God-given definition of 'object-oriented' programming) - they don't really 'get' what makes Lisp so special and so powerful. More to the point, because the logistics of developing and deploying applications in Lisp is different than what the typical c/c++/perl/java developer knows, the hurdle to even investigating or considering Lisp as a real possibility seems unnecessarily high.

Could you talk a bit about how those who have a feeling that Lisp might help them with their hard problems could go about bootstrapping their way into finding out? How would you suggest getting started? What is a reasonable set of tools for experimentation, and where should a beginner start with the language? (The standard is a big document!) Also, could you give an example of the type of problem space and style of application delivery that demonstrates that Lisp is more practical than many seem to believe?

LISP and A.I.

[Anonymous Coward]

What is the state of LISP usage in the Artificial Intelligence Community? How has it fared in that field vs mainstream languages?

Maxima

[Anonymous Coward]

For a good example of Lisp in mathematics, check out Maxima. It is written almost entirely in Lisp, and has a crapload of features.

Re:Maxima

[Compinche]

I think the project AC is referring is nicely summarized in he re</A>. It also has links to the main project page.

Re:What will it take to make Lisp fashionable agai

[Anonymous Coward]

Even i know the answer to this one.

There are 3 steps to make lisp a language of fashion:
1) Obfuscate lisp to death. Make it completely unreadable.
2) Write a popular news + comment site with it. Use this bully pulpit to bash all languages except your obfuscated language. Only give moderation rights to your language's supporters, and label all critics 'trolls'.
3) buy out, or otherwise eliminate slashdot. Since they have already implemented this plan with perl, you must eliminate the competition.

The standard process

[VP]

As participant in the standardization process for Lisp, what are your thoughts on standards for programming languages? What would you like to see different in this process? And speaking of standards, what do you think about the RAND licensing issue and the W3C?

Re:Too damn dumb

[SimHacker]

Most people are just too damn dumb to recognise how great Lisp is.

The bias against Lisp is based on the simple fact that the first word that springs into most peoples pointy little heads when they hear the word "Lisp" is: "Gay". And that scares off all the homophobic repressed closet queens, which includes a large percentage of the computer industry. Especially Perl programmers, who use Perl as a means of expressing their manhood and covering up their repressed homosexual tendencies.

-Don

Writing Another Way Out

[jamesmartinluther]

So let us in on the secret - is this enormous project actually the raw output from some radically complex Lisp application?

Re:Writing Another Way Out

[NetSettler]

I doubt this query will bubble up to be among the questions I'm supposed to answer for the interview, so I'll answer it ahead of time here.

I wish I had the time to experiment with automatic episode-writing for Another Way Out (AWO) using Lisp. I think it would be both well within the limits of technology and a lot of fun. Right now the only Lisp involved happens when I edit the stories in emacs (which is implemented in a lisp dialect). The stories are written the hard way, but at least they keep my writing skills honed, which sometimes helps out in work on the sci-fi novel I'm writing in background. (Drop me a line if you want notification if/when that comes available. But don't hold your breath--it won't be in time for Christmas.)

Regarding technology and writing, though, it continues to amaze me how sophisticated the editing tools are for programming and how weak they are for fiction writing. I consider the two to be virtually the same kind of activity, and it's been on my list sometime to write some better tools for supporting my writing. But there are always so many things to be doing...

Back on AWO for a moment, though, I use all kinds of mechanisms for coming up with plots and there's one that went over the heads of most of my readers but the nerds of this forum might get a kick out of. Each of my parodies comes with a "moral of the story" page (i.e., "editor's notes"), and you might find the moral for Episode 47 to be of special interest if you're the sort to care about mechanical story understanding/generation issues. I borrowed some tricks I'd learned from Pat Winston at the MIT AI Lab years before. The technique was almost like programming. The story came out more fun to read about than to read, frankly, but was a lot of fun to make.

And, for extra credit, those of you who are soap fans (no, you don't have to embarrass yourself by self-identifying) might also enjoy my Theory of RelativeTV, which explains some otherwise perplexing effects of time/space that occur in soaps.

Re:What will it take to make Lisp fashionable agai

[Anonymous Coward]

How about good graphical bindings? Not many programs are strictly command line these days, certainly not for end user consumption.

Recursion

[Anonymous Coward]

Please give me ONE reason to use recursion.

Just one. Is all I'm asking for.

Re:Recursion

[Kupek]

Because sometimes, recursion is more natural and easier than an iterative solution. For a very good example of this, write an implementation of a binary tree that uses no iteration.

Re:Recursion

[Anonymous Coward]

Wazza matter, yer Basic interpreter doesn't support it?

Commercial Lisp deployment

[Anonymous Coward]

At least two companies built $250M worth of value from Lisp (Cadabra,Inc and Mergent Inc). I believe Paul Graham also sold a Shopping system built from Lisp.

I was employed as a Lisp engineer for Cadabra (which was acquired by GOTO/Overture). However, our comparison shopping product is now in mothballs, and I'm coding Java for my bread.

Thoughts on LISPs problems:

(1)Very low volume, tight supply and demand of Lisp programmers of any degree of competency.

(2) Package and Build technology horribly non-standard. 1 and 2 Leading to:

(3) GUI, OS and Network support declining with respect to languages like Java and Perl (see 2).

Vicious cycle ? Do you agree ?

Secondly, there is virtually a commercial monopoly on Lisp, through Franz Inc (However we had a lot of success moving to CMUCL). What do you think Franz should try and do to ensure that Lisp or its successors enjoys the widespread deployment and usage it deserves ? Java has Sun as it's advocate.

Should we be looking for either LISP to change its syntax or for Java to absorb more and more of LISP's capabilities.

Winton

Lisp and Java, Packages and Syntax

[wdavies]

Hi,

Some comments and background first:

At least two companies built $250M worth of value from Lisp (Cadabra,Inc and Mergent Inc). I believe Paul Graham also sold a Shopping system built from Lisp.

I was employed as a Lisp engineer for Cadabra (which was acquired by GOTO/Overture). However, our comparison shopping product is now in mothballs, and I'm coding Java for my bread.

Thoughts on LISPs problems:

(1)Very low volume, tight supply and demand of Lisp programmers of any degree of competency.

(2) Package and Build technology horribly non-standard. 1 and 2 Leading to:

(3) GUI, OS and Network support declining with respect to languages like Java and Perl (see 2).

Vicious cycle ? Do you agree ?

Secondly, there is virtually a commercial monopoly on Lisp, through Franz Inc (However we had a lot of success moving to CMUCL). What do you think Franz should try and do to ensure that Lisp or its successors enjoys the widespread deployment and usage it deserves ? Java has Sun as it's advocate.

Should we be looking for either LISP to change its syntax or for Java to absorb more and more of LISP's capabilities. McCarthy said that he always planned to move to M-expressions, but never got round to it :-) see this article

Winton

Re:Lisp and Java, Packages and Syntax

[Anonymous Coward]

At least two companies built $250M worth of value from Lisp (Cadabra,Inc and Mergent Inc). I believe Paul Graham also sold a Shopping system built from Lisp.

And at least two companies have burned through far more than $250M worth of value by betting on Lisp (Symbolics and Texas Instruments). During the late 1980's, especially, I can attest to Texas Instruments devoting millions of dollars to Lisp platform development (the Explorer), in-house Lisp software development (CAD applications and many others), and all sorts of over-hyped AI initiatives. It was, by most accounts, a colossal failure.

You also contend that Lisp suffers from a tight supply of qualified Lisp programmers... and, yet, one has to wonder... If all of these elite computer science departments at some of the most renowned universities have been teaching nearly all of their students Lisp or Scheme at some point in their educational studies for the past 15 years or so, then just exactly why is the supply of such programmers so tight in the marketplace? Personally, I think the tight supply of qualified personnel argument does not hold up to close scrutiny; not only for the reason given above, but also because if Lisp truly was a skillset in high demand in the marketplace, then people would come out of the woodwork to learn it.

No, Lisp and Scheme have failed to develop commercial mindshare because like many of the other more algorithmically "pure" or functionally "clean" languages and computer science concepts... they are so often ill-equiped to handle the demands of implementation efficiency in a world and among a user base that does not always live up to the pristine algorithmic ideals such mathematically and theoretically minded computer scientists espouse. As the common wisdom goes, one should not let the perfect be the enemy of the good. And it seems many computer scientists apparently overlook the sacrificies that are made to force "clean" algorithmic abstractions on top of electronic devices and platforms that are so often ill-suited to such mathematical niceties and daintiness.

Re:Lisp and Java, Packages and Syntax

[Anonymous Coward]

As I see it, the Common Lisp community has developed very nice solutions, of varying levels of elegance, to most practical problems, so that "demands of implementation efficiency" per se is not the real problem. The problem is that the solutions they developed are not the same solutions that everyone else standardized their software development practices on. Interoperability with mainstream systems and libraries is often more complicated than it should be.

This also ties in to the problem of qualified Lisp programmers. In an academic setting, people are not taught how to solve practical problems in Common Lisp. They are taught abstract mental masturbation in Scheme, leaving them with the idea that lisp in general is an abstract tool that is of no use in practice. The end result is that they are neither qualified to solve practical problems in Common Lisp, nor are they willing to even try.

Another issue you seem to overlook in your argument is that after the crash of the 80's AI hype, Lisp has never been a high demand skill. The few companies that venture to work in Common Lisp do require Lisp programmers, but their demand is a drop in the ocean of Java and C++ job openings.

Re:What will it take to make Lisp fashionable agai

[Anonymous Coward]

The thing to make anything fashionable is constant loud-mouthed hype, just look at Java and Linux.

What's in a name?

[xFoz]

I'm wondering if LISP might have been more popular if it had a name that didn't invoke a joke coming to mind every time the name comes up:

Interviewer: Do you program in LISP.
Candidate: Yeth.

Has this been a problem over the years or is it largely overlooked? Maybe there's an old story or two you could tell in this vain.

Re:What's in a name?

[Anonymous Coward]

vein

Practical Lisp

[jstoner]

I've been hearing lots lately about Lisp being used in mainstream software shops, and how it provides a powerful competitive advantage to good developers. Where would you recommend a curious, serious software engineer with real-world problems to solve start to study Lisp? Are there any good practical references (not necesarily for the Lisp novice, I can get that elsewhere) that focus on high-leverage software engineering techniques possible in Lisp? Things you just can't do in other kinds of languages?

Re:Simple Question

[Anonymous Coward]

Braces?! You're thinking C, Perl or Java, foo! Lots of semicolons there too!

my question is

[jchristopher]

How doth ith feel to be one oth the moth important programmers worthing tothay?

Re:Linux -- Not an executable?

[Anonymous Coward]

"What I'm trying to get across here is that I'm no novice when it comes to computer trickery."

Hahahahahaha! This is great, almost Onion-like. Nice!

Interactively programmable applications

[divbyzero]

One of the primary reasons why Scheme and Lisp interest me is that they are well suited for making applications interactively programmable at runtime (Scheme especially, due to its small size). This is far more flexible and useful than applications which are only extensible through heavyweight, precompiled plugins. Since the Slashdot readership tends to be made up of people who are comfortable with programatic interfaces (unlike the general computer-using public), why do we not see more such applications?

Re:What will it take to make Lisp fashionable agai

[Anonymous Coward]

1) Obfuscate lisp to death. Make it completely unreadable.

Uh, they already did that when it was designed.

SRFIs and FFIs

[divbyzero]

Are you in touch with the current participants in the SRFI process? Do you know if any work is being done towards standardizing bidirectional FFIs between Scheme and other languages/runtimes (especially C and Java, but also CORBA, SOAP, and COM)?

FFIs are, of course, crucial for being able to use new libraries which are not designed specifically for your language. I'm convinced that the primary reason why C is so popular to this day is because it standardized its FFI very early on. I'm also of the opinion that this is why adoption of Scheme and Lisp lags so far behind single-implementation languages like Tcl, Perl, and Python, which have a "standardized" FFI by default.

(For the newcomers: SRFI = Scheme Request For Implementations, the current, informal "standards" process for adding features to Scheme; FFI = Foreign Function Interface.)

Fully R5RS Scheme for Java

[divbyzero]

Why are so many so-called implementations of Scheme incomplete when compared to the current spec? The only R5RS compliant implementation of Scheme for Java which I've found is SISC, yet the project seems to be largely unknown, even within the Scheme community. Have you had any experience with it?

Serious reply: What will it take to make Lisp fa..

[puz]

(1) Better IDE

I suspect that when people say they like or dislike a particular language, they often mean they like or dislike the entire development environment associated with that language. LISP needs a powerful IDE like MSCV++ with syntax-sensitive indenting, keyword auto-completion, and chroma-coding (perhaps they already do?)

(2) Non-intrusive garbage collection.

One thing that makes me shy away from using LISP for commercial product is the long pauses of the garbage collector that kicks in at unpredictable times. I would like to have a guaranteed maximum pause time.

(3) Efficient recursion

I would like to have an implementation that does not use up too much stack space with non-tail recursion. For example, the return path for a case like A calls B calls A.... probably can be compressed to 1 or 2 bits per call.

(4) Better handling of large projects

I don't have a specific suggestion on this but just a vague notion that large projects in LISP are hard to manage. Granted, part of the charm of LISP is that you can quickly write and run code without much planning, i.e., without declaring variables, and the binding is non-lexical i.e., last-visible. So my question is, is manageability and writability mutually exclusive?

dogmatism

[dimitri_k]

From hypermeta.com:

Kent does not like software patents, but he does like copyrights and is a strong advocate of free market capitalism. Unlike a many people, Kent is quite ambivalent about the idea of both the "free software movement" and the "open source movement". ... It dismays him that there's such a bandwagon of people who think thse are the automatically right answers in all contexts. It's a kind of religious dogmatism he finds very distasteful. ...

Where does Kent think that this "dogmatism" comes from? If he thinks the current open source zeitgeist is an oversimplification of a complex issue, what is his more nuanced view? How does he square the simultaneous holding of libertarian social values with communistic licensing ideologies by many in the open source and free software "bandwagon", in light of his characterization of the movements as simple minded.

Although I personally agree with Kent's observation that these movements have taken on a import in discussion that is more perceived than real, I do think the tone of his page is more than a little condescending and would like to hear why it is a more "complicated opinion" to think that open source isn't automatically the "right answer", than to think, for example, that it is?

Re:dogmatism

[Anonymous Coward]

why it is a more "complicated opinion" to think that open source isn't automatically the "right answer", than to think, for example, that it is?

Because "X is the right answer" is a set with one element and "X is possibly the right answer" is a set with many elements.

Re:Serious reply: What will it take to make Lisp f

[SuperKendall]

The things of it is, if (1) through (3) were really factors then I don't think Java would have taken off the way it has - Java has had those problems, though is getting over them.

I think (4) is a factor for Enterprise adoption - though I loved using Scheme in school but I'm not sure how well it would work for large projects with a lot of people.

In general though, Lisp has seemed to lack a big champion to promote Scheme and help move it into new spaces. I grew interested in Java initially because I really liked Sun, the company, and thought they might have some good ideas - in the following years Sun has done a tremendous promotoing job, but in helping make it easy for developers to choose Java and to push Java into every space, like small devices or distributed systems.

I think what also helped Java is that there is Java, the platform AND language vs. Lisp, the language. With Java you gain quite a bit more than just another nice programming language, you also get the features of the platform (like security and a wide set of standard API's) to build on.

Who needs a text?

[fm6]

I'm not Scheme expert. But I really wonder if you need any text at all to learn it. What little work I've done with Scheme has been in my occasional attempts to work through S&I. That book is interesting because it (a) assumes no prior knowledge of Scheme (b) spends very little time explaining the language as such. And yet the whole book is about Scheme programming! It would seem that Scheme programmers spend less of their time thinking about language issues than other programmers.

Re:Who needs a text?

[juha0]

And yet the whole book is about Scheme programming!

Actually, the book (which is great) is about programming - Scheme just is the used language, and a good choice for this purpose.

Re:Scheme for OOD

[rpg25]

Actually, C++ is kinda bad for learning about Object-oriented programming, etc. Here are a couple of reasons:

• C++ isn't a fully object-oriented language. It's a set of object-oriented extensions grafted onto a non-OO substructure. One particular place where you can see this is the way the object-oriented extensions combine with operator overloading and type coercion to create something that's deeply confusing. Also, since C++ is aimed at building very efficient systems programs, it skirts things that seem difficult, like multiple inheritance.
• C++ has no garbage-collection. This means that lots of things that should be natural (like having methods that CONS together new objects and return them) become difficult and fraught with error.

Scheme, on the other hand, provides a good framework for teaching not just object-oriented design, but functional programming, as well.

Note that I'm not trying to get into a war about the best programming language for building things, nor am I trying to diss C++. But I think it's a pretty crummy language from a teaching perspective.

Fundamentally, I don't think that CS education should be vocational education. If you learn the concepts and theory, learning a new language is a breeze. If you don't, then you don't walk away from the education with much; everything you learn is in imminent danger of evaporating in your hands.

Re:Scheme in CS [recursion]

[rpg25]

This isn't a way to convince people to learn Scheme, but one of the reasons I think it's critical to use a language like Scheme in CS education is that it helps learn the critical concept of recursion. While you may never use recursive programming again (or you might use it all the time, like me), it is an absolutely critical concept for computer science and for other fields like mathematics, linguistics, etc.

Recursion is a critical concept and is much harder to master than iteration.

I once taught Computer Science in a University where the introductory courses were all taught in procedural programming languages. I had to teach theory and some other advanced topics to people who'd never mastered recursion and it was unspeakably painful. Like teaching physics to students who hadn't mastered algebra.

defmacro and defadvice

[SilentTristero]

One (ok two) of the nicest features of lisp, IMHO, are defmacro and defadvice, which allow you to use the full power of lisp to rewrite an arbitrary expression or function and thus extend the syntax and semantics of the language. This is so far beyond the C macro preprocessor it's not funny (and of course Java has no preprocessor at all, whine). I miss this more perhaps than any other Lisp feature. Various people have worked on getting something like this into C/C++/Java: ePerl lets you use perl as a macro language, and some of the AOP (Aspect-Oriented Programming) folks are old lisp hackers (I think Alan Bawden is in that group, for instance) and these people would like to see some kind of defmacro/defadvice functionality in C.

So here's my question: do you think that's possible, given C's irregular syntax and poor token/string handling, and would it be a good idea? Any thoughts on how it could work?

Flaw in JPL Paper?

[Anonymous Coward]

The criticism of the Lisp vs XXXX performance paper is that the problem is one that is solved most efficiently with hash tables. Many of the student subjects didn't know about the hash tables that are part of the standard library in C++. The ones that missed this and whacked together their own data management code didn't do very well, pulling down the average C++ performance very far.

If I was spending my own money to do lots of software development, I would almost certainly rather spend it on Lisp instead of C++ when either language is reasonably suited to the task at hand. But this has much more to do with programmer productivity than with run-time performance. Don't pay too much attention to a single experiment. Every language studied with this same problem that has builtin hash tables has looked OK vs C++, including Python and Tcl, which are no way performance champions. If they were, we wouldn't need NumPy and SWIG.

Re:Flaw in JPL Paper?

[J. Random Software]

std::map and std::set are implemented by sorting, not hashing. There are hashtable classes often called hashmap, but none is mandated by the standard.

Re:Serious reply: What will it take to make Lisp f

[Black Parrot]

> LISP needs a powerful IDE like MSCV++ with syntax-sensitive indenting, keyword auto-completion, and chroma-coding (perhaps they already do?)

Never seen MSCV++, but mere lowly Emacs does at least part of this, and could be programmed to do the rest.

> One thing that makes me shy away from using LISP for commercial product is the long pauses of the garbage collector that kicks in at unpredictable times. I would like to have a guaranteed maximum pause time.

There are lots of garbage collection strategies around, addressed to different tradeoffs, so maybe there is a Lisp implementation that uses one that will suit you.

However, in the limit, the garbage collector has to find memory as fast as your program consumes it. You could have a gc that only spent, say, 1ms whenever it butted in to do its business, but if your program is grabbing memory too fast you'd just get lots of 1ms interruptions without too much substantial computation between them. At some point your gc has to be in equilibrium with your program, regardless of what strategy it uses.

Re:Scheme for OOD

[Anonymous Coward]

No one here claimed that C++ was a "full" or a "true" object oriented language. Furthmore, while I agree that the overuse or misuse of operator overloading can be "deeply confusing", i would not go as far as to say that when it comes to type coercion. Data typing and type coercion is a very important concept for anyone truly interested in the efficiency of execution and storage on real-world digital microprocessors. As to multiple inheritance, it is often -- like Scheme itself -- a high-minded conceptual approach to programming that often makes little sense from an efficiency standpoint. Furthermore, speaking of a concept that can be thoroughly misused or overused... you just named one of the worst offenders!

Yes, you are correct, C++ has no garbage collection. Thank the lord! For many, that is a significant plus, not a drawback. While you are correct in saying that any functionality that requires memory allocation and deallocation becomes fraught with error, it also means that you are not subject to the ineffeciences and vagaries of a universal garbage collector.

You and others here praise Scheme for its elevation and promotion of the concept of functional programming. And while, yes, it can be elegant; functional programming, and Scheme in general, tend to promote recursive over iterative algorithms. And while tail-recursive procedures can be optimized into the iterative form, it is nevertheless my opinion that recursion often is an exercise in the elevation of concept over execution that Scheme epitomizes. It becomes so much form over substance. IMHO, they want to teach some algorithmically pristine view of the world that does not necessarily mesh with the programming effeciences and inefficiences of real world digital devices.

I agree that CS education should not be reduced to vocational education or mere certification programs, but neither do I believe in dogmatically elevating algorithmic form over machine code substance and being so often blythely ignorant of the implmentation efficiencies and tradeoffs that must be made for such a pristine view. It is the difference viewpoint between a computer programmer coming from a mathematics background versus one coming from a digital electrical engineering background. One views solely algorithms and functions, while the other is mindful of things like register sizes and machine code instruction efficiencies.

Flexibility versus Performance

[Anonymous Coward]

Richard P. Gabriel and Ron Goldman argue that software needs to become more organic, more forgiving, less brittle, less obsessed with performance, and more people-centered. One example they give is of small agents cleaning up objects if their class definitions have changed since their creation. This is possible using the Common Lisp Object System's (CLOS's) Meta-Object Protocol (MOP), which is a run-time MOP, but not, say, with Christian Queinnec's Meroon object system for Scheme, which can be described as having a compile-time MOP. On the other hand, Meroon's object system, in my experience, has much higher performance than CLOS.

Where do you stand on the flexibility-performance divide?

Re:Serious reply: What will it take to make Lisp f

[big.ears]

As a frequent LISP user, I think you are right about 1 & 4-- 2 & 3 would be nice, but GC doesn't bug me so much since I turned off the debugging feedback that told me every time it was collecting, and I almost never have to use non-tail recursion, and even then I find myself re-writing most recursive calls with mapcars and lambda functions.

I think the best IDE I've used is for MCL. The editor, FRED (Fred Resembles EMACS Deliberately), is probably better than the ilisp modes I currently use in EMACS (the paren highlighting keeps breaking, for instance.) Allegro's Windows IDE was pretty fancy, but was very difficult to work with. An IDE that allowed for better large-scale organization, as well as better GUI interface, could go a long ways toward reviving LISP. Something like Delphi/C++ Builder, but in LISP. But don't ask me how it would work.

Re:Scheme in CS [recursion]

[irksome]

But, in order to understand recursion, we must first understand recursion. ;)

-

CS contains many prongs

[Anonymous Coward]

The average university CS course consits of (roughly) two dozen computer science classes. Many/most of them involve programming, and all come from different angles. It's not uncommon to be taking two courses simultaneously, one dealing with a LLL (such as assembler) and another dealing with a HLL (such as Scheme). General computer science generally starts out at both extremes (some courses starting at abstract concepts, and others starting at integrated circuits), and supposedly the student will be able to get to the middle and piece them together fairly quickly (if not, he's in trouble).

Basically, nothing you ever do in undergraduate computer science will be useful. It's there purely to teach concepts. Thus, it seems pretty silly to try and force it into de facto standards. If a class is teaching about graphs, for example (and operations thereon), nothing is gained in doing in C++ over Scheme except extra headaches due to the pragmatism of C++ (and possibly some extra practice in C++, so that's not really the purpose of the class).

It's in everyone's best interest to understand things as quickly as possible. If I'm a student, I can do an assignment in Scheme in a few hours that might take a few days to do C++. This means that more topics can be covered in the class (which probably only runs about 15 weeks). Since the class is there purely to teach me computer science concepts (such as graph theory), it doesn't make any sense to waste time in C++, to be more "practical" about a thing which is inherently useless anyway.

I think it's the integration

[LoveMe2Times]

I've played around with both Lisp and Scheme (no strong preference either way), enough so that I feel pretty comfortable with the languages and my next step would be to write a minor application. But my lisp compiler sits around unused while I merily do useful (and occasionally interesting) things in Perl, Java, C++, ... Why? I think my problem is likely related to why Lisp isn't used much in industry: it's the integration, baby.

Now, I haven't poked around a lot, but what I want to know is, "Where are the libraries? The toolkits?" Perl has CPAN and there are so many C and C++ libraries that I don't want to think about it, and the standard Java libraries are pretty impressive in their scope and breadth (if not in quality or consistency, but I hear they're improving rapidly). All these languages can tie in easily to OS services and tend to play pretty nicely with each other. They have built in support in things like web browsers and web servers. Where is mod_lisp???

My question for you is: do you see any interest in the Lisp or Scheme communities to become mainstream in the first place? Or are they pretty much content with where they're at? Where is the work going on to make Lisp or Scheme competitive with Perl, Python, Java, etc in terms of portability and ubiquity and integration with important other programs (especially web stuff)?

Thanks for your time :)

Re:I think it's the integration

[mrdlinux]

The Common Lisp CLiki
cCLan
mod_lisp and other Lisp WWW packages

I personally use IMHO with mod_webapp to write web applications for work. People write similar things in Java, but Lisp is a far more suitable language due to the interactive runtime compiler and introspective capabilities. I find CLOS to be a better, more flexible object system for these tasks than the Java/C++ model as well. Multi-method dispatch, multiple-inheritance, call-next-method, :around methods, and even some Meta-Object Protocol I have used in my programs. And I nearly forgot the really neat HTML macros that let you write out HTML in s-expressions. It's much less clunky writing HTML in Lisp than HTML as HTML, especially in Emacs.

Re:My question, sir:

[Anonymous Coward]

technically, by giving the taliban $43mil in may this year, the us has "supported terroristic activities against the United States of America".

Don't blame me if you don't like it...

an interface like EMACS on steroids

[Berkana]

My primary reason to have a scheme-shell type interface is that it is consistent. I do plan on having Unix compatability built on as either a layer, or a module.

I didn't intend to have language enforcement, but the best-of-both-worlds scheme/lisp hybrid language that I plan to prepare for HomunculOS (tm) would be natively supported, and would allow EASIER tweaking/personal tuning of the OS, compared to the OS's written in C, like Linux and AtheOS.

What I envisioned was an interface that's like EMACS on steroids. Imagine the power! It's just that some of the commands are counter intuitive. The thing I love about Scheme is that the conventions are somewhat more intuitive than Lisp.

Let me know what you think. . .

Re:an interface like EMACS on steroids

[Peaker]

Well, I think that when designing an OS, you shouldn't yet worry about the shell you're gonna run. I also think that while it may be a good idea to ponder what language to use for the OS itself, it shouldn't really make a difference for the users of the OS, that should be able to use any safe language they want on top..
The tweaking should still be possible, provided that the interface provided to safe languages is completely compatible between all safe languages.

If the OS is modular/generic enough, one would be able to create emacs-on-steroids, or a simple *nix-behaving shell on top, and the OS designer himself should not worry about it :)

I myself don't believe in *nix compatability, btw, because *nix is bad news, and lack of such support will give rise to interesting new replacements :)

I want to believe

[nervebox]

All I read about LISP makes me want to use it. when I was a math student, I imagined programming languages to made of pure logic. Imagine my disappointment as I slowly morphed into a professional programmer and found so few tools with which to implement what I knew. But I'm having trouble starting with LISP.
Call me spoiled, but I've been looking for standard libraries to talk to COM ports, ODBC data sources, or various Internet protocols (POP3,HTTP, LDAP). The search is coming up pretty flat. I could write these libs as I need them, but I don't want to HAVE to.
So where can find some extensions and APIs for LISP?

That was the first place I looked

[Berkana]

The LispOS mailing list was the first place I looked. My design principle can be summarized as KISS aSS:

Keep It Stable, Secure, and Small/Simple :o)
j/k

.

Re:Scheme in CS [recursion]

[clacke]

After twelve years of procedural programming, my first contact with functional programming was this semester.

If anything, Scheme has taught me clean iteration techniques (through its tail-recursion syntax). Recursion isn't really that hard to grasp, but iteration is easy to screw up. And, judging from my fellow non-programmer students' reactions, teaching Scheme as a first language (and introducing set! as late as possible) creates programmers who enjoy writing clean code in general - modularized, high-level, generic code.

heh

[unixmandan]

cons of the 2 languages, was that a pun?

Re:24 years on LISP???

[Anonymous Coward]

How the fuck is this Informative?

Re:Serious reply: What will it take to make Lisp f

[Anonymous Coward]

It seems that you haven't looked at Lisp in the past 10 years. Otherwise you would have known that all your complaints except for the one about compressing stack frames have been answered very well already.

Compressing stack frames is probably impossible, because otherwise you'd lose information. You at least need to keep the return address and the size of the stack frame on the stack. That's much more than 1 or 2 bits. If you want to do very efficient recursion, put all the functions involved in a LABELS form and put a (declare (speed 3) (debug 0)) in the surrounding DEFUN. That will tell the compiler to do whatever it can do to speed up the function calls, at the expense of debuggability.

-- Rahul Jain

(OT) Zeros feedback

[Tablizer]

Perhaps if people knew WHY their replies keep getting zeros, they would stop repeating behavior that gets them zeros.

Thus, I propose that someone be required to give an explanation of why they are modding somebody down. And, plese be more specific than "troll". "Troll" is anybody you don't like these days.

LISP and readability

[Anonymous Coward]

LISP is very "elegant", I am told, because it has a single syntax for everything - braces, and lots of them! This allows LISP to be easily meta-programmed to a high degree, and I agree that this is an extremely powerful feature. However, it seems to me that the single syntax really detracts from the readability of the code - without a variety of seperators in the language it becomes a much larger effort to "parse" the code as a human [even though the computer finds it much easier!] This becomes particularly important in team projects and maintenance programming - which academia traditionally doesn't have much care for anyway! Where do you see the ideal balance between psychological "ease of use" of a language versus mathematical "elegance"?

What about Graham?/Isn't AI inevitable?

[sdprenzl]

Paul Graham makes some big claims for Lisp/functional programming in some of his essays (see www.paulgraham.com). But logic also dictates that some sort of artificial intelligence will have to come to pass; otherwise, we continue telling the computer each thought to have, hoping we thought of everything, and that those thoughts don't clash and crash. (To be sure, this hand-built, hand-coordinated approach is already pretty much maxed out.) Between Graham and the inevitability of AI's reemergence, Lisp seems like a good bet. Or am I (and Graham) way off?

AutoCAD still uses LISP

[dsyu]

Although it's called VisualLISP, does pretty un-LISP like stuff, and other weirdness, like an actual LISP IDE. But nonetheless, it's a major software package that uses LISP.

which IDE and other tools

[Anonymous Coward]

the most popular programming languages today seem to enjoy the support of rich development environments. features like displaying reverse call graphs, integrated debuggers, and other visual cues (beyond syntax highligting) that emacs does not appear easy to augument with.

what does your LISP coding console look like, and what tools do you recommend?

free software, repositories of emacs mode enhancements, essential code analysis tools, and other visual tools would all be pointers of interest.

thanks,
- Ryan

Why LISP is doomed

[Gorobei]

In theory, everyone should be using LISP: it's fast, interactive, elegant, extensible, and reflective. Many modern languages lack its power: e.g. most "design patterns" are solutions to the problem that you aren't using LISP.

As time goes on, I get to program in LISP less and less, largely because it is being used less. I've wondered about this for some time, and here's my theory:

In the old days, when computers cost $200,000 a piece, the scarcity of hardware made the competition for the chance at a CS degree very high. Graduating required at least the ability to write a compiler, a toy OS, know how to use all the standard data structures, know algorithmic complexity, Turing machines, computability, etc. A DEC-20 supported so few users that a Uni could only graduate 40 CS majors per year: the bar was raised to the point that those making it intuitively understood that LISP expressed computation well.

When desktop machines arrived, there became a demand for programmers (people that could turn ideas in programs.) The schools could turn out more programmers because resources where cheaper for them too. CS (or IT) became as common a major as English Lit, and the bell-curve of talent was no longer chopped off at +3 sigma.

10 years ago, many new CS graduates couldn't explain what a Continuation was. Now, many can't explain how a hashtable is implemented. Moore's Law has obsoleted deep CS knowledge (and thus LISP,) as brutally as the industrial revolution killed weaving skills.

There will always pockets of LISP (the skilled craftmen working on human-scale projects,) but the vast bulk of computer programming is now carried out by people with neither the time, inclination, nor mental capacity to understand what was once Computer Science.

I wish I were wrong, but I fear programming is becoming like food: yes, there will always be some great chefs, but most people in the industry will never be able to progress beyond their fast food outlet's Fryolator.

Re:Why LISP is doomed

[Anonymous Coward]

This has to be one of the most lucid and succint explanation for the amazement people over 35 feel about obvious ignorance of trained professionals in their 20s. Thanks. (Made me post to slashot!)

Re:Scheme for OOD

[sdprenzl]

I've never bought the CS degree argument that you need theory, etc. in order to be fit enough to catch the next wave. Believe me, nobody like Oracle or Microsoft is going to come out with something so new and big that it'll take a CS degree to grok it. The real IT world makes the next wave as catchable as possible for their developer base. Hence, good IT jobs are very possible without CS degrees. Look at MS: a study in living totally outside the CS degree.

A CS degree says you can tackle big stuff and not get thrown the first day. If you don't want to do bread-and-butter data management work, but stuff more cutting edge, then yes, the compter as a scientific subject should be in your realm of knowledge. But when as many as 75% of any given CS program's students only want big-buck commercial data management gigs, why torture them with CS theory?

Re:Too damn dumb

[sdprenzl]

Q: Are you lisping?
A: No, I'm scheming.

Is Java the successor to LISP?

[Animats]

Although the syntax is very different, Java has a run-time environment that's LISP-like, with dynamic loading, run-time safety, and garbage collection. Java is now the first language taught at Stanford. Is Java now being used where LISP once was?

Re:Is Java the successor to LISP?

[NetSettler]

This is an excellent question. That's not to say I agree with the claims it's making, but it raises a number of interesting and important issues. The short answer, I think, is that there is a difference between "how a language is used" and "what a language is good for". You're making observations about the former and trying to conclude things about the latter, but I don't find the inductive leaps you're making to be well founded.

When I look at how Java is (or should be) used, I see more similarity between Java and TeX or C than between Java and Lisp. That is, I see Java, TeX, and C as "assembly languages" and Lisp as a "higher level" language. The former set of languages are about implementing an idea (saying how to do it), while higher level language should be, I think, about expressing an idea (saying what you want done, and abstracting away from how you want it done).

Can one such language threaten the other in the marketplace? Sure. Does marketplace superiority necessarily imply technical or conceptual or moral superiority? Can you spell "Microsoft"?

I don't deny that Java has adopted some useful features of Lisp. I'm actually relieved to have entered an era where I don't have to explain the importance of garbage collection all the time. Java has finally made it clear to people that this is a useful language feature. I'm happy to see any of the good ideas of Lisp trickling down into other languages. But Java has not by any means "captured the essence of Lisp".

Because continuations are hard to implement

[phr1]

in languages like Java. (Don't say do it with
threads. Performance will be abysmal. Remember
that it's supposed to be legitimate Scheme style
to use continuations anywhere other languages
would use gotos, loops, or even ordinary function
calls, not just fancy constructs like coroutines.

Open Implementations

[Martin Pomije]

What is your opinion of the idea of Open Implementations from Gregor Kiczales? Do you think that his idea could help Lisp be more widely used?

You can see him giving a lecture about this idea here. The video is only available in Windows Media format on this site.

Re:Scheme as an inefficent language

[DeepMind]

Damn it! How do you know ??? :)

Julien.

CS != learning a programming language.

[morzel]

I have to disagree with you: CS isn't about learning programming languages, it isn't about mastering a specific technique or language that is "apt for industry".

It's all about learning the basic fundamentals of programming, algorithms, data structures, different ways of solving things, lot's of theory - it's called "computer SCIENCE", remember.

Scheme is a good teaching language for a lot of reasons:

Most CS students nowadays have experience with computer "programming": VB, Delphi, C, C++, Java, Javascript,... nearly everybody has some experience with some programming language. The problem is that a lot of this experience isn't always built on the proper fundamentals, they're mostly about solving a particular problem without knowing why they should use data structure X or algorithm Y. The usage of Scheme as a teaching language has the advantage that most (if not all) students are forced to learn a new language, which probably isn't at all similar to what they're used to - enabling the teachers to start from scratch. That way, there aren't differences in the level of knowledge of the students, also a plus.

The language structure of scheme is very flexible: most (if not all) fundamental bits can be dealt with properly in Scheme: procedural programming, heaps of different data structures, OOP, ...

I do agree that other languages (be it C, C++, Java, Pascal, Fortran, O'Caml, Eiffel, ...) should be taught as well. But only on a later stage in the education: the most important thing is that the fundaments of your knowledge are strong, well-taught. Scheme is a good language to do just that: laying those fundaments.

With the boom of IT and internet the last 5 years, there are so many programmers out there that lack those proper fundaments. I'm not saying that they aren't any good, but there are a lot of people that don't have a grip on what lies beneath - which is a pity.

Don Knuth showed us that computer programming is an art, not based on a specific programming language, and I tend to agree with him :).

Re:CS != learning a programming language.

[juha0]

Mod this guy up! At my school first programming course was pure Scheme. Syntax is really simple, and students don't need to waste their time in learning that. No loops, so everything was done by iteration, and a LOT of attention was paid to (simple) algorithms. Benefits of recursive and iterative solutions we're teached, and often we first solved some problem in O(n) way, and after that we did it O(log n). People who had been coding 10 years we're really learning. Also streams we're introduced, and at the end of the course student's we're making changes to a metacircular evaluator(Scheme evaluator made with Scheme). Haven't run into other language that makes this possible. Enough Sheme hype, but if you want to open your mind, this is a really good book: The MIT Press, Structure and Interpretation of Computer Programs.

Re:CS != learning a programming language.

[Anonymous Coward]

I find its pretty fun to switch your main programming language every once in a while, just to make sure you're not getting too attached to one syntax.

Play around a bit in C(haven't done any C++ yet), then switch to scheme for a bit, back to C, and then try Forth...etc.

I wonder how classes would work if they were taught with MIXAL(or is it MMIXAL now?), it might be a pretty good idea, especially with a simulator that showed you what was going on inside the machine.

Re:Scheme for OOD

[mvw]

C++ isn't a fully object-oriented language. It's a set of object-oriented extensions grafted onto a non-OO substructure. One particular place where you can see this is the way the object-oriented extensions combine with operator overloading and type coercion to create something that's deeply confusing.

This is not true. C++ has full support for OOP (and lots of other paradigms as well by the way). In that aspect it is more complete than Java which misses multiple inheritence due to concessions to its VM interpretation. Operator overloading is a blessing or a curse depending on how you use it.

Too bad that many beginning C++ programmers expose the same habit like new wordprocessor users who try out every font and style to create ugly documents, but that's not the fault of C++.

Also, since C++ is aimed at building very efficient systems programs, it skirts things that seem difficult, like multiple inheritance. C++ has no garbage-collection.

Again I disagree. Java has shown how helpful a modern, large, portable, well documented set of libraries is. The libraries are the real part, where C++ could need additional work.

Re:Scheme in CS [recursion]

[Anonymous Coward]

The conventional wisdom about my college's CS program is this:
1. We spend our first year doing Java, so we can concentrate on designing clean software.
2. We spend our second year working in Scheme, so we can actually write algorithms that work.
3. There are many students, even when they are working in C, who start a complicated problem by solving it in Scheme, and then worrying about the language change later.
The essential idea is that all CS students will write as cleanly as possible from design down to the nitty-gritty search algorithms.

Lisp Threads

[Anonymous Coward]

I have read that in Lisp you cannot create threaded code. If this is true is it just impossible to implement threads within the Lisp model of computation or is threaded Lisp not used because it would make the language ugly (Lisp being the "only beautiful programming language").

Re:Lisp Threads

[J. Random Software]

Just like C++, Eiffel, Perl 4, and most other languages that predate Java, Common Lisp doesn't specify a threading interface, but several vendors offer proprietary threading interfaces after having made their runtimes thread-safe.

What should lisp not be used for?

[drinkypoo]

We've seen nearly everything written in lisp these days. Are there any kinds of projects you can think of which would better have been written in another language?

Make them write an interpretor

[jordanda]

My program at the University of Washington is very much against the "get them ready for industry attitude" which some of the students don't like. We learn Scheme in a class called "survey of programming languages" as the first of a series of four languages meant to touch on the difference between functional, pure functional, procedural and object oriented code. Early in the course we write programs for Scheme in Guile. The final project is write an interpretor of Scheme in Java.

I think this is the best way to sell Scheme. Once students see how easy it is to write an interpretor for it they get all kinds of great ideas of how to integrate it into other applications.

How to make a free Lisp great?

[Gurdy Leete]

What do you think is the nicest Free Software Lisp environment now, and what would need to be changed or added to make it as good as or better than the most appealing Lisp environment you have used?

What was up with CLisp's "loop" form?

[Jayson]

Did you can have anything to do or know who had anything to do with the "loop" form in Common Lisp? Why does it look and feel just like a FOR loop on C (from the Graham book):

(loop for x = 8 then (/x 2)
until (< x 1)
do (princ x))

This is one of by biggest minor nags about CLisp and I am very curious what was going through the committee's collective head. Didn't anybody balk at this enough to at least get the syntax cleaned up?

-j

Re:What was up with CLisp's "loop" form?

[jaoswald]

What's the problem? The purpose of the Common Lisp "loop" macro was to develop an easy, almost English-like way to describe iteration. For those who don't know it, it has a lot of "clauses" to describe the various phases of initialization, stepping, testing, and collecting results, which get combined in an almost free-form way.

It includes things like the C for loop, but a lot more as well. [from the Hyperspec]

(loop for x from 1 to 10
for y = nil then x
collect (list x y))

=> ((1 NIL) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9) (10 10))

;; Collect numbers larger than 3.
(loop for i in '(1 2 3 4 5 6)
when (and (> i 3) i)
collect it) ; IT refers to (and (> i 3) i).
=> (4 5 6)

You don't have to use LOOP if you don't like it. It is a bit of a mess, when different clauses start interacting, but it can be very clear when the other iteration mechanisms might be more confusing.

How would you prefer the syntax to look?

Re:What was up with CLisp's "loop" form?

[Jayson]

It isn't Lisp. It is bad C. If you could find a full spec of the syntax and semantics of LOOP, I bet it is larger than the R5RS of Scheme. It is as if an evil C zealot snuck into the committee and forced his twisted philosophy on everybody: a terrorist plot against everything that is Lisp. The LOOP clauses are out of place in the beautiful forest of s-expressions.

Seriously, I have just never a use of LOOP where DO/MAP/REDUCE were not cleaner. The interactions between clauses is unbearably difficult to understand at times. If you are looking for peculiar interactions between the variables in the clauses, then use DO*.

The this what really annoys me with DO/MAP/REDUCE is that even though CLisp has a large standard library of functions, it is missing small very useful list generating functions: like generating a list of the integers from 0 to x. Then the need for defining some incrementation construct and iterating though it would be eliminated (not in the Lisp spirit, I feel); you could then just MAP across the list (a much more Lisp-ish style).

Besides all that, LOOP is just too complex, very poorly defined, and not extensible at all: very un-Lisp like.

-j

Unique Scheme Ideas

[Jayson]

Nobody ever mentions call-with-current-continuation. Scheme-like continuations seem to change everything in a language. Now Scheme behaves like Icon in that any function can return multiple times. Coroutines and cooperative threading become trivial to implement. Try to wrap your head around returning a continuation from a function or passing a continuation into another continuation. Continuations provide a functional way to remove control logic from a program.

Continuations make forms like "promise" and "force" work. With promise and force you can make Scheme lazily evaluate arguments to a function of an infinitely long list (or promise to provide a continuation). force will only evaluate a promise once, no matter how many times a promise is forced.

(promise thunk) ;; delays the evaluation of the function thunk (a thunk is a function that does not take an angument) until it is later needed.

(force prom) ;; forces the evaluation of the promise prom, which is the value of evaluting the origiinal thunk.

You make lists where the tail if the list is a promise to evaluate the rest of the list.

Another fun Scheme form is "amb" meaning abigious. Solving the 8-queens problem becomes trivial. Amb allows a program to search a state space without having to encoding the search and backtracking logic.

(amb ...) ;; returns all its arguments, one at a time (meaning the function returns multiple times), until it has no more arguments to return. At that time it fails, and computation backsup to the preceding the preceding amb form.

Re:C++ and OOP

[jaoswald]

C++ has no elegant way to specialize on multiple arguments of a method, because C++ methods are tied to classes. "friend" is a symptom of this disease.

Sure, you can use various "patterns" to get around weaknesses in the C++ object model, but why should you have to?

Also, when you re-define a class, you have to recompile your C++ program. Which means it has to stop running. Neither is true in CLOS. You can interupt a CL program, re-define a class, write code (if necessary) which updates older instances to work as instances of the re-defined class, on demand, and then continue execution, perhaps after you've interactively tried your new class definition.

Still think C++ really supports OOP?

How much Common Lisp reguires from programmer?

[notany]

I have now been learning + programming in Common Lisp about 3-4 years. I have learned that CL gives more degrees of freedom to programmers than any other language I have learned before (C/C++, Java, ,Ada ,Prolog ,Haskell, Pascal, Python, Perl). It is said that (Common) Lisp is programmer amplifier. The good news is that superior programmers/architects get 100X boost. But my experience is that bad/medicore programmers can shoot themselves in the foot as badly as in Perl (usually in more abstract level). My question is: Can Common Lisp be used/learned in company of tens of people who have been using C/C++/Java and only 10 persent of those programmers have masters degree?

Re:How much Common Lisp reguires from programmer?

[jaoswald]

The point is that a few very good programmers using Common Lisp beats far and away the same number of *equally good* programmers working in C/C++.

The fact that a few very good programmers kicks ass over a large group of mediocre programmers is not about Lisp. It is about mediocrity.

The question shouldn't be "what tool do I get to protect mediocre/incompetent programmers from their own weakness" but "how do I get great programmers"? One way, is to let the great programmers use the language that lets them work best.

Programming well is hard enough. Why make it harder by forcing every one to use tools made for the lowest common denominator?

And if you do get mediocre programmers, either train them or dump them. True incompetence will harm your project, no matter what language you use. Inexperience or ignorance can be conquered by training.

Re:Scheme for OOD

[rpg25]

A CS degree says you can tackle big stuff and not get thrown the first day. If you don't want to do bread-and-butter data management work, but stuff more cutting edge, then yes, the compter as a scientific subject should be in your realm of knowledge. But when as many as 75% of any given CS program's students only want big-buck commercial data management gigs, why torture them with CS theory?

I've got an answer to this, from working with people like that. They don't know how to find a decent algorithm in a book. They reinvent everything and, pretty much universally, they aren't as smart as the people that invented them in the first place (that's not really fair --- they may be as smart, but without the benefit of knowledge created before them, they are helpless).

For example, I've seen people reinvent OO databases, I've seen more linear time searches than you can shake a stick at (this is a sure recipe for disaster in big-buck commercial data management), I've seen parsers that would make you want to cry, written by people who never took compilers, etc., etc.

CS without theory is like engineering without physics.

Re:Scheme for OOD

[rpg25]

Those points are all well and good, but they don't get at my argument. I wasn't trying to argue for the abolition of C++. Just trying to point out some reasons for using Scheme over C++ for instructional purposes.

Re: Lisp implementations

[jaoswald]

Sorry if I was being harsh, but there is an important difference between "interpreted" and "interactive." Macintosh Common Lisp, for instance, compiles everything to native code, but is still just as interactive as an interpreter. Since compilation can act on individual functions, it is very fast, and the overhead is completely negligible. I enter (+ 3 5) and get 8 back without a blink. Many people use the "Lisp is interpreted, therefore slow and inefficient" myth as a way to dismiss it.

More typically (CMU CL), when you type things by hand, including function definitions, they are held in interpreted form, which is more flexible for tracing, debugging, introspection, etc. You have to add the extra step of asking things to be compiled. You can ask for individual function definitions to be compiled, or for whole source files. Much of the work that went into Common Lisp was to ensure that compiled code and interpreted code have exactly the same semantics, unlike the original Lisp implementations.

I haven't done work on the PC, but at least on Mac and Unix, it is de rigueur to support a foreign function interface to libraries that follow the native linkage format (C, Fortran, etc.) In the other direction, things are a little more limited, as Lisp has a pretty elaborate run-time environment, that can be difficult to access from more primitive environments like C.

If you mean linking to Lisp libraries, then I believe that the shipped binaries would have to be Lisp platform specific. I.e. Franz "fast load libraries" have a different format from Xanalys.

I've heard a lot of talk on comp.lang.lisp about the use of CORBA as a mechanism to solve a lot of these inter-language problems. Lisp provides a very good platform for using such protocols.

is Common Lisp an orphan?

[Anonymous Coward]

Paul Graham in 'Being Popular':

"Common Lisp is unpopular partly because it's an orphan. It did
originally come with a system to hack: the Lisp Machine. But Lisp
Machines (along with parallel computers) were steamrollered by the
increasing power of general purpose processors in the 1980s. Common
Lisp might have remained popular if it had been a good scripting
language for Unix. It is, alas, an atrociously bad one."

Does Common Lisp have/constitute a system to hack on vanilla hardware?

Cadence Re:Lisp as a Macro Language

[Anonymous Coward]

The tool for integrated circuit design that leads (monopolises ?) the market is using a lisp/scheme like language called "skill".

McCarthy and Foderaro said it best

[alispguru]

John McCarthy said this in 1980:

LISP has survived for 21 years because it is an approximate local optimum in the space of programming languages.

More recently, John Foderaro said:

Lisp is a programmable programming language.

For my money, these two together cover Lisp's enduring advantages over newcomers.

Yes, you can get many advantages with strongly typed functional programming languages. But, you can get most of their abstraction power with Lisp's first-class functions and macros, without the pain and suffering of adhering to formality. Most Lisp hackers acknowledge the utility and power of functional programming, but use Lisp anyway because it doesn't force them to do everything functionally

Yes, Java, Python and Ruby have many of Lisp's features without Lisp's syntax. But, they don't have Lisp macros, so the abstraction power of designing your own language is not available to them. I use Lisp because it allows me to take

FileInputStream infile = null;
try {
infile = new FileInputStream("foo")
// Do stuff with infile
} catch (Exception e) {
// Report error munging infile
} finally {
infile.close();
}

and replace it with:

(with-open-file
(infile "foo" :direction :input)
;; Do stuff with infile
)

and get the same level of safety, with a lot less repetitious code.