A Look at newLISP

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.


  1. 2009-01-05 7:17 pm
    • 2009-01-05 7:26 pm
      • 2009-01-05 7:46 pm
      • 2009-01-05 8:09 pm
  2. 2009-01-05 8:14 pm
    • 2009-01-05 8:58 pm
      • 2009-01-06 7:15 am
        • 2009-01-06 10:33 am
        • 2009-01-06 1:55 pm
    • 2009-01-05 9:59 pm
      • 2009-01-05 10:25 pm
        • 2009-01-06 7:38 am
        • 2009-01-06 1:15 pm
    • 2009-01-05 10:30 pm
  3. 2009-01-05 8:27 pm
  4. 2009-01-05 9:22 pm
  5. 2009-01-05 11:01 pm
  6. 2009-01-05 11:13 pm
  7. 2009-01-05 11:42 pm
  8. 2009-01-05 11:42 pm
  9. 2009-01-06 12:09 am
  10. 2009-01-06 2:54 am
    • 2009-01-08 7:01 pm
  11. 2009-01-06 5:40 am
  12. 2009-01-07 10:58 am
  13. 2009-01-07 4:57 pm