[PLUG-TALK] Any lispers out there? Newbie needs booster shot

[Russell Senior]

>>>>> "Renegade" == Renegade Penguin <renegadepenguin at comcast.net> writes:

Renegade> [...] In other words, LISP is much less fault-tolerant.  If
Renegade> you're missing a single parentheses or have one too many,
Renegade> your app won't compile properly if at all.

This is an idiotic criticism.  If you leave out a semi-colon in a C
program it won't compile either.  Lisp editors (like Emacs and others)
make leaving out a parenthesis just about impossible, and anyway,
easily corrected.

One of the primary things Lisp gives you is leverage.  It lets one
person develop things that take armies of programmers in other
languages.  There are some engineering tradeoffs for this.  Automatic
memory management doesn't come for free, nor does its dynamic typing,
but for many things it is well worth the cost.  The REPL, from a
development point of view, is a huge win.

Here's a summary of features from one of the two bigger commercial
Common Lisp vendors:

   <http://www.lispworks.com/products/lisp-overview.html>

   Common Lisp Language Overview

   Common Lisp has long been the leading language for software
   research and advanced development projects. Its ability to tackle
   the biggest problems is unmatched.

   Common Lisp is rich in data types, supported by a high-level
   language model and garbage collection. In Common Lisp, all data are
   represented as objects. There are no out-of-language errors. This
   model encourages a high-level view of programs and an exploratory
   programming process that make Lisp programmers among the most
   productive in the world. Evidence for this is presented in Erann
   Gat's paper Lisp as an Alternative to Java.

     <http://www.flownet.com/gat/papers/lisp-java.pdf>

   Common Lisp has grown and evolved over time, acquiring features and
   supporting paradigms as they've entered the world of computer
   science. It is now supported by an ANSI standard (ANSI
   X3.226:1994). This standard includes the Common Lisp Object System
   (CLOS); features like multimethods and dynamic class redefinition
   make CLOS among the most advanced object systems in the world.

   Among the most important features of Common Lisp are:

       * Machine-independent language model. All operations are
         performed in terms of program objects, not raw bits.

       * Iterative design process. Common Lisp supports exploratory
         programming, making programmers more productive.

       * Dynamic patching. Common Lisp programs can be updated while
         they are running. The ability to install field patches
         without interrupting service is important for many
         mission-critical applications.

       * High-level debugging. All debugging is performed within the
         language model, preventing system crashes and other
         out-of-language errors.

       * Common Lisp Object System (CLOS). Common Lisp provides
         advanced object-oriented programming, including multiple
         inheritance, multimethods, class redefinition in running
         programs, and dynamic type creation. No other language
         provides an object system so rich in features.

       * First class functions and classes. First class higher-order
         functions provide control systems that are elegant and
         powerful.

       * First class classes let you manipulate the object system in
         running programs, giving you finer degrees of control.

       * Extensive data types. Objects, structures, lists, vectors,
         adjustable arrays, hash-tables, and symbols are just a few of
         Common Lisp's myriad data types.

       * Advanced numeric types. The Common Lisp arithmetic package
         includes unlimited size integers, fractions, complex numbers,
         and a complete floating point library. Conversion between
         numeric types occurs automatically.

       * Complete IO library. Common Lisp includes a portable
         interface for streams, the file system, and other IO
         facilities.

       * Extensive control structures. Complex looping, guard
         expressions, non-local transfer of control and lexical
         closures are among the control structures offered by Common
         Lisp.

       * Condition system. The Common Lisp condition system is
         object-based, and supports recovery as well as escape from
         errors and other exceptional situations.

       * Consistent syntax. Common Lisp uses a simple consistent
         syntax that is easy to learn and easy to use from day one.

       * Macros. A convenient macro system lets Common Lisp
         programmers create embedded languages, essentially turning
         their Lisp environment into a domain-specific problem solving
         tool.

       * Programs as data. Common Lisp is a fully reflective language,
         supporting genetic algorithms, evolutionary programming, and
         other self-referential programming techniques.

       * Late-bound types. By leaving type declarations to the
         programmer's discretion, programs can be simpler and
         prototyping faster. 


   For more information on Common Lisp, see our Community pages.

There are some anti-features as well.  The free Common Lisps don't
support multithreading (there are some free Schemes that do, though).
Lisp doesn't always play nicely with others, e.g.: it is harder or
uglier to link in foreign functions from C or Fortran; and I/O can
sometimes be inefficient (basically a matter of getting raw data into
and out of Lisp types).

I have never regretted learning or using Common Lisp.


-- 
Russell Senior         ``I have nine fingers; you have ten.''
seniorr at aracnet.com