Why is the Lisp community so fragmented?

Question

To begin, not only are there two main dialects of the language (Common Lisp and Scheme), but each of the dialects has many individual implementations. For example, Chicken Scheme, Bigloo, etc... each with slight differences.

From a modern point of view this is strange, as languages these days tend to have definitive implementations/specs. Think Java, C#, Python, Ruby, etc, where each has a single definitive site you can go to for API docs, downloads, and such. Of course Lisp predates all of these languages. But then again, even C/C++ are standardized (more or less).

Is the fragmentation of this community due to the age of Lisp? Or perhaps different implementations/dialects are intended to solve different problems? I understand there are good reasons why Lisp will never be as united as languages that have grown up around a single definitive implementation, but at this point is there any good reason why the Lisp community should not move in this direction?

It'th becauthe when they thpeak, they can't underthtand what they're thaying to each other. ;) — FrustratedWithFormsDesigner, Jan 22 '10 at 03:58
I don't think it's due to age. C is equally old, but it has a standard. — Stefano Borini, Jan 22 '10 at 04:02
C is far from equally old! Lisp is 50 years old and C is almost 40 years old. Those early 10 years were rough! — Frank Krueger, Jan 22 '10 at 04:05
C has a standard and many variants who develop extensions of that. Then there is C++, C#, Objective C, C--, BitC, D, ... — Rainer Joswig, Jan 23 '10 at 11:30
LISP has standards as well. There are two major standards (Scheme and CL). — troelskn, Jan 23 '10 at 17:47
This question should be marked as 'community wiki', since it is a question about programming culture, rather than a question about programming. — Mark Rogers, Mar 30 '10 at 18:15
Pascal, Perl, Java, C#, Python, Ruby, C and C++ are all [Algol dialects](http://en.wikipedia.org/wiki/Generational_list_of_programming_languages#ALGOL_based). Looking at that list I'd say it's more fragmented than Lisp. — Sylwester, Aug 01 '13 at 17:02
Java, Python and Ruby are basically **one-implementation languages**. They don't fragment for the same reason that, say, Gnome Terminal doesn't fragment. Also, Python **is de facto a fragmentation** of Ruby. But because they don't share a lot of syntax, they are just seen as different things. They are both actually distant Lisp dialects! So Python and Ruby are participants in the Lisp fragmentation. Moreover, Java is part of the C fragmentation. There are lots of C compilers with their own dialects. Then there is C++, ObjC, ... , and Java is a clear offshoot also. — Kaz, Dec 18 '15 at 00:54
@Kaz - Python was started years before Ruby. If anything, both are offshoots of Perl, though there is some lisp influence as well. — Justin Ethier, Dec 24 '15 at 14:25

Rainer Joswig · Accepted Answer · 2010-01-23T17:42:24.233

The Lisp community is fragmented, but everything else is too.

Why are there so many Linux distributions?
Why are there so many BSD variants? OpenBSD, NetBSD, FreeBSD, ... even Mac OS X.
Why are there so many scripting languages? Ruby, Python, Rebol, TCL, PHP, and countless others.
Why are there so many Unix shells? sh, csh, bash, ksh, ...?
Why are there so many implementations of Logo (>100), Basic (>100), C (countless), ...
Why are there so many variants of Ruby? Ruby MRI, JRuby, YARV, MacRuby, HotRuby?
Python may have a main site, but there are several slightly different implementations: CPython, IronPython, Jython, Python for S60, PyPy, Unladen Swallow, CL-Python, ...
Why is there C (Clang, GCC, MSVC, Turbo C, Watcom C, ...), C++, C#, Cilk, Objective-C, D, BCPL, ... ?

Just let some of them get fifty and see how many dialects and implementations it has then.

I guess Lisp is diverse, because every language is diverse or gets diverse. Some start with a single implementation (McCarthy's Lisp) and after fifty years you got a zoo. Common Lisp even started with multiple implementations (for different machine types, operating systems, with different compiler technology, ...).

Nowadays Lisp is a family of languages, not a single language. There is not even consensus what languages belong to that family or not. There might be some criteria to check (s-expressions, functions, lists, ...), but not every Lisp dialect supports all these criteria. The language designers have experimented with different features and we got many, more or less, Lisp-like languages.

If you look at Common Lisp, there are about three or four different active commercial vendors. Try to get them behind one offering! Won't work. Then you have a bunch of active open source implementations with different goals: one compiles to C, another one is written in C, one tries to have a fast optimizing compiler, one tries to have some middlle ground with native compilation, one is targeting the JVM ... and so on. Try to tell the maintainers to drop their implementations!

Scheme has around 100 implementations. Many are dead, or mostly dead. At least ten to twenty are active. Some are hobby projects. Some are university projects, some are projects by companies. The users have diverse needs. One needs a real-time GC for a game, another one needs embedding in C, one needs only barebones constructs for educational purposes, and so on. How to tell the developers to keep from hacking their implementation.

Then there are some who don't like Commmon Lisp (too big, too old, not functional enough, not object oriented enough, too fast, not fast enough, ...). Some don't like Scheme (too academic, too small, does not scale, too functional, not functional enough, no modules, the wrong modules, not the right macros, ...).

Then somebody needs a Lisp combined with Objective-C, then you get Nu. Somebody hacks some Lisp for .net. Then you get some Lisp with concurrency and fresh ideas, then you have Clojure.

It's language evolution at work. It is like the cambrian explosion (when lots of new animals appeared). Some will die, others will live on, some new will appear. At some point in time some dialects appear that pick up the state of art (Scheme for everything with functional programming in Lisp in the 70s/80s and Common Lisp for everything MacLisp-like in the 80s) - that causes some dialects to disappear mostly (namely Standard Lisp, InterLisp, and others).

Common Lisp is the alligator of Lisp dialects. It is a very old design (hundred million years) with little changes, looks a little bit frightening, and from time to time it eats some young...

If you want to know more, The Evolution of Lisp (and the corresponding slides) is a very good start!

It's worth pointing out that lisp is one of the oldest languages still in use today. This means that **it's had far more time than most languages to fragment**. — Dafydd Rees, Apr 17 '11 at 02:27
@KenLiu Actually, it seems Lisp source code has the same number of parentheses as some mainstream languages (e.g.: Java), yet it has less punctuation overall. — Eleno, Jan 17 '12 at 00:19
@JustinEthier - Nope. I just noticed it a day I was coding in Java, and noticed that each function call had a pair of parentheses, just like Lisp, but Java had colons and dots, which would have been missing in Lisp. — Eleno, Jan 24 '12 at 03:04
@JustinEthier - Examples: i = 0; => (setq i 0) // fun (a, b, c); => (fun a b c) // object.fun (a, b, c) => (fun obj a b c) // ` Lisp's parentheses are more visible because they are piled up, but once you get used to them, and maybe highlight them with a subtler color, then you realize there is less clutter overall. — Eleno, Jan 24 '12 at 03:11

score 14 · Answer 2 · answered Jan 22 '10 at 04:14

14

I think it is because "Lisp" is such a broad description of a language. The only common thing between all the lisps that I know is most things are in brackets, and uses prefix function notation. Eg

(fun (+ 3 4))

However nearly everything else can vary between implementations. Scheme and CL are completely different languages, and should be considered like that.

I think calling the lisp community fragmented is like calling the "C like" community fragmented. It has c,c++,d,java,c#, go, javascript, python and many other languages which I can't think of.

In summary: Lisp is more of a language property (like garbage collection, static typing) than an actual language implementation, so it is completely normal that there are many languages that have the Lisp like property, just like many languages have garbage collection.

answered Jan 22 '10 at 04:14

David Miani

14,518
2
47
66

1

Has it always been this way? Surely at the begining there was One Lisp, which then fractured (splintered? crumbled? unravelled?) into these other dialects? Or have there always been dialects? – FrustratedWithFormsDesigner Jan 22 '10 at 04:17
Yes that is true, but it is the same way the C like languages started. Initially there was only one (c obviously), then there was c++, java and all the others. This is natural, as each language does things in different ways. Eg c++ introduced objects, and java introduced memory management and the virtual machine concept. – David Miani Jan 22 '10 at 04:29
4

In the very beginning there was a single Lisp, the initial implementation. But it definitely fragmented. We have Common Lisp today specifically because of that fragmentation, it was designed to unify the splintered Lisps. That said, while things were lifted from Scheme (lexical bindings notably), Scheme was never a "part" of the pieces that inevitably made Common Lisp. For extra credit, we can discuss Lisp based Object systems. – Will Hartung Jan 22 '10 at 05:18
5

The original description of lisp was an academic paper, without an implementation or even the intention to do one. The first implementation followed very shortly, rather to the author's surprise. See the history section of the wikpedia article. – dmckee --- ex-moderator kitten Jan 22 '10 at 17:21
4

python is "C like"? surly not :S – AnnanFay Jun 07 '10 at 19:51
C, C++ - I can understand, even thought those are totally different languages, but C++ supports C subset. But how C++ got with Java and C# into the same list??? – Feb 16 '11 at 02:20
If `fun` and `+` aren't tokens denoting symbol objects, which refer to functions or operators via bindings in an environment, and if the whole thing isn't a nested list structure, and if multiple occurrences of `fun` or `+` wouldn't refer to the same symbol objects, then this isn't Lisp. – Kaz Dec 24 '15 at 18:04

Frank Krueger · Answer 3 · 2010-01-22T04:10:32.087

I think it's because Lisp was born out of, and maintains the spirit of the hacker culture. The hacker culture is to to take something and make it "better" according to your belief in "better".

So when you have a bunch of opinionated hackers and a culture of modification, fragmentation happens. You get Scheme, Common Lisp, ELISP, Arc. These are all pretty different languages, but they're all "Lisp" at the same time.

Now why is the community fragmented? Well, I'll blame time and maturity on that. The language is 50 years old! :-)

score 9 · Answer 4 · answered Jan 22 '10 at 05:08

Scheme and Common Lisp are standardized. SBCL seems like the defacto open source lisp and there are plenty of examples out there on how to use it. It's fast and free. ClozureCL also looks pretty darn good.

PLT Scheme seems like the defacto open source scheme and there are plenty of examples out there how to use it. It's fast and free.

The CL HyperSpec seems as good as the JavaDoc to me.

As far as community fragmentation I think this has little to standards or resources. I think this has far more to do with what has been a relatively small community until recently.

Clojure I think has a good chance to become The Lisp for the new generation of coders.

Perhaps my point is a very popular implementation is all that is required to give the illusion of a cohesive community.

score 8 · Answer 5 · answered Jan 22 '10 at 04:27

8

LISP is not nearly as fragmented as BASIC.

There are so many dialects and versions of BASIC out there I have lost count.

Even the most commonly used implementation (MS VB) is different between versions.

answered Jan 22 '10 at 04:27

James Anderson

27,109
7
50
78

Good point, although on the MS side each new version is meant to replace the old one. Of course this has the effect of orphaning projects using an old version of BASIC, so you will still see posts about VB6, for example. Are there any dialects/versions of BASIC still actively used outside of the MS implementations? – Justin Ethier Jan 22 '10 at 14:26
3

This answer doesn't address the question. – Ken Liu Feb 20 '10 at 06:11
@Justin Ether 'Are there any dialects/versions of BASIC still actively used' -- its widely used in the DEC/VMS sites that survived the various takeovers and mergers plus there are serveral commercial products that have some sort of built in basic interpreter (e.g. IBM/Ascential DataStage) – James Anderson Feb 22 '10 at 01:48
1

@ken lui, while my comment does not directly answer the question it does provide addition data. i.e. Lisp is not the only language that is fragmented, which may help answer the posters question – James Anderson Feb 22 '10 at 01:51

score 4 · Answer 6 · answered Jan 23 '10 at 02:20

The fact that there are many implementations of Common LISP should be considered a good thing. In fact, given that there are roughly the same number of free implementations of Common LISP as there are free implementations of C++ is remarkable, considering the relative popularity of the languages.

Free Common LISP implementations include CMU CL, SBCL, OpenMCL / Clozure CL, CLISP, GCL and ECL.

Free C++ implementations include G++ (with Cygwin and MinGW32 variants), Digital Mars, Open Watcom, Borland C++ (legacy?) and CINT (interpreter). There are also various STL implementations for C++.

With regards to Scheme and Common LISP, although admittedly, an inaccurate analogy, there are times when I would consider Scheme is to Common LISP what C is to C++, i.e. while Scheme and C are small and elegant, Common LISP and C++ are large and (arguably) more suited for larger applications.

score 4 · Answer 7 · answered Jan 17 '12 at 00:33

Having many implementations is beneficial, because each implementation is optimal in unique places. And modern mainstream languages don't have one implementation anyway. Think about Python: its main implementation is CPython, but thanks to JPython you can run Python on the JVM too; thanks to Stackless Python you can have massive concurrency thanks to microthreads; etc. Such implementations will be encompatible in some ways: JPython integrates seamlessly with Java, whilst CPython doesn't. Same for Ruby.

What you don't want is having many implementations which are incompatible to the bone. That's the case with Scheme, where you can't share libraries among implementations without rewriting a lot of code, because Schemers can't agree on how to import/export libraries. Common Lisp libraries, OTOH, because of standardization in core areas, are more likely to be portable, and facilities exist to conditionally write code handling each implementation's peculiarities. Actually, nowadays you may say that Common Lisp is defined by its implementations (think about the ASDF package installation library), just like mainstream languages.

I wrote a Lisp application which is compiled to a Windows executable using Clozure Common Lisp (CCL, formerly MCL). The application has a licensing back end which runs on a Debian server, which runs under CLISP. They have Lisp code in common, and use common libraries. The same crypto library and whatnot. — Kaz, Dec 24 '15 at 18:12

score 3 · Answer 8 · answered Jan 23 '10 at 18:17

Two possible contributing factors:

Lisp languages aren't hugely popular in comparison to other languages like C/C++/Ruby and so on - that alone may give the illusion of a fragmented community. There may be equal fragmentation in the other language-communities, but a larger community will have larger fragments..

Lisp languages are easier than most to implement. I've seen many, many "toy" Lisp implementations people have made for fun, many "proper" Lisp implementations to solve specific tasks. There are far more Lisp implementations than there are, say, Python interpreters (I'm aware of about.. 5, most of which are generally interchangeable)

There are promising projects like Clojure, which is a new language, with a clear goal (concurrency), without much "historical baggage", easy to install/setup, can piggyback on Java's library "ecosystem", has a good site with documentation/libraries, and has an official mailing list. This pretty much checks off every issue I encountered while trying to learn Common Lisp a while ago, and encourages a more centralised community.

mathk · Answer 9 · 2019-03-13T09:02:32.830

3

My point of view is that Lisp is a small language so it is easy to implement (compare to Java, C#, C, ...).

Note: As many comment that it is indeed not that small it miss my point. Let me try to be more precise: This boll down to the entry point price. Building a VM that compile some well know mainstream language is quit hard compare to building a VM that deal with LISP. This would then make it easy to build small community around a small project. Now the library and spec may or may not be fully implemented but the value proposition is still there. Closure it a typical example where the R5RS is certainly not in the scope.

edited Mar 13 '19 at 09:02

answered Aug 07 '10 at 12:20

mathk

7,973
6
45
74

Good point, especially with regard to Scheme. – Justin Ethier Aug 07 '10 at 13:44
3

... although I will say that to implement everything for a Lisp - even Scheme R5RS - is probably not as small or easy as you think. – Justin Ethier Jan 23 '12 at 21:51
2

of course not, there is many trap you could get into, but compare to C++ Java and stuff like this... – mathk Jan 25 '12 at 09:01
@JustinEthier Indeed, and on top of that you have SRFI's. – Kaz Dec 24 '15 at 18:07
1

Common Lisp's standard is still larger than that of C, by raw page count, though C is catching up. – Kaz Dec 24 '15 at 18:08
Common Lisp has by far the biggest spec of all existing languages. A conforming implementation needs to provide a huge stdlib, which is about 10x bigger than most other stdlib's. It's a huge language. The only bigger spec might be the latest Ada/Spark. – rurban Mar 13 '19 at 06:47

Why is the Lisp community so fragmented?

9 Answers9

Linked

Related