NewLisp is a Lisp dialect which tries to build a modern platform based on the Lisp heritage, in order to answer modern computing needs a lot better than other dialects do. According to its developers, newLisp is a Lisp-like, general-purpose scripting language. The official description is somewhat misleading though, because it implies newLisp is a kind of Bash with more parenthesis than code — which, as it turns out, it is not. newLisp can competently handle application programming, statistical computation and web development, so it’s actually closer to Python and Ruby than it is to command.com.
For those of you who are not familiar with Lisp, the entire story in a hundred words of more can be boiled down to a very expressive, dynamic, extensible language which can be used in a functional manner if you carry a picture of Haskell Curry in your pocket. Most Lisp programmers cite its powerful meta-programming features, its expressiveness and very concise style as being Lisp’s greatest features. From this description, it would seem that almost everybody would want to use Lisp, which is in fact true. What is also true is that very few people use Lisp though, and for a handful of otherwise fair reasons, some of which we will discuss immediately.
Those readers who are familiar with Lisp are cautioned that, given our favorite programming tool’s extreme popularity, this article is aimed at a very wide audience. As a consequence, some explanations are not exact or complete, but are nevertheless comprehensible for people who haven’t used Lisp before. It’s a small price to pay when you’re famous.
A tale of more Lisps: from Common LISP to Scheme and newLISP
The first thing I mentioned about newLisp is that it’s a Lisp dialect. As you may have guessed if you did not already know, Lisp is actually the name given to an entire family of languages (which can be equally well characterized by the description above). However, even today, most people refer to ANSI Common LISP when they talk about Lisp. ANSI Common LISP is, as its name implies, a standardized version agreed upon in the 1980s. Several implementations are available today, of which SBCL, GNU Common LISP, CMUCL, Clozure, Allegro Common Lisp and LispWorks are only a few of the more commonly used.
ANSI Common Lisp is an extremely powerful language. Its standard includes not only the kitchen sink, but very detailed provisions about the entire civil infrastructure of a small town. ANSI CL also includes a remarkably portable API, which is unsurprising given that it was designed in the days when there must have been fifty ways to leave your lover and equally many platforms to write your letter of adieu on. However, some of its features are really anachronic, and the large number of features makes the documentation very cumbersome to work with. To this date, the main reference is a document called Hyperspec, which is a very detailed and complete specification; while being thorough and reliable, the Hyperspec is also famous for being extremely cluttered and for making it very hard to actually find anything, partly due to its nature, partly due to the sheer size of the CommonLisp standard.
By contrast, newLisp is very lean and quite minimal. It does away with many of the implementation details in Common Lisp, in favor of a simpler subset that can be used to compensate for any features that are missing out of the box. In this respect, newLISP feels a lot more like a language from the 21st century, even without being as complete as Common LISP.
newLISP also sports a couple of significant differences, both in terms of syntax-related details and in terms of architecture. In fact, there are several notable language-related differences which bring newLISP much closer to Scheme than Common LISP. However, even in comparison to Scheme, the dominating aspect of newLISP is simplification. Just one example: newLISP replaces the various equality operators in Common LISP and Scheme with a single one. Therefore, you no longer need to remember the difference between equal, eql, eq, equalp, =, string=, string-equal, char= and char-eq — which is really how things should be.
Invented half a decade ago
yet it was used in the 1980s!!! impressive
edit ‘the quoted typo has now been ammended’
Edited 2009-01-05 19:37 UTC
It wasn’t used just in the 1980s, but the most famous achievements of Lisp’s date back to the 1980s. Actually, the best stuff Lisp was used for date back in the 1960s and 1970s, when it was THE promoter of many techniques (the most important being garbage collection) that are still used today.
After the 1980s, Lisp was somewhat abandoned because its main field (AI research) was itself all but abandoned.
yeah who cares about AI when real humans are as dumb as rocks and watch American Idol or Eurovision?
AI is not even close to abandoned.
Most of its areas have moved out into fields of their own (data-mining, searching and problem solving, etc)
but AI is a very lively field of study.
… of languages to have a look at and to eventually use for something “real-world”, I once again come down to wondering, in 2009, _what_ I actually might want to use LISP for. Sure, it’s an interesting language eventually covering a set of use cases better than other languages, same as Haskell or Erlang or Prolog or Scala or some others. But: Looking at my (narrow) horizon of using Java in a productive environment every day, I see it’s not really the language, the paradigm or the IDE to make this a useful tool – it’s the vast community, the overwhelming set of third-party components and code both open-source and proprietary, the presence of frameworks and platforms like Java EE or Spring, the availability of tools for modeling / MDA, testing, code coverage and so forth, the existence of application servers to allow for deploying, starting, running distributed applications without too much ado that still make me stay with Java rather than considering going for any of the (eventually more interesting) languages. So to say: Where in this toolbox to meaningfully fit in newLISP and friends? Where, in terms of doing productive work, can newLISP be dropped in there getting something done, making it more than just an “interesting tool”?
Thanks for any comments…
K.
A handful of places where Lisp is used can be found here: http://bc.tech.coop/blog/041027.html . Some of the links are dead (the blog post is almost five years old now), but it’s there all right.
I, for one, don’t believe in the rebirth of Lisp, in spite of liking it as I do. Common Lisp is too baroque to be meaningful today, and I don’t think tools like newLISP or Scheme can make good replacements for Java or C# (although without trying it, I can’t call this an informed opinion). However, there are a few features of Lisp that I wish Java — of which I’m a user myself — actually had.
I also think there’s a reasonable niche for Lispish scripting languages like newLisp; they’re dynamic ,expressive, have enough tools to be used for this, they’re portable and allow for quick prototyping, which is exactly what I’m looking for in a scripting language (and what made me try newLisp first, in fact).
Edit: many of the links on that page point to Franz Inc.’s webpage, which sells its own Common LISP implementation, so there’s a lot of marketing mumbo jumbo on them which I think you can safely skip.
Edited 2009-01-05 21:00 UTC
Thanks for the pointer, I’ll surely have a look and browse through these. Actually, I am generally enthusiastic about solving problems using tools that fit them best. I would love to, say, use a functional language to implement the computational core of our business application, or something like Prolog in situations in which business rules are to be implemented / evaluated. Maybe in many cases this would even eliminate the need to have custom DSLs because some language in existence might address the problem same as well.
But: In the end, to me so far it seems that, in terms of overall support and tooling, there are Java and .NET and no real other languages completely on par with both platforms in terms of feature completeness, tooling, adoption and “ecosystem”. So as long as it’s basically about choosing either one of them, throwing in another language to me mainly seems about adding complexity: I need an expert capable of working with this “additional language”. I eventually will have to deal with a broken tool chain, being in need of another IDE, different debugging / profiling tools, different deployment mechanisms and so forth in order to get code implemented in this language handled. Plus, in worst case I end up with making a “standalone” application a “pseudo-distributed” one as I am suddenly in need of enabling communication between code / subsystems implemented in different languages, making use of different runtime environments, … . Maybe, in Java, things like JSR-233 are likely to ease this a little on the long run, but so far I am really really sceptical about that…
Cheers,
K.
I agree; at its current state, Lisp does not make a good replacement for Java and .NET, not in the real world anyway. Most of those that have used Lisp for complex applications — including some of the companies listed on the page I’ve posted earlier — have complained about the lack of proper libraries. Emacs and SLIME make good enough development tools to be used, and now there are also good alternatives, like the two Eclipse plugins I can’t name right now (one was called Cusp I think, I don’t remember the other one). Most LISP implementations also have an excellent FFI and tools that can automatically generate bindings based on header files, but that really doesn’t make a good replacement for well-written and, most importantly, well-documented actual libraries. In fact, most LISP users are a bit uncomfortable with automatically-generated FFI bindings because, when they are automatically generated, they don’t make very Lispish code (and you probably don’t want to write C with extra parenthesis).
Granted, there are enough libraries to cover most major areas right now, but there’s a great deal of inertia. A few years ago when I first used Common LISP, the only reasonable options for GUI that I had were a toolkit called Garnet (big, complex and non-free) and Xlib bindings.
As for the syntax, I actually find it useful. Keeping track of parenthesis is hard if your text editor cannot do that automatically, but most editors do now. It also helps if it can indent your code properly. I never had problems with parenthesis. There are other problems in Lisp as a language, some of them nicely evaded by newLisp though.
It’s hard to say whether these are better or worse times for Lisp. It does get a lot more attention, and (unlike some years ago) there is some proper documentation available, like Practical Common Lisp, but simply being is the spotlight is hardly enough. Unless someone manages to make up a decent, active community that actively contributes code and ideas, like that behind Perl, Ruby or Python, Lisp is really doomed to be just the language that was cool back in the 1980s (which, for large values of 1980s, really was half a decade ago :-D)
The IDE and tool chain part is the easy part, really. If you have some clean code in lisp that translates into a mess in java, then you should use lisp, because managing an IDE and installing a tool chain for lisp is nothing when compared to debugging messy code: THAT is the hard part, and the bigger the code, the harder it gets. For small programs, it’s ok to use a random language, but when your programs have more than 100 000 lines of code, you better choose the right language, no matter how hard it is to install an IDE. When you have more than 1 million lines of code, you spend less time learning a new language and reading clean code than reading bad code in the language you know best. When the code gets really big, even writting a new language from scratch is easier than using a less than perfect language for your project.
Edited 2009-01-06 14:01 UTC
Dude, you really got the point. In so-called “IT” industry, the most worthless thing is the technology. Money is the real boss. Lisp itself is good. It evolves smoothly, in contrast, languages like java or C# are just evolution dead-end. I saw the talk about the future of C#, my impression is that these C# guys is doing the same thing as those C++ people did to C. They are just patching the existing language. And the result is that we end up with a language with awfully complicated syntax and semantics.
Why these guys like C flavor so much? I mean C is good, it is also an evolution dead end, but it is OK for C because C is designed to do low level programming such as writing kernels, device drivers or system programming, and this kind of jobs rarely changes. In contrast, languages like java or C# are different, they are mostly used in business world, and business changes fast.
Edited 2009-01-05 22:02 UTC
C was designed to be a high level portable language, not to do “low level stuff”. It was the C# or Java of its time, when everything was done in asm.
C# isn’t just rolling random features in, if you look at the last few releases it is obviously trying to roll some of the reasons that functional and dynamic languages are so awesome into a statically typed language while still maintaining clarity and performance.
Not only that, but the IT industry that you are disparaging is taking a good look at functional languages like LISP right now. There is a huge interest in Haskell, Erlang, and F# as a way to leverage parallelism in a smart way and to deal with certain types of problems that OO doesn’t handle well.
C is designed to be general purpose high level language, however, it is practically not good at developing large complex user applications, especially, those business applications which have to be fast-written and change greatly from one domain to another. C does not free programmer from taking extra care of low-level things.
No. At the time C was invented, the mainstream high level languages were COBOL, FORTRAN, Algol and PL/I. These languages do not handle e.g. pointers and bit operations as well as C does.
C was invented specifically as a system programming language (so they wouldn’t have to rewrite OS for different architectures).
One of the “friends” is F#. In the .net world, F# is a first class citizen, and can interop with C# assemblies with little effort and no penalty. The idea is that OO does not deal with certain kinds of problems well, while other paradigms deal with them beautifully. Functional languages are phenomenal for recursion, and can function in a parallel manner gracefully, both things that are very ugly in OO languages.
I would argue that the IT industry is very interested in functional (and dynamic) languages, are are just trying to find the best way to use them right now. I haven’t been in the Java world for about 7 years now, but in the .net world functional languages are getting a lot of buzz.
Symbolics, Symbolics, Symbolics Symbolics Symbolics!
Sorry. Since we’re talking about Lisp I just had to get that out of my system.
Also, I believe OpenGenera is still available for Tru64 UNIX.
sorry, my wrong
Edited 2009-01-05 21:24 UTC
Clojure is much more interesting than newlisp. http://clojure.org/
And actually enjoyed it. But I am glad the author pointed out some of the glaring differences and how they might be confusing (indexes, eg.)
Overall, my impression of it was good too, fun language, really.
wislist -> wishlist
betweem -> between
I wonder if times are getting better or worse for LISP. If you listen to Paul Graham and some other LISP guys times are getting better because other languages slowly adopt features from LISP.
I, however, believe times are getting worse for LISP because its ecological niche is getting occupied by other languages.
The good news is that programming Ruby or Python is probably less painful for a LISP guy than programming C.
The bad news is that the incentive to make the jump to LISP from these languages is also smaller.
“whose fans look almost with despise at other languages rediscovering it” should probably read:
“whose fans almost despise other languages …”, or
“whose fans look almost with despite at other …”
Where 1st is more natural, and 2nd closer to original sentence structure.
Sorry to grammar/vocab nazi on you …
VERY high performance games of the previous generation of consoles…
http://www.gamasutra.com/features/20020710/white_02.htm
http://www.allgame.com/cg/agg.dll?p=agg&sql=4:3946
As most students of LISP will tell you, LISP does NOT stand for LISt Processing. It stands for Lots of Idiotic Stupid Parenthesis.
My favorite:
Perl => Pathologically Eclectic Rubbish Lister
(for the record: I love Perl)
I’m glad to see a renewed interest in LISP. I have always enjoyed the language and what can be done with it. The article and the comments have prompted me to finally register to OSNews after years of being just an anonymous guest.
Yes, all the parentheses are tricky to keep track of and pair properly so that the Read-Eval-Print Loop can handle the programmers’ thoughts as intended. However, this is not a major handicap once one has reached some fluency in the language.
One strength of the language is that Code and Data have the same fundamental structure. This has been used extensively in AI Research, including studies on AI programming languages and the creation of purposely defined LISP dialects.
I’ve done my LISP programming using muLISP on a PC (8088 @ 5 MHz, 512 kb memory, two floppies, no hard drive) years ago. One weakness I encountered back then for the specific case I was programming was the difficulty to handle time-stamped data. The data structures I came up with were likely not the best but I managed. I wonder if the younger dialects have pre-defined functions for this.
Although all data processing problems can be handled by any computing language, there are some pairings which are easier to mentally work with than others.
By the way, MDL (a.k.a. Muddle) from which current LISP draws some of its constructs was used for the original mainframe iteractive fiction game Zork. The coders went on to form Infocom and ported Zork to the early microcomputers via a virtual machine (Z-Machine)and a stripped-down dialect of MDL called ZIL(Zork Implementation Language).
Clojure which has been mentioned here as being much more interesting than newLISP is also a LISP dialect implemented in the Java Virtual Machine…..Many fundamental similarities between the old and the new although names, purposes, and underlying data processing power are vastly different.
They seem too complicated. They take a straightforward concept and make it very complex by adding a lot of first-class features.
Has anybody used http://www.iolanguage.com/?
It is a pure OO language with a prototype based system like JavaScript. It is a really pleasure to work with!