
Answers from 2017 Common Lisp experts - drdre2001
https://blog.teknik.io/phoe/p/365
======
mark_l_watson
Wow, that is great, thanks for putting it together! I have been using CL since
the mid 1980s, but cumulatively have just used the language for perhaps five
years.

While I find myself using Python a lot because it wraps so many machine
learning libraries and Java because of the ecosystem, there are other
languages like CL, Ruby, and Haskell that all just make me feel good when I
use them.

~~~
aaron-lebo
I really wish I could use CL more. It's just that in almost every domain, the
new libraries are elsewhere. You could use lisp for scientific computing, for
example, but it'd be crazy to do so because you'd be reinventing so much
that's getting built elsewhere. Similarly with games, C++ just has a lot more
libraries available (you could FFI I guess, but that's never as bulletproof).

Not sure lisp is better at any one thing than being a lisp, which is great but
I want to be able to justify reaching for it. 10 years ago PG had me believing
that there'd be a lisp revival one day, but despite getting more and more
polished, there's so much going on in other ecosystems.

Sorry for the rant, I know the lisp community has been building great stuff
for decades, lisp is great.

~~~
grault
You don't have to reinvent a thing, just use some ffi (foreign function
interface) implementation and call into whatever you want.

~~~
flavio81
To add to this reply, interfacing in C with Common Lisp is pretty easy today.
There are at least two portable libraries to do this.

Also, you can also interface with Java libraries on the JVM by using the ABCL
lisp implementation.

~~~
vram22
>There are at least two portable libraries to do this.

What are they?

~~~
flavio81
One is CFFI, widely known and well documented, with tutorial and tooling:

[https://common-lisp.net/project/cffi/](https://common-lisp.net/project/cffi/)

The other was UFFI, older; but then there are others. In fact, there are a ton
of other projects for doing FFI in Common Lisp!

[http://www.cliki.net/FFI](http://www.cliki.net/FFI)

And then you can also use the FFI functionalities provided by the particular
Lisp implementation (i.e. SBCL, LispWorks, ABCL, etc.)

However, the use of a _portable_ library like CFFI means that you can take
your code that runs correctly in SBCL, and then run the very same code in
CLISP (other Lisp implementation) with no change at all.

CFFI works for the following Lisp implementations or "compilers": ABCL,
Allegro CL, Clasp, CLISP, Clozure CL, CMUCL, Corman CL, ECL, GCL, LispWorks,
MCL, SBCL and the Scieneer CL.

That's a lot of implementations!

~~~
vram22
Sure is a lot. Thanks!

------
rtpg
Lots of interesting stuff in here.

Feel like some people could probably say things with a bit less sass though...
Replying to "I have a hard time finding good resources" with "everything is
terrible" isn't super useful

~~~
Sir_Cmpwn
The teknik.io gang is not known to be lacking in sass.

~~~
phoe-krk
Who's the gang you're speaking of? I'd like to get to know them. The
aforementioned quote is AFAIR from Reddit, not Teknik, so the credit goes
there; you can trace the answers to individual comments inside the Reddit
thread linked in the article.

Personally, I use teknik.io as a blogging service and Git hosting.

~~~
Sir_Cmpwn
Can you reach out to me via email? I don't necessarily want to post their
haunts in public without their permission.

------
jc2188
That's a lot of Lisp experts

~~~
phoe-krk
It's a play on the title of the original blogpost. Quoting myself from there:

 _It 's somewhat baffling to say that "experts", whoever they are, have
gathered to respond to this question - I simply assume that the people who
have voiced their opinion on the topic - regardless of who they are - know
what they are talking of, and therefore their comments should be, and have
been, included here._

But, on the other hand, correct, Lisp ain't dead yet. At least not any deader
than the usual.

------
lngnmn
I really don't get the lispm's answer about cl21. What are the hidden
treasures of the genuine Common Lisp we are ignorant of?

In my humble opinion Common Lisp is the classic example of the kitchen sink
syndrome, where many pieces taken from various dialects were put together in a
hurry. The results is not that bad (like, say, C++) but we know, arguably, a
much more refined versions of Lisp, such as the dialect from Symbolics and
Arc.

So, honestly, what are these hidden gems?

cl21, it seems, was an attempt to unify some syntactic forms rather than re-
define what a Common Lisp is or should be. In that respect it is very
remarkable effort. It is also a package - don't use if don't like.

The fair point that Common Lisp is a truly multi-paradigm language, so it
includes mutating primitives alongside with "pure" functions and supports
lexical and dynamic scooping, is rather difficult to grasp, but there is a lot
of possibilities at the level of syntactic forms and embedded specialized
DSLs, which, arguably, is what makes a Lisp Lisp.

It is never too much of embedded DSLs and syntactic sugar.

~~~
lispm
> What are the hidden treasures of the genuine Common Lisp we are ignorant of?

Actually Common Lisp is in many places a very well documented and designed
language. Other languages have copied its numeric tower, its macros, its
object-system, its error handling, ...

>In my humble opinion Common Lisp is the classic example of the kitchen sink
syndrome, where many pieces taken from various dialects were put together in a
hurry

The 'hurry' took place from 1981 (when the work on Common Lisp started) until
1994 when the ANSI CL standard finally was published. 13 years where hundred+
persons helped to design the language and provided comments, improvements,
designs, prototypical implementations, alternative designs, ...

Also the 'various dialects' were mainly only Maclisp successors and Common
Lisp was designed to be successor to them, not a summary of various dialects.

CL21 has more problems than lines of code, including security problems. As an
experiment, fine. As a library that should be used? Please don't.

Edit: this thread gives a bit more detail discussing a COERCE method of CL21:

[https://www.reddit.com/r/lisp/comments/6snw5d/questions_for_...](https://www.reddit.com/r/lisp/comments/6snw5d/questions_for_2017_common_lisp_experts/dlfi78d/)

~~~
lngnmn
I remember reading the Symbolics manuals from bitsavers and how I have been
impressed by clarity and unity of the language, and how they incorporated CL
into Zetalisp just by moving their own stuff into packages.

At least in the documentation everything looks wonderful. Compared to
Symbolics CL looks like a mess at least from reading the books.

~~~
flavio81
> Compared to Symbolics CL looks like a mess at least from reading the books.

Which books, may I know?

The Common Lisp Hyperspec is one of the best reference manuals for a
programming language, ever. But it is not a tutorial nor a how-to guide!

Try "Pratical Common Lisp". Or "Land of Lisp" if you want to have lots of fun.

 _simple but refined, guaranteed to blow your mind..._

[https://youtu.be/HM1Zb3xmvMc](https://youtu.be/HM1Zb3xmvMc)

~~~
lngnmn
> Which books

Symbolics Common Lisp - Language Concepts (volume 2A)

It also covers parts of Zetalisp.

I am also big fan of pg's On Lisp and ANSI Common Lisp.

------
phoe-krk
Author of the compilation here.

Sweet lords, I have made the front page of the Hacker News for the first time
of my life! I had no idea that this would generate so much traction,
especially as my own submission at
[https://news.ycombinator.com/item?id=15012678](https://news.ycombinator.com/item?id=15012678)
went across HN rather unnoticed.

~~~
ScottBurson
It's somewhat hit-and-miss which submissions make the front page. A submission
has only a few minutes to get several upvotes before it's pushed off the front
"new" page, after which it's unlikely to recover.

Since you're here I'll add a little to my previous comment [0], which was very
short because I didn't think many people would see it.

I don't advocate completely pure functional programming as one would do in
Haskell, but I do think there are lots of places in most code where the
functional style would be clearer and easier to understand and debug than the
fully imperative style more common in Lisp. That's why I created FSet [1], a
functional collections library. It has been my observation that having high-
quality functional collections is often the most important missing piece to
make it possible to write more code functionally.

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

[1] [https://github.com/slburson/fset](https://github.com/slburson/fset)

------
quickthrower2
> It's not some axiom of the universe that "thou shalt use GitHub

Love it!

------
flavio81
Alternate Link for people who can't open the URL due to it being marked as
"malicious" by some software:

[https://gist.github.com/phoe/d93f968f22bbcc87070cdc583176202...](https://gist.github.com/phoe/d93f968f22bbcc87070cdc5831762021)

------
ScottBurson
• Are there any functional programming advocates in the Common Lisp open
source community?

Yo! [https://github.com/slburson/fset](https://github.com/slburson/fset)

