LIlispm·May 12, 2018
> I think lisp did (to a lesser extent still do) suffer from the "whole system syndrome
There are a bunch of problems of Lisp for systems/application programming:
* dynamic typing and dealing with runtime errors
* garbage collection vs. real-time response
* amount of memory used is usually higher for GCed systems
* interoperability with C code and code in other languages
* abstraction mismatch between C code and Lisp code.
* the need for a foreign function interface to inter-operate with C code
* the integration with C++
* the minimum size of a program and how many programs can be started
* sharing much of the runtime and library
When people started to write lots of Lisp code (80s) then the question of delivery came up. The were a bunch of responses to that:
* don't run systems and applications in Lisp,
for exampl
Read the rest
e rewrite the Lisp applications into C++
(smaller footprint, possibly faster execution, ...)
* develop new Lisp-like programming languages,
but which are more efficient to implement.
Example: Apple's Dylan or see Dynace ( https://github.com/blakemcbride/Dynace )
* develop special Lisp implementations which address
the above issues and are specialized in application
delivery
Let's look at the latter approach.
Germany had for example the Apply project which for example created the CLICC compiler ( https://www.informatik.uni-kiel.de/~wg/clicc.html ). CLICC is a whole-program compiler for a restricted subset of Common Lisp. mocl is based on CLICC and was/is a commercial CL compiler for macOS X, Android and iOS.
There are a bunch of similar compilers (Thinlisp is one https://www.cliki.net/ThinLisp ). Many years ago Oracle also bought an Lisp compiler (which was very expensive for users, IIRC in the range of $100k), which actually generated 'maintainable' C code.
Another interesting system is WCL: https://github.com/wadehennessey/wcl
WCL allows one to use Common Lisp as a shared library (mostly). Each Lisp application starts with tiny RAM usage and tiny application size. This allows to run possibly hundreds of smallish Lisp applications at the same time.
Eclipse was a Common Lisp which has a direct integration in C and compilation to C, which made something like a Foreign Function interface unnecessary: https://github.com/blakemcbride/eclipse-lisp
Generally these tools are often 'old', not widely used and not many applications have been written with them.