I’ve had a long-term love affair with Lisp:

• Expressing myself in diverse and brilliant Lisp languages and dialects
  • especially the most elegant, consistent and general Lisps
• Exploring the programming techniques and paradigms that Lisp enables
  • functional programming, macro programming, metaprogramming
• Using the powerful programming tools available for a homoiconic language
• Studying the fascinating aspects of Lisp implementation:
  • representation, interpretation, compilation and runtime system support
• and all other aspects of Lisp

/This repository is intended to be a gateway to a lot of important materials, linked by the documents here. If you explore these materials, please share your experience, through direct communication, by posting Issues, or etc. Please suggest improvements!/

I recommend learning Lisp using

• the first Modules
• of the Computing Magic Curriculum!

lisp-simplicity.org – Lisp is Really Simple!

lisp-systems.org – Foundations of Lisp

lambda-sugar.rkt – Lambda and Syntactic Sugar

vis-mce.rkt – a Meta-Circular Evaluator in Racket

Lisp was originally inspired by the Lambda Calculus introduced by Alonzo Church in the 1930s. Lisp systems have always been an attempt to harness the elegance of the mathematical theory of computing along with ad hoc features that seemed like helpful additions for practical programming. As the understanding of Lisp systems has matured, newer Lisp systems have been able to discard a lot of those ad hoc additions and much of the complexity of earlier Lisp systems by a better realization of its formative principles, yielding an improvement in both expressivity and efficiency.

Lisp is not the only family of languages which have this kind of elegance and this closeness to mathematics. The pure Functional Programming langauges such as Haskell and the rest of the ML family have it. The Logic Programming languages, including the Prolog family, Mercury and Curry have it. Mercury and most Prolog systems also share Lisp’s homoiconicity.

And some of the most wonderful programming languages either do not have quite as much expressivity as Lisp or as much mathematical purity yet have great riches to teach the explorer.

Some other awesome mathematically-based languages are the Array Processing Languages including of Apl, J and K. They are the most powerful tools for certain kinds of problems and the way of thinking you learn by using them is invaluable.

Some more awesome languages which are less mathematically inspired yet have similar power-to-weight ratios include the Smalltalk family and the Forth family. Object-Oriented Programming has gotten some bad press lately. Smalltalk will show you how wonderful it can be!

All of these languages are Turing complete, so you should be able to express any algorithm in any one of them, but not always elegantly or “naturally”. Many powerful computational approaches would be more likely to occur to a programmer when thinking in one language versus another one. Much (but not all) of this has to do with how much a language is tied to specific Programming Paradigms. Languages which introduce you to new ways of thinking about computing increase your programming power - which then becomes available to you in all other languages, but especially in Lisp.

Lisp especially rewards the explorer because of Lisp’s malleability. After learning a new way of expressing computation in another language, it will invariably be possible to use that new power of expression naturally in Lisp, perhaps assisted by some choice macros! Racket takes this to an extreme by allowing for the definition of new languages which can introduce radically new features such as static typing and allowing you to express different parts of a program in different languages!

It is often not enough for a language to be highly expressive. If it’s going to support practical projects and especially the building of new tools it needs to be efficient. Lisp has proved itself in this regard better than any other single language. While vastly more expressive than C, the poster child for low-level efficiency on conventional compuers, there are compilers for Common Lisp and for Scheme that are approximately as efficient as C.

A famous series of papers by the designers of Scheme, one of the simplest Lisps, show that Lisp Systems can support all of the data structures and control structures of any competing languages, including powerful features which were rare or non-existent among other languages of the time. Since then, many popular languages have added features in imitation of Scheme, but without the same elegance. Those papers are still an excellent read!