The advantages of Lush are especially significant on projects where a combination of an interpreted language (e.g.Python, Perl, Matlab, S+, or even [gasp!] BASIC) and a compiled language (e.g. C) would otherwise be used. With Lush the best of both the interpreted and compiled programming worlds are obtained 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 with the same Lisp-like syntax;
  
• 3. the C language, which can be freely mixed with Lush code within a single program or within a single function.
  

It sounds complicated, but it is not. In fact, Lush is designed to be very simple to learn and to use.

The main features of Lush include:

• 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, combined with a powerful dynamic loader for the 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, and tensor operations;
  
• a huge library of numerical routines, including GSL, LAPACK, and BLAS;
  
• an extensive set of graphics routines (that includes an object-oriented GUI toolkit and interfaces to OpenGL and SDL);
  
• sound and video grabbing (via ALSA and Video4Linux);
  
• a library of image and signal processing routines;
  
• several libraries for machine learning, neural networks, and statistical estimation.
  

This combination of flexibility, efficiency, and extensive libraries makes Lush an ideal platform for research and development in artificial intelligence, bio-informatics, computer vision, data mining, image processing, machine learning, signal processing, and statistics, Its speed and extensive libraries allow it to be applied to areas such as real-time audio, image, and video processing. Many users put Lush to work as a general purpose scripting language or as their main language for application development. Some users are known to have used Lush to develop 2D and 3D games. A few have even used Lush to develop commercial software for embedded processors.

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

If at any time you have:

• wished you had a 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 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 that it were easier to call C routines from it;
  
• written a program with scripting languages, like the ones previously mentioned, and wished you could generate a portable standalone application from it;
  
• or 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 implementation, and an interpreted, weakly typed language with smart memory management, such as Lisp, for the high level implementation and user interface.
  

then Lush is for you!

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 functions, and a flexible (possibly interpreted) language for high-level control, scripting, experimentation, and tinkering. Popular research-oriented interpreters like Matlab are somewhat inefficient, have little or no support for complex data structures, do not provide the power of a full-fledged object-oriented programming language, and lack simple interfacing functionality to C and other compiled languages.

The syntax of Lush is a simple form of Lisp. 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 one of the simplest syntaxes possibly available. Most scientists, engineers, and software developers who learn Lush become proficient with it in just a few short days, even if they have 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 generates very efficient C code that is compiled with the best available C compiler for the machine under consideration.

Lush currently runs on various Unix platforms including: Linux/x86, Solaris, and SGI/Irix. It can also be run on Mac OS X and Windows (under Cygwin).

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

Some unusual features of Lush are its compiler to C, dynamic loader, and the ease with which interfacing to existing C functions and libraries can be accomplished. A particularily unusual feature is the language facility it provides to intermix Lisp and C source code within a single function.

The vector and matrix manipulation engine is quite powerful and efficient. This makes Lush ideal for computationally demanding numerical applications and signal and image processing. Functions are included to create, resize, and convert vectors, matrices, and tensors with up to eight dimensions. Basic matrix operations such as scalar operations (on all elements of a matrix), dot products, outer products, transpositions, highly optimized 1D and 2D convolutions are, of course, included. A set of iterators is also provided to access any matrix element without requiring costly bounds checking.

As an object-oriented language, Lush provides the ability to define and compile classes with slots and methods, and for derived classes to inherit the slots and methods of their parent class (similar to C++ semantics).

All the functions familiar to Lisp enthusiasts are included in Lush. These include: list functions, list iterators, physical list manipulators, macros, splicing macros, symbol manipulators, and so on. Most casual users will probably prefer to stay away from some of the more complicated of these.

A set of simple-to-use graphics functions are supplied 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 system window (on Unix) or sent to a PostScript file. The low-level portable graphics functions provided are used to build high-level functionalities, such as function plotting.

There is also a very compact and easy-to-use object-oriented graphical user interface (GUI) generator called Ogre that comes with Lush. Ogre is entirely written in Lisp on top of the low-level graphics functions mentioned above. It contains predefined classes for buttons, sliders, radio buttons, menus, string editors, and so forth. Ogre includes an automatic mechanism for placing objects in a 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 and output. One is a set of Lisp-oriented functions that allows easy input and output of ASCII data, lisp expressions, lisp objects, and matrices. It includes goodies such 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. With these functions large matrices can be mapped into the virtual addressing space, instead of being explicitely loaded into memory. This allows efficient access of very large datasets.

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

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

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

An image processing library with functions to load, save, resize and resample, warp, filter, and analyze images is also at the users disposal. Mathematical morphology operations such as connected component analysis, distance transform, erosion, and dilation, are also available for bitonal images. Classes and functions for easily grabbing video using the Video4Linux API is included also.

Another included library provides graph functionality 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 facilitates the construction of large learning machines from multiple learning modules and cooperative learning machine training. 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).

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

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

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

• numerous handrwiting recognition projects
  
• many projects in neural networks, machine learning, and statistical estimation
  
• datamining, fault detection, and database marketing projects
  
• image processing research
  

A few full-fledged commercial applications have also 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)
  
• an 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 system with handwriting recognition
  

In some segments of the software industry Lisp is sometimes perceived as an oddity of essentially academic interest. Its theoretical computer science heritage also causes common misconceptions about Lisp, such as it being inefficient and difficult to learn. So why choose Lisp? We chose Lisp because, contrary to the common prejudice, it is extremely easy to learn, in addition to being flexible, efficient, and compact. Lisp has such a simple, clean, and flexible syntax that it is probably the easiest language to learn (in contrast, Perl is found at the other extreme). Our experience with teaching C developers to use Lush is that they become proficient with it in a few days. Script language designers often make the mistake of not only designing their own language functionalities, but also of designing their own syntax. Examples of this include MatLab, Mathematica, S+, and many others. Why invent a new syntax when a good one such as Lisp already exists? Lush is just such a language, it is an object-oriented dialect of Lisp that puts the emphasis on ease of use, efficiency for numerical operations (unlike many traditional Lisp implementations), and close to effortless interfacing with existing code written in C.

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 without limit. This feature also makes it easy to write such things as syntax transformers, self-optimizing programs, compilers, automatic differentiators, etcetera. Most users will probably stay away from writing such things, but they will profit from the work of others in these areas (e.g. the CLush compiler).

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 automatically read checks. 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 de 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) 
     |