In: computer, programming, language.

LISP (programming languages)

Appeared: 1958
Typing: dynamic, strong

And anyway, the subject line presupposes that Lisp has not caught on. This is like saying that astrophysics or calculus or brain surgery has not caught on because in relative numbers, there might be more people doing other things. The success of Lisp is not measured in the number of people using it, it’s measured in the utility to those people who do use it. Turning it into C (or C++ or C#) to make it more popular would not be success. In the world’s menu of computer language options, we don’t need them all to be Taco Bell.
– Pitman’s Assessment of Lisp’s Success

Common Lisp

See Common-LISP page.

Scheme

See Scheme-LISP page.

Medley Interlisp

Many of the functions have different names and arguments compared to Common Lisp, Interlisp has many other, more fundamental, differences from Common Lisp.
Like Common Lisp but unlike Scheme, Interlisp is a LISP-2 language. This means, in part, that the namespace for variables is separate from the namespace for functions.
https://github.com/Interlisp/medley

Fennel

Fennel is a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.
Any library or tool that already works for Lua will work just as well for Fennel.
The two main platforms for making games with Fennel are TIC-80 and LÖVE.

https://fennel-lang.org
https://love2d.org – LÖVE is a game-making framework for the Lua programming language
https://tic80.com – TIC-80 is software that acts as a simulated computer in which you can write code, design art, compose music, and lay out maps for games

Janet

Janet is a functional and imperative programming language.
The entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB.
You can also add Janet scripting to an application by embedding a single C source file and a single header.

https://janet-lang.org
https://github.com/janet-lang/janet

Hy

A dialect of Lisp that’s embedded in Python.
Since Hy transforms its Lisp code into Python abstract syntax tree (AST) objects, you have the whole beautiful world of Python at your fingertips, in Lisp form.
Hy is a Lisp-1 because Python functions use the same namespace as objects that aren’t functions.
In general, any Python code should be possible to literally translate to Hy.

https://docs.hylang.org
https://github.com/hylang/hy
https://docs.hylang.org/en/master/cheatsheet.html

Zygomys

Zygo is a LISP interpreter written in Go-lang.
A dialect of LISP that contains significant built-in infix syntax support, making it exceptionally easy to read.
Zygomys allows you to create a Domain Specific Language to drive your program with minimal fuss and maximum convenience.
It is designed as an embedded extension language for Go. It is implemented in pure Go as a bytecode interpreter.

https://github.com/glycerine/zygomys

LIPS

Scheme based powerful LISP interpreter written in JavaScript.
Based on the Scheme dialect and the R5RS/R7RS specifications. It has extensions to make it easier to interact with JavaScript.

https://lips.js.org
https://github.com/jcubic/lips

FemtoLisp

A lightweight, robust, Scheme-like Lisp implementation.
Femtolisp is about 150kb, is very self-contained and it’s fast, ranking among the fastest non-native-compiled Scheme implementations.

https://github.com/JeffBezanson/femtolisp

TinyLisp

Lisp in 99 lines of (obfuscated) C code (and other, larger versions).
Despite being small, these tiny Lisp interpreters in C include 20 built-in Lisp primitives, garbage collection and REPL, which makes them a bit more practical than a toy example.
Tinylisp can run on a vintage Sharp PC-G850VS pocket computer.

https://github.com/Robert-van-Engelen/tinylisp
https://github.com/Robert-van-Engelen/tinylisp/blob/main/tinylisp.pdf

SectorLISP

The SectorLISP project has achieved its goal of creating a LISP that’s tiny enough to fit in the master boot sector of a floppy disk.
To the best of our knowledge, this is the tiniest LISP to date.

https://justine.lol/sectorlisp
https://justine.lol/sectorlisp2
https://github.com/jart/sectorlisp

LISP500

A mostly-joking implementation of a lisp in just 500 lines of (obfuscated) C.
https://github.com/tkalvas/lisp500

MiniLisp

A readable lisp in less than 1k lines of C.
https://github.com/rui314/minilisp

FE

A tiny, embeddable language implemented in ANSI C.
https://github.com/rxi/fe

Tools

Check and transform Lisp code with Comby

https://github.com/vindarel/colisper

Articles & questions

Features of Common Lisp ⭐

By Abhishek Reddy, updated 2008-08-29
This is AWESOME!!
http://random-state.net/features-of-common-lisp.html

An Intuition for Lisp Syntax

https://stopa.io/post/265 ⭐
Risp (in (Rust) (Lisp))
https://stopa.io/post/222 ⭐
LLisp: Lisp in Lisp
https://stopa.io/post/292
Macros by example:
https://stopa.io/post/229

A road to Common Lisp

By Steve Losh, August 27th, 2018
https://stevelosh.com/blog/2018/08/a-road-to-common-lisp

Is LISP fast?

https://quora.com/What-is-the-fastest-Lisp-implementation
CMUCL and SBCL have the most analyses and optimization, which means they are best at manipulating and allocating machine sized data. Typically this means they’ll be best at raw floating point numerical performance.

Python for Lisp Programmers

By Peter Norvig, May 2000
http://norvig.com/python-lisp.html
Take a Lisp program, indent it properly, and delete the opening parens at the start of lines and their matching close parens, and you end up with something that looks rather like a Python program.

Python VS Common Lisp, workflow and ecosystem

https://lisp-journey.gitlab.io/pythonvslisp

Why is LISP used so little in spite of the fact that it is often acclaimed as one of the best programming languages?

https://quora.com/Why-is-LISP-used-so-little-in-spite-of-the-fact-that-it-is-often-acclaimed-as-one-of-the-best-programming-languages

Proficient Lispers invent sub-languages for the simplest of domains and their programs are a very elegant collection of very high-level abstractions created in special purpose languages. In my experience, this is not true in any other language. The mastery of proficient Lispers over the language is so deep that novices can stare at the code for days before understanding what is going on. Indoctrinating a new Lisper into the language is a tall order.
What ends up happening is that the band-gap between novice-ness and proficiency becomes very high and very few programmers actually cross the gap. Those that do either do so because they love it, or because they are forced to.
Unfortunately, this gives rise to a bit of an ivory-tower mentality, which further increases the perception of the band-gap, consequently attracting fewer people to the language.
– Anurag Mendhekar

The single biggest factor in language adoption is how good are the existing libraries. And libraries for LISP-like languages haven’t been even close to libraries of languages like Java, for a long time.
So, it may very well be that LISP lets you write more elegant code. But, Java lets you get away with not writing the code at all because other people wrote it for you. And no code beats elegant code.
– Radu Grigore

Where does Lisp come in? To say that Lisp “makes it easy” to write code that writes code, is a sin. It’s like saying automobiles “make it easy” to get to work. There’s such a huge difference between walking to work and taking a machine, that using that phrase doesn’t make much logical sense. Lisp makes it natural to write code that writes code. […]
You see in Lisp, this transpiler nonsense doesn’t need to exist. In fact, entire programming languages like Dart, Elm, and TypeScript don’t need to exist if all programming languages were actually equal and JavaScript truly had the powers of Lisp.
Literally everything that’s been added to JavaScript over the years, including things like optional arguments in functions, you could have added that yourself if JavaScript had the power of LISP.
You can’t tell me that you don’t need or want any new features, because if that were true, there would be no updates to the languages you use.
So yes, all programming languages have been copying LISP for decades and continue to do so today. But the reason why they copy LISP is because people see the power of the language and have tried, quite unsucessfully so far, to bring that power to their own languages, yet always forgetting the one thing that really matters.
We call em macros by the way.
– Max Thompson

If LISP is such a great language then why isn’t it used more in software development?

https://quora.com/If-Lisp-is-such-a-great-language-then-why-isnt-it-used-more-in-software-development

Some people believe Lisp is great. The vast majority of developers, however, have never heard of it. Even a lot of university researchers in computer science and software engineering have no idea what Lisp is, so it doesn’t get taught or discussed much. And a lot of software practitioners, computer science researchers and software engineering researchers do not actually believe that programming language matters; it’s a very common opinion that languages are just a matter of personal preference. People who believe that (and there is not much evidence to dissuade them) have no reason to invest any effort in learning a second language if they have a good grasp of one already.
And learning a second programming language is even harder than learning the first one, so most people just do not do it. Or they limit their study to extremely similar languages and then reach the logical conclusion that language choice doesn’t matter and language zealots are just nuts.
(…)
Note that nothing in this answer is specific to Lisp; it also applies to Haskell, OCaml, etc. Basically technology choices, in a broad sense, are a result of a lot of social and historical factors, personal preferences, and branding and marketing. Technical merits play a very small role in overall popularity.
– Gary Verhaegen

The way software development shops are organized doesn’t allow for languages like LISP, because to do well in it, you have to be a good programmer, and you have to understand some advanced programming concepts. You have to understand its power, and how it’s expressed. I’ve heard it said that two really good, star programmers can match the achievement of 20 mediocre programmers. The problem is it’s hard to find star programmers. Managers who have worked with such programmers have to ask themselves, “What if they leave? What if something happens to them?” Whereas if they encode everything in a simpler, clunkier, though easier language to understand, they can hire from a much larger pool of developers. Then they don’t have to worry so much about how to replace them, if need be, and they can pay them less. Another perceived benefit I’ve heard about is that if the software requires help desk support, you’re more likely going to find people who are ready and skilled in doing that among the ranks of mediocre developers than with star developers.
The former approach (the two star developers) emphasizes doing more with less code, where the artfulness of the implementation translates directly into productivity gains. The latter approach (20 mediocre developers) emphasizes bureaucratic control over process, which supports the continuation and expansion of the enterprise, at least in the IT department, regardless of realized risks. The former is a more optimistic, though risky approach. The latter is a more pessimistic, security-conscious approach.
– Mark Miller

Why is Lisp not as popular as Python?

https://quora.com/Why-is-Lisp-not-as-popular-as-Python

Python appeals to most people’s familiar sense of ergonomic and esthetic. That’s why it is more popular. Looks matters, and popularity almost always depends on look and charisma.
Capabilities are the technical aspects of a language. Things like the runtime performance, memory use, the platform it can run on, how much of the hardware it can leverage and how effectively can it leverage it, like can it use the GPU, can it run with massive heaps, can it make use of all cores, etc.
Ergonomics is the study of people’s efficiency in their working environment. Just how productive and efficient are you when using the programming language. This is very important for popularity, but it is also highly dependent on who the person is, and how much experience they have with the language or its concepts. Most people have little to no experience with Lisps and its concept. Even simple things like infix operations is something most people have no prior experience. So I think Python will seem more ergonomic to more people, as they come to it with already some prior experience in its concepts.
Esthetics is the last dimension, and the most relevant one in this case. It means the concern with beauty one has. This dimension is also somewhat personal, everyone will have grown to have different appreciation of beauty and what is beautiful or isn’t. In my opinion, the Python syntax is more aesthetically pleasing to most people. It has more breathing room, it is more symmetrical, there is less visual chaos, it uses characters people are used too when reading literature.
The thing about esthetic, is that it too can change. A person’s own sense of aesthetics can change. Mine did, I used to loathe the look of Lisps, and love the look of Python. And I did in fact pick up Python over Lisps simply due to this. Always indented, no weird characters, white-space between everything, full english words instead of symbols, etc.
My tastes have changed over time though, and just like I didn’t like coffee at first, and later only liked drip coffee with lots of sugar in it, but eventually got super into specialty coffee, so did I slowly progressed towards Lisp. I like to think of Lisp like a specialty programming language, in the same vein as specialty coffee.
And that’s why I believe Python is more popular than Lisp.
– Anonymous

Popularity is really hard to understand. I suspect the biggest factor holding back Lisp popularity is unfamiliarity. First, the syntax, with Lots of Incomprehensible Silly Parentheses does put some people off. Which is a shame, because LISP actually has the simplest syntax of any language I know, and you adapt to it pretty quickly. Second, because of LISP’s Homoiconicity and its powerful macro system, LISP does some things differently than other languages.
– Peter Schachte

Learn

Podcasts

Awesome

References

×