
Why I like Common Lisp - lispm
http://p-cos.blogspot.com/2014/09/why-i-like-common-lisp.html
======
mck-
What I like most about Common Lisp is how it made me a better programmer. The
different paradigm of coding trains your brain in different ways which offer
perspectives on problem solving that I otherwise wouldn't have considered.

Note that for the above effect, it is irrelevant what Lisp you choose. Yes, it
also applies to learning any additional language, but because Lisp is a
different breed altogether (as opposed to Fortran-derived languages), more
value is to be had from the diversity.

I used to be a huge fan of Common Lisp (even wrote my own series of blogs on
why I love it a few years ago) -- still use it in my daily work -- but I came
to realize that it's not perfect. There are many things that Clojure has
improved upon, e.g. consistent accessor methods, shared immutable data
structures vs copying, and probably many more once I dive deeper -- there's a
reason why even pg started recommending Clojure over CL or Arc.

I've been coding in Common Lisp for about 3-4 years. Even the algorithm of my
startup is written in Common Lisp. There are definitely moments of sheer joy
when I switch back and forth between Javascript and Common Lisp. But also
moments of annoyance... sometimes certain algorithms are just more naturally
imperative, and CL makes it hard not to write recursive.

tl;dr learning a Lisp is highly recommended. It does not matter which flavour.
Or just go read SICP.

~~~
wirrbel
do you have a link/source for paul graham recommending Clojure?

~~~
juliangamble
He's said its probably your best bet:

[https://news.ycombinator.com/item?id=4487793](https://news.ycombinator.com/item?id=4487793)

------
pnathan
I love Common Lisp; I've been writing Common Lisp at home for something around
7 years. It's fast, flexible, expressive, and deeply programmable.

I won't say it doesn't have its warts: the namespacing and packaging systems
are kludgey, and the extensibility of built-in operators is poor. It's a
dynamic language to boot, which implies type derivations are often estimates
at best (painful sometimes on a poorly tested codebase).

 _But_ , Common Lisp, above all that, is an integrated development system
which allows live and fluid development. I can't stress enough that it is a
deep and joyful technology which lets me achieve more faster in it.

I only wish there were jobs in it. :-/

~~~
rusabd
[http://lispjobs.wordpress.com/](http://lispjobs.wordpress.com/)

~~~
pnathan
Not a bad feed, but...

Common Lisp has under 10 employers in the US/CA, as far as I can discern:
Clozure Associates, Grammarly, 1? 2? defense contractors in the Seattle
region, ITA (now owned by Google), a company in Colorado, D-Wave in Vancouver,
BC (Canada), and a handful of very small consulting-type shops. Occasionally
there are some university jobs that come up, usually in Boston area.

I've been monitoring things for a while, and the prospects are dim. Suppose
I'll just have to run my own business, eh? :)

------
pivo
I have never been more productive than when I'm developing with Common Lisp in
Emacs with Slime. It's a really fantastic environment.

~~~
pkaye
What exactly do you develop with Common Lisp?

~~~
mrottenkolber
I develop _everything_ (typesetting software, compilers, web server, email
client, a desktop environment just for me, a sound synthesizer, my invoice
generator, IRC bots, full blown web apps, a wiki engine and tons of general
purpose libraries) using Common Lisp. My love for the language comes
especially from the fact that its so limitless by design. I have DISASSEMBLE
and I have DEFUN. I have ETYPECASE and I have LOOP. Lacking a language
feature? Add it with ease and incredible performance.

~~~
pkaye
Are any of these software tools available as open source so I can see the
advantage of using Lisp?

~~~
malisper
Not the parent, but I recently wanted ssyntax[0] in Common Lisp, so I decided
to write an implementation for it[1]. In doing so, I created a DSL for
defining ssyntax (made up of defssyntax-test, defssyntax-macro, and
defssyntax-sym-mac). Just note that my implementation uses a library of
utilities I wrote[2] and is not pure Common Lisp.

[0]
[http://arclanguage.github.io/ref/evaluation.html](http://arclanguage.github.io/ref/evaluation.html)

[1]
[https://github.com/malisper/Clamp/blob/master/experimental/s...](https://github.com/malisper/Clamp/blob/master/experimental/ssyntax.lisp)

[2] [https://github.com/malisper/Clamp](https://github.com/malisper/Clamp)

------
TheMiller
I just find it utterly fascinating that these discussions on the merits of
(Common) Lisp still draw 100 comments within such a short time. This has been
going on for decades, in many different venues. This by itself should clue
newcomers in to the notion that the language (family) may be worth examining
in some detail. :)

~~~
johan_larson
Anyone have something better than a wild guess about whether Lisp is getting
more or less popular? It was never a very popular language in the first place,
having lost out to the spawn of Algol.

~~~
_delirium
At least in terms of the open-source community it feels much more lively now
than, say, the early 2000s. There are new books like _Practical Common Lisp_
and _Land of Lisp_ , SBCL has matured into a solid implementation, Clozure CL
was open-sourced, and Quicklisp has really improved the convenience of using
libraries. I don't know whether that translates to more popularity overall,
though.

If you mean the overall Lisp family, I think it's more clearly on an upward
swing, especially due to Clojure's popularity (and if you're willing to
stretch, Julia smuggles a Lisp-like language under cover of Matlab-like
syntax).

~~~
Tomte
Re: open source Lisp, I guess other venues than comp.lang.lisp have taken a
lot of the mindshare (the demise of Usenet).

cll was rabidly against OSS, e.g. Pitman's pure hatred for it was practically
Gospel there.

A few years ago some younger Lispers emerged, for who OSS was natural, just
like with the short Ada renaissance.

At least the "young Lispers" are still there, unlike their Ada counterparts,
even if they haven't taken over the world.

------
csdrane
Not too long ago I was researching what Lisp to learn. I contemplated Common
Lisp, but ultimately chose to learn Clojure. The latter won because the
development community seems to have more life to it. Additionally, the fact
that one can import existing Java libraries is a huge plus. Very much enjoying
everything so far.

~~~
josteink
I've dabbled in Scheme (SICP), Clojure, Elisp (Emacs) and now Common Lisp. My
opinion is that there is value in at least _looking_ at more than one. That
way you will see what compromises have been made, and how it affects your
program.

While Clojure is definitely more a in-thing right now, it's nice to see "the
originals", where it all came from. There are several things Clojure does
really well, at the cost of other aspects. It's a very opinionated language,
and for some, it may be too opinionated. I find idiomatic Clojure-code to be a
bit on the too terse side, affecting the clarity of the code.

Let's also mention the JVM. While this is often used as argument for Clojure,
it can also be an argument against it. Now your application needs a JVM to
run. That excludes my Raspberry from ever running it, unless you find 30
seconds+ startup time to be acceptable. I don't.

Looking into Scheme, you will definitely appreciate the _simplicity_ of the
language. Unlike Clojure, there's no magic behind the curtains. What you see
is what you get, and yet it's still so capable. That's quite eye-opening and
magic in its own right.

Scheme however isn't a _standardized_ language, like Common Lisp. In that
regard you cannot guarantee that what works in one Scheme-implementation works
in another. With Common Lisp you _can_ do that. And from that point of view,
it makes sense to have a good story on modules/packages. And Common Lisp has
that. In plenty.

In Clojure, with Leiningen, you can easily declare what dependencies you have
and have those fetched build-time without any extra work what so ever. Sounds
good, eh? In Common Lisp you can do that in ordinary code, runtime, even in
_the REPL_. Your code just declares what it needs, and it's there. Just stop a
second and think what that does to extensibility, when software written in CL
lets you plug your own code in.

All in all, once you know a LISP looking into others is much less work. And as
such, you should definitely check out others. Maybe there are other LISPs
which suites your needs even better? Unless you look around, you will never
know.

~~~
lispm
> Scheme however isn't a standardized language, like Common Lisp.

Scheme is a standardized language. The first standards defined a relatively
small language, also useful for teaching purposes. Then it was tried to define
a more modern Scheme with a core language and a library. The R6RS standard was
kind of controversial and now there is work for quite some time on R7RS.
Additionally the Scheme community has a process to define extensions.
Generally the landscape of Scheme is quite a bit more fragmented than the CL
landscape. The implementations can differ widely in their implemented
language. But if you look at individual systems, Scheme systems have to offer
quite a lot. Also, historically there are a several really excellent Scheme
books for learning programming and/or computer science.

This site, news.ycombinator.com , actually is written in a Lisp dialect (Arc)
running on top of a 'Scheme'.

~~~
_delirium
In practice I tend to think of Scheme as quasi-standardized, in the sense that
there is a standard core, but it's difficult to stay within it. Whereas with
standards like C99, Fortran 90, or ANSI CL, it's quite common for people to
write nontrivial standards-conforming programs that you can expect to run
unmodified across implementations. Culturally the Common Lisp community also
seems more interested in maintaining portability even when leaving the
confines of the official standard, through the heavy use of compatibility
layers like Bordeaux-Threads. The Scheme approach seems to be to just target a
specific implementation, and share functionality across them on a case-by-case
basis by porting libraries (which is sometimes trivial, and sometimes more
involved). Hence CL has Quicklisp, while Scheme has a package repository per
system.

------
yodsanklai
What are the advantages of Lisp over ML (more specifically, I know Scheme and
OCaml). My knowledge of scheme is probably incomplete, but for what I
remember, Scheme is OCaml without static typing, sum types, pattern matching,
module system. Scheme is more dynamic (dynamic types, code as data, symbols)
but i find type safety much more important (and in a language with type
inference, it comes with little overhead).

Am I missing something about Common Lisp?

~~~
davidxc
Common Lisp has macros. Paul Graham's book On Lisp is usually pointed to as
the best treatment of macros in Lisp. CL also has many more features than
Scheme, as mentioned in the other comments here.

~~~
jrapdx3
It's probably not exactly true that CL has "more features" than Scheme. That
is to say, the Scheme "core" language (well, as of R5RS) describes the
essential functionality that qualifies as Scheme, but the major
implementations have tons of additional/optional utilities, convenience
features and extensions.

The sum total is that the complexity of CL vs. Scheme may not in practice be
all that different. Take a look at newer Scheme standards, R6RS, R7RS, the
SRFI's, and implementations like CHICKEN to see what I'm referring to.

Still CL and Scheme are different languages, each has its fans. It does seem
to imply that the stuff it takes to get the job done is more or less
independent of language, whether it's included with the base language, or
contained in modules or libraries, the features need to be there somewhere in
some form.

~~~
lispm
That's basically true. The more advanced Scheme implementations (and there are
several) offer a lot of functionality.

One thing I still find true: Common Lisp has much more useful functionality in
the core. Thus the core and the libraries are often actually using them.

Example: by default Scheme has poor argument lists. Thus a lot of code does
not use keyword args and the compiler usually does not know about that.

Another example: Common Lisp has a standard object system. All implementations
support it and some use it extensively. In most extended Common Lisp much of
the libraries is using CLOS: conditions are CLOS classes, I/O is based on
CLOS, etc.

~~~
jrapdx3
Whether functionality should be contained in the "core" or in libraries is
often a subject arousing contention, but I think it is, or can be, largely a
technical distinction.

Where it matters is how well the functionality is integrated with the core
language. The argument goes that in Scheme it is less regularly the case that
libraries are complete and consistent vs. CL.

The effort of the R7RS-large work group to create a "standard" library of
extended functionality is ongoing, but in a year or two should produce a
language standard that could create consistency across Scheme implementations,
effectively similar to CL.

Of course, how well that works out depends on the willingness of implementors
of Scheme to make it so. Let's hope that they will do that.

------
TheMagicHorsey
I'm no expert, but it seems like its easier to get started with Clojure than
Common Lisp. There are tons of free Clojure resources and tutorials. There is
a great IDE that works quite well (LightTable), and the command line tools
with Leinengen are pretty sweet too.

I realize that you can probably optimize your Lisp code a lot more than you
can your Clojure code since Clojure is on the JVM, but right out of the box
Clojure performs as well as naive Common Lisp, so its probably a more
attractive Lisp for most beginners.

~~~
eudox
Common Lisp has all those tools, what it does lack is a well-designed website
that says "Here's how you start".

The closest thing to that is probably the common-lisp.net website, and that's
just an unfinished barebones Bootstrap example.

I've been meaning to design a better one, but that's going to take some time.

~~~
Blackthorn
A website that both provided a starting off point and a unified reference
would be a great improvement to the CL community, on the same level as
Quicklisp.

------
kilon
I have been coding for fun for 26 years and played around with most popular
languages. Common lisp has by far the worst community I have experienced.
There is a minority of people that elitist , rude even hostile to anyone that
is new to the language. I never gave up a language because of the community
but CL community really was very hard to tolerate. Elitism and snobbery is far
from uncommon in the coding world unfortunately.

I think as a language it deserve the reasonable praise it gets and certainly a
beautifully designed language, powerful and yet flexible. I enjoyed very much
coding in it and with the help of lispers I was introduced to a language /
environment I fallen in love with Smalltalk , Squeak and now Pharo.

------
hvd
coincidentally I am working through land of lisp, recommend it:
[http://www.amazon.com/Land-Lisp-Learn-Program-
Game/dp/159327...](http://www.amazon.com/Land-Lisp-Learn-Program-
Game/dp/1593272812) Do I see myself using lisp in production code? Not in the
near future. I do think there is value in learning something that exposes you
to thinking in different ways, till now what Ive gained is that Python is
pretty lispy!

~~~
hcarvalhoalves
> Python is pretty lispy!

Check this out [https://github.com/hylang/hy](https://github.com/hylang/hy)

~~~
hvd
thanks!

------
matrix_nad
How long was the learning curve to CL, if you don't mind me asking?

I remember learning Lisp and all that reverse polish notation was very
unorthodox to me.

~~~
Slackwise
> I remember learning Lisp and all that reverse polish notation was very
> unorthodox to me.

I really, really want to answer this, but it's worthy of a chapter in a book.
May I summarize instead?

1\. Lisp syntax is tree syntax.

An expression such as this:

    
    
        (+3 (* 4 5))
    

Is a tree such as this:

    
    
           +
        3     *
            4   5
    

2\. Lisp macros can treat raw Lisp expressions as trees, and transform them
into other trees, as well as avoid typical function call evaluation.

3\. Lisp has little to effectively no syntax. Since all forms (outside of
special reader forms) are in simple lists/trees, you effectively know all
there is to know about reading Lisp. (Although, you do need to understand the
Triforce of Functions, Macros, and Special Forms, but they're worthy of their
own chapters to explain. They're still lists, though.)

4\. The nodes[1] of a Lisp tree are also their own data structure, known as
Cons Cells[CC]. These allow for easy manipulation and construction of trees,
as well as easy recursion by poping off the first part of a cons cell,
processing/consuming it, then sending the rest of the list back into the
function. Essentially stack-like processing of lists. So while recursive
functions can be rather ugly in other languages, they're rather elegant in
Lisp, and easy to work with.

Jeeze, I can probably keep going, and adding more and more points and
elaborating on their purpose, but it'd be better to just study Lisp on your
own instead. I only know cursory Common Lisp, so I can't recommend any books
or sources, but I can instead recommend learning Clojure. "Programming
Clojure" has been stated to be a good starting book, but I've mostly read
"Clojure Programming" from O'Reilly and "The Joy of Clojure". These are also
good books, but I'm not sure which is best for beginners.

[1]: Okay, to be more pedantically accurate, Lisp 'trees' are just cons cells
linking to more cons cells. It's a bit unweildly to think of all Lisp
expressions as cons cells rather than nested function calls or trees. [CC]:
[http://en.wikipedia.org/wiki/Cons](http://en.wikipedia.org/wiki/Cons)

~~~
jrapdx3
The fundamental syntax is also the same in Scheme which I've used quite a lot.
The stumbling block for beginners is of course the prefix, parenthesized,
"everything is a list" notation.

It does take patience to "get used to it". The effort of "getting over the
hump" is amply rewarded--one way is the benefit of seeing how marvelously
consistent and predictable the notation proves to be. IOW it's a great
simplifier, allowing humans to mentally read, parse and understand Lisp code.

To me the great genius of Lisps is shown by the experience of looking at work
I'd done months or years ago. Stuff I'd written before in C would often be
obscure to me later, especially when I hadn't made enough comments to
"explain" what the code was doing.

In contrast, it's much easier to understand my old Scheme programs, often just
minutes of review will do it. Sure, I'm talented at making things convoluted,
it's just harder for me to do that with Scheme, and no doubt that's true for
Lisps in general.

I've looked at Clojure a bit, my impression is it's syntax is more complicated
than Scheme. At least there are enough differences that it would take some
effortful study to become fluent in Clojure. Not a criticism of the language,
but suggests making the transition isn't trivial. Perhaps that applies in both
directions.

It's worth adding in the domain of constructing web servers, the list notation
of Lisp maps extraordinarily well, and easily, to the hierarchical markup of
HTML. It's a feature I've exploited extensively, and I think it could provide
better and simpler tools for web programming if employed more widely.

------
agumonkey
mobile/light version [http://p-cos.blogspot.fr/2014/09/why-i-like-common-
lisp.html...](http://p-cos.blogspot.fr/2014/09/why-i-like-common-
lisp.html?m=1)

------
pankajdoharey
This same article was published on planet Lisp
[http://planet.lisp.org/](http://planet.lisp.org/) by Pascal Costanza

~~~
_delirium
Planet Lisp is just a blog aggregator, and his blog is one of the ones it
aggregates.

------
brudgers
This article illustrates one of the hurdles the Common Lisp community often
sets before itself when it produces a piece of marketing. It points to
resources that are not immediately obtained or that don't directly touch on
the large subjects mentioned.

For example, one of the important capabilities mentioned in the article is
getting close to the metal with profilers and hand tuning code and the runtime
environment. Yet none of the links discuss this directly or provide tutorials.

The discussion about the wonders of CLOS suggests reading _The Art of the
Meta-Object Protocol_ \- a $35.00 345 page dead tree tome which Amazon will
get to you in about a week if you opt for free shipping. Graham's _Ansi Common
Lisp_ is of course even more obscure - it's been out of print for years and
from Amazon you're in the realm of individual sellers [my anecdote is that it
took about a month to get the copy I ordered - the seller was a nice person
but it was a couple of weeks before they read their email from Amazon letting
them know someone had purchased their copy].

The author goes on to recommend LispWorks as a platform. It's $1500 for 32
bits in North America and $4500 if you want to use all 64bits that your OS
probably runs under. Sure there's a free version, it's 32-bits, not licensed
for commercial work, and crippled. Don't get me wrong, the free version is
probably fine for playing around with, but this article targets people for
whom tuning the heap and GC are appealing, and this tends to be a professional
rather than hobbyist market segment.

The "early Web 1.0" vibe is unfortunately common when the Common Lisp
community attempts to promote Common Lisp. Let's face it, the linked Lisperati
site looks a GeoCities page [a good one]. The LispWorks page requires four
clicks to get to the price of non-crippleware. The author's own guide links to
academic papers and black and blue on white websites.

The issue is that the Common Lisp Community is not just sending signals that
most of the potential market ignores, it's that it is sending signals that
turn the potential market off. I will unequivocally say that crippleware is no
longer a viable approach to achieving significant developer mindshare. The
landscape is open source and $4500 a seat [and calling it Enterprise Edition]
is only going to hit some [potentially profitable] edge cases.

Of all the places accessible from the author's post, the only one that looks
in touch with the present is the original article on BlogSpot. Everything else
screams "This ain't for you" at most people.

It makes Racket look hip. And that's hard to do.

~~~
lispm
I think the hurdles are less than you think, but Common Lisp is probably not
for you. But I think that's fine. There is already a lot of stuff for 'most
people'. Why does everything need to be built for 'most people'? Why isn't it
okay that there are things which are not for most people? Haskell is not for
most people, Prolog is not for most people, Coq is not for most people, why
does Common Lisp need to be for most people? The article describes why
Charlotte Herzeel likes Common Lisp. maybe she is not 'most people'?

* you don't need to read AMOP to use CLOS. It's there if you want to know 'MORE'. Much more. Much more than you ever wanted to know about reflective OOP. Alan Kay of Smalltalk fame recommended the book as the best book on objected-oriented technology in a decade. ordering it over your book store is easy. But I don't recommend it to anyone wanting to learn Lisp. Read it if you want to know how CLOS is implemented or extended. A bonus point: it shows excellent coding style.

* 'Yet none of the links discuss this directly or provide tutorials.' The LispWorks, SBCL, Clozure CL manuals discuss that. Since there is so much stuff to link to, I recommend to go fully old-school and read the fine manual.

* as the starting book most will point you to Practical Common Lisp by Peter Seibel. Free online and available printed. It even explains a lot of CLOS.

* 'The author goes on to recommend LispWorks as a platform.' I do that too. Not the free version. The full commercial version. I even have the full 64bit 'Enterprise' version of LispWorks on my Mac.

* Web 1.0: Even worse, a comic book about Lisp programming using Common Lisp. [http://landoflisp.com](http://landoflisp.com)

* '$4500 a seat [and calling it Enterprise Edition] is only going to hit some [potentially profitable] edge cases.' \- well you may want to compare what a commercial Smalltalk, Ada or Prolog system costs... The market is small and lowering the cost would help letting the company survive. Something must be working for them: LispWorks was first released 25 years ago.

* 'Everything else screams "This ain't for you" at most people.' \- well, Common Lisp is not for most people. For most people there are many simpler options. For those wanting to work on fancy Web X.0 stuff in an easy way, there are better options - and that's totally okay.

Common Lisp is not for __most people __.

For those who want to use Common Lisp as free and no-cost software, the
article mentions 'Clozure Common Lisp' and 'SBCL'. I'd say that's excellent
choices. I use those, too. Still I prefer the commercial and expensive
LispWorks...

~~~
brudgers
I'm a fan of reading the fucking manual and thus you're preaching to the choir
on that. But I'm not an evangelical baptist about it. Truth is that most
people program by page faulting - writing some code, hitting a bug, and
googling for a solution, lather rinse repeat.

Don't get me wrong, 4500 bucks is probably a bargin. But again the landscape
is dominated by FOSS. More to _my point_ the points of comparison are pre-www.
Ada, Smalltalk, and Prolog as alternatives suggest a time before twenty-
something developers' parents were in college. Those languages were hot at the
same time as Lisp Machines. Was an opportunity missed to mention Modula-2 and
rotary dial telephones?

The Common Lisp community doesn't handle onboarding well. Seibel's _Practical
Common Lisp_ is ok, but how long has it been since CD's were an important
recorded music medium for people spending their time with computers? Well over
a decade since the days of Napster. Coming up on a decade of iTunes. CD's are
more old-school than landlines.

This is to take nothing away from Common Lisp as a language. It's not a knock
on the individuals who make up the Common Lisp community. It's pointing out
the Common Lisp community's blind spot. Mcarthy was brilliant. He also could
have been Rich Hickey's grandpa. We don't make phonecalls on party lines
anymore.

Figuring out how to reach the next generation of programmers doesn't require
compromising on principle. It does require recognizing that what didn't really
work in the past [that is the past since the days when Prolog and Ada were
hot, e.g. since C++] probably won't work today, either.

I mean, what's the case of Common Lisp over Clojure? And by that I mean:

    
    
      + point me to a webpage that sells me on the idea 
      
      + has a clear call to action
    
      + and looks at least as vibrant as Clojure's homepage

~~~
lispm
> most people program by page faulting

As I said, Common Lisp is not for most people.

This Web 1.0 page describes the concept: "Teach Yourself Programming in Ten
Years" [http://norvig.com/21-days.html](http://norvig.com/21-days.html)

> But again the landscape is dominated by FOSS.

Which landscape? There is not one landscape. Is Apple's XCode FOSS? Windows
dev tools? Open Source?

If you believe in FOSS, you can use SBCL, CMUCL, CLISP, ECL, MKCL, Clozure CL
and several others. I use SBCL and Clozure CL.

> CD's are more old-school than landlines.

Write games with Land of Lisp then. But sorry, the Common Lisp community is
not large enough to rewrite books every so often. In the mean time there are
classics like Peter Norvig's PAIP, which are even older and even less
exciting. Still it is easily one of the best programming books ever written.

> Ada were hot

Ada was never 'hot'. It is a tool used in a lot of mission critical software.

> I mean, what's the case of Common Lisp over Clojure?

I think you have to find that out yourself. Don't be sad if Common Lisp is not
for you. Few people drive a Mercedes Unimog, though Arnold Schwarzenegger had
one.
[http://i.dailymail.co.uk/i/pix/2014/09/04/1409847539952_wps_...](http://i.dailymail.co.uk/i/pix/2014/09/04/1409847539952_wps_1_EXCLUSIVE_Arnold_Schwarze.jpg)
You might ask what the Unimog does better than some Toyota, why it costs so
much and why so few people have one. If you might spend some time, you might
find out what the Unimog is, why it exists and who uses them for what...

~~~
brudgers
There are different ways in which a programming language isn't right for
someone.

For example, it can be like beef liver. It's not that I don't eat it because
of a commitment to vegetarianism. I'm not a vegetarian and I'll gladly eat
rare cow on a bun. It's not that I don't believe beef liver is nutritious. I
just find eating beef liver an inherently unpleasant experience. It's how I
feel whenever I try to use Python [even though it is quite likely more popular
than beef liver].

There are also languages which aren't right for me because they don't really
fit with what I want to do. Swift for example is only available on the OSX
platform and I don't own a Mac.

Neither of those apply to Common Lisp. The reason Common Lisp isn't really for
me is that there are simply less painful alternatives for the sorts of things
I want to do. And one of the ways in which those alternatives are less painful
is because of their communities.

It's not that language communities shouldn't be opinionated. I listened to DHH
talk about Rails in the early days on an older Hansel Minutes podcast. The
object is "person" and the table is "people". If that offends someone, then
Rails might not be for that person.

But the Rails community gets to the point quickly. It lays out the facts and
moves forward. Within that community it is not considered acceptable to say,
"read this book and these five papers and drop a few thousand on commercial
software, and then we might consider you worthy."

They tend not to tolerate that. But from the heritage of usenet.comp.lang.lisp
that's still considered by some a perfectly entertaining way to treat novice
questions in the Common Lisp community. Answering easy questions is dull and
being snarky is an outlet for creativity in comparison.

In the end, my hypothesis is that programming languages live and die the same
way as natural languages, either the community onboards new speakers and the
language lives or it doesn't and the language dies [take this as a Kuhn
paradigm if you prefer a reference point in science]. C remains vibrant as the
language of Unix and its descendants. JavaScript thrives as the language of
the web. Pascal and Algol and Simula are less than vibrant or thriving because
few people are learning the language.

By analogy some members of the Common Lisp community often behave as if it's
wrong for babies to babble, that toddlers should learn the alphabet by reading
Faulkner, and that only then are they qualified as persons.

Norvig's article is about learning programming, not taking ten years to learn
a programming language. Contrary to a portion of our dialog, he's a bit
language agnostic.

~~~
lispm
> Within that community it is not considered acceptable to say, "read this
> book and these five papers and drop a few thousand on commercial software,
> and then we might consider you worthy.

You totally distort the Common Lisp community and you post FUD. You attack
Charlotte's preferences for no reason. She presented HER preferences. Still
you attack the Lisp community as if individual opinions are not allowed and as
if she speaks for all.

Chearlotte speaks for herself and I think her recommendations are good.

There are a multitude free and open source implementations. Many were
developed before stuff like Rails or Java even existed. Free and Open Source
software has been written in Common Lisp from day one.

Clozure CL, mentioned by Charlotte. It is published on the LLGPL.

SBCL, mentioned by Charlotte. SBCL's roots go back to the early 80s as Spice
Lisp and then CMU Common Lisp. Public Domain since 30+ years.

And many others. Usually people complain the Common Lisp has too many
implementations.

Nobody required somebody to invest $4500 into a Lisp system to start.

It's just that some people in the Lisp community use the commercial tools and
think they are great. I'm one of those. LispWorks is probably the best
implementation of a dynamic language anywhere.

If people have actual problems with coding, they have multiple forums. I have
personally answered 1000 Lisp questions on Stackoverflow.

> analogy some members of the Common Lisp community often behave as if it's
> wrong for babies to babble

Some non-members of the Common Lisp community seem to whine a bit too much for
my taste. What the Common Lisp community (if there is one) does not really
like is whiners who fail to contribute.

~~~
brudgers
I'm not attacking the Common Lisp community. If I were, I certainly would not
have opened my comments with the idea that the community places a hurdle
before itself when marketing the language it loves. And one of the things I
love about Lisp is the way in which I share a love for the language with the
larger community.[1]

I have nothing against commercial tools. I've spent many thousands of my own
dollars on shrinkwrapped bits over the years. That doesn't change the fact
that shrinkwrapped bits are continuing to diminish in popularity due to thirty
years of Stallmanism running in parallel with nearly thirty years of "greed is
good" and even more years of a hacker ethos where spending 80 hours to pirate
fifty dollars worth of software is a hobby.

Why care if the Common Lisp community likes me? It don't like most people. It
would be foolish to its dislike personally. In fact, why blame them when Hell
is other people?

The upshot is that I care enough to say something constructive. I don't wish
the Common Lisp community anything but success. I'm not a jaded ex-lover. I
hope it meets someone new and that someone turns out to be its soul mate.

[1] Going so far as to coin the term "love song to Lisp":
[https://hn.algolia.com/?q=love+songs+to+lisp#!/comment/forev...](https://hn.algolia.com/?q=love+songs+to+lisp#!/comment/forever/0/love%20songs%20to%20lisp)

