Has anyone used Common Lisp and care to give an apology for why I should look at it?

I looked briefly at Scheme and CL before I learned Clojure and walked away from both due to lack of useful library infrastructure.

quicklisp seems to have helped with this, but I haven't actually used it in anger.

CL is fantastic.

compile time type checking in SLIME is insanely valuable

aardem^^

CLOS blew my mind wide open

'tis what all OOP systems i've ever learned wished they were

but even calling it OOP is a bit of a misnomer

the multiple dispatch system is superb

the restarts system is what every other try/except implementation wishes it were

the whole language hangs together as a coherent, designed thing.

for instance, from emacs, jump-to-def on a method will pop up a buffer listing /all/ implementations of that method, with handy function signatures and type annotations for each

there is some insane shit in there too, for instance the ability to update all instantiations of a class to a new class definition

"why would you ever /do/ that?"

well many old systems that CL descended from were designed to /never be restarted/

SBCL, for instance, implements save-lisp-and-die

which serializes the running lisp image to disk along with a function to call to boot it back up

i could go on, but the best summary i can offer is that in my extremely short career i've learned that the culture of software likes to reinvent all of software every .75 decades, and CL is an example of a 30-year old programming environment that not only solved it all, but did so elegantly, coherently, /beautifully/, and more completely than any of the modern languages i've touched.

I have used Common Lisp for about a year. It was my first Lisp and left me unsatisfied with everything I discovered after it, except Clojure.

@arrdem: The Lisp Machines might interest you. (Like Symbolics Genera.)

Here’s a demo of the operating system: https://www.youtube.com/watch?v=o4-YnLpLgtk

Never used it personally (though I’ve had a couple jobs using Common Lisp), so for me it’s more an imaginative mindset to critique and better understand the Unix experience: - the Unix commandline is like a REPL (what they called a “Lisp listener”) - instead of a general language UI, Unix has a system language (C) + scripting language (usually bash) + application languages (Java, Python, Clojure...) - Unix is too static and un-unified to let you click on an object, see its sourcecode, and modify it on the fly - Unix has core dumps rather than a debugger

Though come to think of it, I just got into Docker (which so far I think is unusually nicely-designed); to what extent does the traditional OS matter anymore? If everything runs in isolated containers and communicates via message-passing... seems there’s space for a decent dynamic layer(s) above that.

while we're on the topic of symbolics: https://www.youtube.com/watch?v=6uPwQuxjgQo

@bvulpes: Thanks, found it very inspiring!

@arrdem: Oh, forgot to mention: as you probably know, the main Common Lisp hangouts were basically troll cultures, last I checked. Toxic. http://lispforum.com is decent, and so’s LispWorks’ forum (if you use LispWorks).

Yeah. I'm aware.

Interesting links / commentary, thanks all.

Ah yes I remember asking a question on a Common Lisp mailing list once. The replies didn't make me feel too good.

So I'm well aware of the Lisp Machines... and I'm also really not interested by them.

Technically speaking the machines we have today are strictly superior in all but ergonomics, and that's a question of investment which markets seem to have shown isn't required.

I think the thing that puts me off about CL, despite its place in history, awesome performance and many features is that it's a very old, very insular culture which has no apparent interest in onboarding people or evangelizing if indeed they have something we don't of which I'm not convinced.

They have a new website: http://lisp-lang.org

Heh.

They also have the hyperspec which while not great puts Clojure's docs to shame...

Even what bits I've rewritten for http://conj.io

Ah, I should've asked what sorts of things interest you... to see what (if anything) in Common Lisp meets your interests.

well, Paul Graham recommends Clojure instead of Common Lisp now, FWIW 😉

@tjg: all good. I spent some quality time here at school doing computer architecture, so this is a particularly sore spot for me 😛

https://www.arrdem.com/2014/11/28/the_future_of_the_lispm/

The primary criticism I got of that piece was that LispMs weren't about FP, to which my rhetort is that while they weren't they're being held up by the Lisp/FP crowd of today as some lost Eden which I think is a negative collective self-delusion. I'm inclined to level a similar criticism against the "clisp is better" pattern of thought. The idea that we've meaningfully lost anything in particular is explicitly defeatist and fails to acknowledge the limitations of prior art.

My 0.02, would love to be shown wrong.

found another one @borkdude http://gotlisp.com/ 😛

I have moved on. I like a language that embraces immutability from the core, it's my definition of FP: first class functions + immutability. When I only knew Common Lisp I thought first class functions were enough, but no.

Maybe there will come a time when I say: types, monads, etc, else that's not FP, but I'm not yet there.

arrdem: do the chip designs not count as lost?

not to mention the ability to actually stop the chip/nic-equivalent and inspect their states?

i read the schem-76 paper recently and the ability to actually stop and inspect the chip sounds pretty amazing, and pretty far from where we are now.

I mean... it's cool sure but why do you need it? we can still build logical debuggers without it as evidenced by gdb, sbcl, the Java debugging frameworks etc.

that strikes me as giving up on debugging the hardware, though.

i am way out of my depths here, though. all of my formal training is in applied physics, not complang/execution environment design/impl

@arrdem: Interesting article! The criticisms you mentioned getting (about FP) don’t seem relevant to it.

I don’t advocate Common Lisp, but you requested “an apology for why I should look at it.” 🙂 Personally haven’t touched or thought about Common Lisp for a couple years.

There’s circumstances where Common Lisp fits better than Clojure, but privately I consider it a dead language. (Of course, people benefit from learning “dead languages” all the time.)

Though, I think there’s truth to the “lost Eden” mindset. People like Alan Kay point out a slowdown of computing innovation around the 1970-80’s. http://stackoverflow.com/questions/432922/significant-new-inventions-in-computing-since-1980

Some point out that major factors around 1970 are changes in the economy, increased bureaucratization of universities, and privatization of research. (Like in the 2nd half of this article: http://thebaffler.com/salvos/of-flying-cars-and-the-declining-rate-of-profit )

In the programming world, one manifestation could be a bunch of disgruntled Lispers... 🙂