Lush can be used advantageously for projects where one would otherwise a combination of an interpreted language like Python , Perl , Matlab , S+ , or even (gasp!) BASIC , and a compiled language like C. Lush brings the best of both worlds by wrapping three languages into one: (1) a loosely-typed , garbage-collected , dynamically scoped , interpreted language with a simple Lisp-like syntax , (2) a strongly-typed , lexically-scoped compiled language that uses the same Lisp-like syntax , and (3) the C language , which can be freely mixed with Lush code within a single program , even within a single function. It sounds complicated , but it is not. In fact , Lush is designed to be very simple to learn and easy to use.

Lush's main features are as follows:

• A very clean , simple , and easy to learn Lisp-like syntax.
  
• A very efficient native compiler (through C).
  
• An easy way to interface C functions and libraries , and a powerful dynamic loader for object files of libraries ( .o , .a and .so files) written in other compiled languages.
  
• The ability to freely mix Lisp and C in a single function.
  
• A powerful set of vector/matrix/tensor operations.
  
• A huge library of numerical routines , including GSL , LAPACK , and BLAS.
  
• An extensive set of graphic routines (including an object-oriented GUI toolkit , an interface to OpenGL , and an interface to SDL).
  
• Sound and video grabbing (using ALSA and Video4Linux).
  
• A library of image and signal processing routines.
  
• Several libraries for machine learning , neural net and statistical estimation.
  

Compared to Matlab , Lush is a "real" object-oriented programming language with data structures , typed matrices , a simple syntax , and a native compiler. Compared to Python , Lush has an efficient native compiler (compiled numerical code is as fast as C) , and the ability to practice functional programming. The ability to easily call C libraries , and the ability to freely mix C and Lisp is somewhat unique to Lush.

If at any time you have:

• wished you had simple interpreted language with which you could quickly try out ideas , implement efficient numerical algorithms , or prototype GUI-based applications.
  
• written a piece of software in C and wished you could control it from a simple , interpreted script language.
  
• written such a script language interpreter yourself and wished it were a full-blown programming language.
  
• used an interpreted script-like language , such as Perl , MatLab , Mathematica , Tcl , Python , or BASIC , and wished the compiler generated efficient code , and wished it were easier to call C routines from it.
  
• written a program with one of the above languages and wished you could generate a portable standalone application from it.
  
• wished you could combine two languages for your programming projects: an efficient , compiled , no-frills language such as C or C++ for the low-level , and an interpreted , weakly typed language with smart memory management such as Lisp for the high level and the user interface.
  

Many software projects , particularly research projects , require two languages: an efficient compiled language such as C or C++ for implementing the low-level or computationally expensive function , and a flexible , possibly interpreted language for high-level control , scripting , experimentation , and tinkering. Popular research-oriented interpreters such as Matlab are somewhat inefficient , lack support for complex data structures , lack the power of a full-fledged object-oriented programming language , and lack simple interfacing to C and other compiled languages.

Lush uses a very simple Lisp syntax. If the word "Lisp" sends shivers down your spine , be advised that the dialect of Lisp that Lush implements is extremely simple to learn , with possibly one the simplest syntax around. Most scientists , engineers , and software developers who have learned Lush have become proficient at it in a few days , even if they had no prior exposure to Lisp. It's very simple. Really. In fact , Lush has been used to teach programming to kids.

The Lush compiler has several interesting properties , and a few limitations. Its main advantage is that it generate very efficient C code which is then compiled with the best available C compiler for the machine considered.

Lush Currently runs on various Unix platforms including Linux/x86 , Solaris , and SGI/Irix.

The Lush interpreter is quite similar to some lisps of the mid 80's like "Le_Lisp" and "UCI-Lisp". It is significantly simpler than "Common Lisp" and quite different from Scheme.

An unusual feature of Lush is its compiler to C , its dynamic loader , and the ease with which one can interface existing C functions and libraries. En even more unusual feature is the ability to intermix Lisp and C source code within a single function.

The vector and matrix manipulation engine is quite powerful and efficient , making Lush ideal for heavy numerical applications and applications such as signal and image processing. It includes functions to create , resize , and convert vectors , matrices , and tensors with up to eight dimensions. It includes basic matrix operations such as scalar operations on all elements of a matrix , dot products , outer products , transposition , highly optimized 1D and 2D convolutions. A set of iterators is also provided to access all matrix elements without requiring costly bound checking.

Lush is an object-oriented language. Classes with slots and methods can be defined and compiled. Derived classes inherit the slots and methods of their parent class (similar to the C++ semantics).

Lush includes all the functions familiar to Lisp aficionados , such as list functions , list iterators , physical list manipulation , macros , splicing macros , symbol manipulation , etc , but most casual users will probably prefer to stay away from those.

Lush provides a set of simple-to-use graphic functions to draw lines , polygons , rectangles , pictures , and text in color , with automatic refresh and double-buffering capability (for simple animations). Graphics can be drawn in an X-windows window (on Unix) , or sent to a PostScript file. Those low-level portable graphic functions are used to build high-level functionalities , such as function plotting.

Lush also contains a very compact and easy-to-use object-oriented graphical user interface generator called ``Ogre''. Ogre is entirely written in Lisp on top of the low-level graphic functions mentioned above. It contains predefined classes for buttons , sliders , radio buttons , menus , string editors , etc... Ogre includes an automatic mechanism for placing objects in the window , thereby greatly simplifying the design and implementation of GUIs. Simple GUIs can be written in extremely short times and are very compact.

Lush provides two models for Input/Output. One is a set of ``Lispy'' I/O functions that allow easy input and output of ASCII data , lisp expressions , lisp objects , and matrices. It includes such goodies as pipes and sockets. The other model essentially provides access to the standard C I/O library , including fopen , popen , fprintf , fscanf , fgetc , fputc fgets , and various functions for reading and writing matrices. Large matrices can be mapped in the virtual addressing space , instead of explicitely loaded in memory. This allows to access very large datasets efficiently.

For our numerically enclined friends , Lush has a full interface to the GNU Scientific Library (GSL) , and to the LAPACK and BLAS Linear Algebra libraries. This gives access to an extensive set of numerical and statistical functions (several thousand in fact).

Lush includes a full interface to the industry-standard OpenGL library that allows the creation of 3D graphics and animations. This interface include an interface to GLUT , OpenGLU , and OpenRM (scene graph rendering engine). This makes Lush an excellent platform to write interactive VR applications and computer games.

Another popular library interfaced to Lush is the video game API Simple Directmedia Layer (SDL). It is enhanced by a high-level library that allows the easy manipulation of sprites and movable screen objects with pixel-accurate collision detection. This library , combined with Lush's simple syntax , makes it ideal for developing simple video games and for teaching programming to children.

Lush contains a library of image processing functions to load , save , resize and resample , warp , filter , and analyze images. Mathematical morphology operations such as connected component analysis , distance transform , erosion , and dilation , are also available for bitonal images. It also includes classes and functions for easily grabbing video using the Video4Linux API.

Lush includes a graph library that allows grammar and finite state machine construction , graph transduction and composition , and viterbi search algorithm.

Lush includes an extensive library for gradient-based machine learning , including neural networks , radial basis functions , support vector machines , and many others. This library is based on an innovative object-oriented design that allows to build large learning machines out of multiple learning modules and to train them cooperatively. Commercially used optical recognition systems have been built with this library.

In addition , Lush provides various interfaces to multimedia libraries , including Video4Linux (video grabbing) and ALSA (audio recording/playing).

Another unique advantage of Lisp is that it is a "programable programing language". In Lisp , a program is just a data structure that can be created and manipulated just like any other data structure. In other words , Lisp programs can create other Lisp programs. This allows users (and not just language designers) to extend the language themselves ad infinitum. This feature also makes it easy to write such things as syntax transformers , programs that optimize themselves , compilers , automatic differentiators , etc. Most users will probably stay away from writing such things , but they will profit from the work of others in these areas (the CLush compiler is an example).

The versions developed at AT&T Bell Labs , and then at AT&T Labs and at the NEC Research Institute were used to build many succesful technologies and products. The most notable ones are:

• a handwriting recognition system used by many banks across the world to read checks automatically. In fact , some ATM machines made by NCR (that can read checks) run compiled SN code on embedded DSP boards.
  
• the prototype of the DjVu image compression system.
  
• numerous machine learning algorithms developed at AT&T since 1988 , including the "LeNet" family of convolutional neural networks and some early implementations of the Support Vector Machine algorithm.
  

SN was primarily used internally at AT&T Bell Labs for many research projects in machine learning , pattern recognition , and image processing. But its various incarnations were used at AT&T Labs , Lucent , the Salk Institute , the University of Toronto , Universite of Montreal , UC Berkeley , and many other research institutions. The commercial versions of SN were used in several large companies as a prototyping tool: Thomson-CSF , ONERA , ....

Contributors include: Leon Bottou , Yann LeCun , Jie Huang Fu , Patrice Simard , Yoshua Bengio , Jean Bourrelly , Patrick Haffner , Pascal Vincent , Sergey Ioffe , and many others.

In 2001 , AT&T and Neuristique released their respective versions under the GPL , allowing the development and distribution of Lush. Turning SN into Lush was done by Yann LeCun , Leon Bottou and Jie Huang-Fu at the NEC Research Institute.

Here is a family tree of the various incarnations of SN and Lush:

SN(1987) neural network simulator for AmigaOS (Leon Bottou, Yann LeCun)
 |
SN1(1988) ported to SunOS. added shared-weight neural nets and graphics (LeCun)
 |   \
 |   SN1.3(1989) commercial version for Unix (Neuristique)
 |   /
SN2(1990) new lisp interpreter and graphic functions (Bottou)
   |   \
   |   SN2.2(1991) commercial version (Neuristique)
   |    |
   |   SN2.5(1991) ogre GUI toolkit (Neuristique)
   |   / \
    \ /  SN2.8(1993+) enhanced version (Neuristique)
     |     \
     |   TL3(1993+) lisp interpreter for Unix and Win32 (Neuristique)
     |      [GPL]
     |        \_______________________________________________
     |                                                        |
   SN27ATT(1991) custom AT&T version                          |
     |        (LeCun, Bottou, Simard, AT&T Labs)              |
     |                                                        |
   SN3(1992) IDX matrix engine, Lisp->C compiler/loader and   |
     |       gradient-based learning library                  |
     |       (Bottou, LeCun, AT&T)                            |
     |                                                        |
   SN3.1(1995) redesigned compiler, added OpenGL and SGI VL   |
     |         support (Bottou, LeCun, Simard, AT&T Labs)     |
     |                                                        |
   SN3.2(2000) hardened/cleanup SN3.x code,                   |
     |         added SDL support (LeCun)                      |
     | _______________________________________________________|
     |/
     |
   ATTLUSH(2001) merging of TL3 interpreter + SN3.2 compiler
   [GPL]         and libraries (Bottou, LeCun, AT&T Labs).
     |
   LUSH(2002) rewrote the compiler/loader (Bottou, NEC Research Institute)
   [GPL]
     |
   LUSH(2002) rewrote library, documentation, and interfaced packages
   [GPL]      (LeCun, Huang-Fu, NEC) 
     |

Here are examples of situations in which Lush (or its predecessor SN) have been used:

• as a simulation environment for neural network and machine learning experiments.
  
• as a Matlab-like prototyping tool for numerical computation, signal processing, image processing, statistical estimation,...
  
• as a "control/script language" for software projects.
  
• as a super debugger and diagnostic tool for large applications
  
• as a quick prototyping tool for GUI-based applications.
  
• as a script language for quick hacks.

  
  

Here is a small subset of the research projects that have been done with Lush:

• numerous projects in handrwiting recognition
  
• many projects in neural network, machine learning, and statistical estimations
  
• data mining, fault detection, and database marketing projects.
  
• image processing research

  
  

A few full-fledged comercial applications have been built with Lush, including:

• a complete check amount reader now integrated in NCR's automatic teller machines and large back-office check reading machines (Lush-generated code runs on DSP boards). This is a huge piece of complicated code (60,000 lines of Lush Lisp code automatically converted to C).
  
• Early version of the foreground/background segmentation module for the DjVu image compression system.
  
• a neural network simulator and neural network training tool.
  
• a pen-based data entry systems with handwriting recognition