Lisp, Scheme, the JVM and CLR
Given my recently renewed interest in Lisp and its cousins, I of course can’t help to wonder how they might actually become used as widely as I believe they should be. While not having used either Lisp or Scheme in any real project yet, I agree with the often-made claim that essentially everything one ever wanted to have in a programming language is in there, and many of the concepts introduced in recent iterations of Java and C#, or Python, Ruby, and of course Groovy, are basically just a sign of those languages’ playing catch-up with what’s been there since 1958.
So why doesn’t everybody use Lisp or Scheme? Some people hate the syntax (although it would probably be more correct to say that they hate the lack of one, since Lisp dialects basically directly show the AST), but I don’t think that’s the reason. Some claim it’s the attitude of the Lisp community’s members, and they may be partly right. What I believe, though, is that the ultimate test for a language is not its elegance, or even its core feature set. (If you actually know what lexical scope, closure or continuation means, take a few seconds to remember that you are not part of the majority. Thank you).
What basically determines whether a language is useful is whether it can be used to solve real world problems efficiently. And this, in turn, depends very much on the libraries available — and the only chance for any language to compete with Java or C# is if it’s based on the JVM/CLR. CommonLisp, criticized by Scheme aficionados as bloated, only contains a fraction of the functionality of the J2SE or .NET libraries (not even including the plethora of open source stuff, especially in the J2SE case). Perl has managed to attract enough of a community to come up with the extremely extensive CPAN, but I believe it’s probably the last language to have managed that.
What could attract people to Lisp, or Scheme (the latter probably being a better choice), would be something like JScheme or Kawa, if done right. I don’t know whether my view is flawed, or these implementations, but I’ll comment on that once I know more about them.
what can bring people to Scheme is python, then ruby.
Starting using python you start to get the idea of function handling and (kinda) lambdas. With ruby you start (ab)using the real power of a lambda, and making hard tricks with callcc. Then you have opened your mind enough for Scheme.
But to be fair, I can think of many things that many lisp dialect lack.
Furthermore, sexp based syntax should not be used. I hope when graham’s arc come out it will have a nifty sintax (mccarthy himself wanted a syntax for lisp, over his sexp-based metasyntax)
It’s probably good advice to go with Python, and maybe Ruby, for practical reasons — especially Python is gaining so much momentum that one might be able to avoid being accused of ivory tower behavior.
AFAIK, unfortunately both Python (pretty sure here) and Ruby (not so sure) lack a macro facility. And strangely enough, I like the non-syntax of Lisp dialects; I know many people hate it, but I believe it’s extraordinarily clean.
It is lisp’s minimal syntax which enables its excellent extensibility. In other languages any new construct uses a different syntax to differentiate it, and also because there is no neat clean way to describe it using any of the current syntax. Sexps are brilliant in that almost any programming construct can be described in a simple clean way.