

Lispings ala John McCarthy - agavin
http://all-things-andy-gavin.com/2011/10/25/lispings-ala-john-mccarthy/

======
agentultra
Lisp is old. Libraries suck. GC is a problem? _Really?_

Age is a feature, IMO. If it survived this long and is _still_ such an
important language -- that counts for a lot with me. It means I get to stand
on the shoulders of 40+ years of research and development.

The libraries don't suck... there's just not the same proliferation of
libraries that other languages have enjoyed. However, I find that the signal-
to-noise ratio is much lower. In other words, there are few libraries but few
of them suck.

(The lack of documentation however, is a problem, IMO).

Lisp is a good language. It's still a good language.

It has plenty of nice features, a uniform and simple syntax, great tools, and
is fun.

I just wish more people were developing software with it these days. :)

~~~
agavin
I'm not a LISP hater, far from it, I love the language.

In 2006 I wrote a complex multi-threaded socket and web server that talked to
MySQL. I wrote it first in ACL, ported it to CMCL, then to Ruby, and then
parts of it (with another programmer) to C (ultra high performance after
that). So I got a head to head comparison for the same task.

As to libraries in 2006 (and Ruby libs are only better now). It was easy in
Ruby to find libs to talk to third party APIs like Twitter, Facebook,
Photobucket, etc. None of this existed in CL. They might be quirky, but they
were there.

In ACL/CMCL "core" libraries like sockets and database access tended to be
missing a lot of "fringe" (not really that fringe) features like transactions,
multiple database support, enums, bigints, etc. But worse than that they
tended to mysteriously hang under moderate volume. I found this true on both
ACL and CMCL, different libs.

The equivalent Ruby libs, like ActiveRecord, had some SERIOUS quirks, and were
missing some of those "fringe" features (I added a lot of them like multi-db,
enums, and bigints). But fundamentally, they were more modern in design and
reliable. ActiveRecord almost never crashed or hung. Yeah, it did some crazy
and stupid things, and performance was a problem. But it didn't hang. When
writing real production code mysterious hang/crash/corruption bugs are just a
deal killer.

~~~
Arelius
I'm very sympathetic to this exact problem. I love writing code in a Lisp, the
language is a beauty. Working in rendering/visualiztion, there are no real
lisps that are usable for the performance characteristics that we need, which
is a problem in itself, but I do find that I am able to write much of my
personal code in more dynamic languages.

For a while I was trying to get practical code written in scheme, but it then
became clear that there were probally about 40 people in the world trying to
write actual usable code in scheme, and not just using it academically,
eventually, I gave up, and started using CL, because at least, there are
and/or have been, people trying to create real products with CL, and there are
real sets of libraries.

But again, every once in a while, I decide to write a side-project in Ruby,
due to one reason or another, existing libraries, or working with others, and
the simple fact of the matter is that atop of Ruby being a reasonable
approximation of everything I want from Lisp, macros aside, it has, simply a
much more mature set of libraries. In my experience not only am I more likely
to find a specific library for Ruby, but it is much more likely to be well
tested and production-ready.

------
zitterbewegung
No mention of Clojure?

~~~
agavin
I need to check it out -- been busy :-)

~~~
cema
Well, you can enjoy getting busy with Clojure...

------
shaunxcode
Does this mean he uses ruby in the same way you he was using GOAL?

~~~
agavin
The GOAL compiler, yes. The GOAL runtime no. GOAL itself produced high
performance code without arbitrary GC, with simple (semi-static) runtime type
checking etc. It was designed for console runtimes. I didn't write Jak &
Daxter in CL, but in this Scheme dialect language (the compiler was written in
CL/CLOS).

