
Common Lisp in the 21st Century - johnwalker
https://github.com/fukamachi/cl21
======
emiljbs
And this is what /r/lisp thought about it:

[http://www.reddit.com/r/lisp/comments/1vtueu/cl21_common_lis...](http://www.reddit.com/r/lisp/comments/1vtueu/cl21_common_lisp_in_the_21st_century/)

------
ScottBurson
Huh. These all seem like minor details.

I think (shameless plug) that my FSet functional collections library helps
modernize CL quite a bit more than this does. I've had a couple of people tell
me that FSet has changed the way they program. That's a high compliment.

I'd be the first to admit that FSet takes some getting used to, but if you're
willing to put in the work to learn to think this way, there are substantial
benefits. It greatly expands one's opportunities to write CL code in a
functional style. (Those already familiar with the functional style will find
it fairly natural.)

~~~
e12e
I assume that's:

[http://common-lisp.net/project/fset/](http://common-lisp.net/project/fset/)

~~~
ScottBurson
Yep!

------
ryeguy
One of the annoyances of CL is the absolutely nonsense function names. Just
looking at these examples, I have no idea what princ (something to do with
print, i assume), getf, or elt (element?) mean.

~~~
lispm
What does tar mean? ls? df? gunzip (something with guns?)?

Every language old enough will assemble some naming problems. If you look at
newer languages, even there naming is still the old problem. Clojure: What
does fnext do different than nnext? Can you guess what rseq does?

With larger software systems, you'll see that you will need to look up
documentation quite often. On my old Lisp Machine there are 60000+ symbols
naming tens of thousands functions. So naming becomes important. When Lisp was
small, there were functions which print something, then variations were added
and people tried to keep the names short. After a while there were so many
functions and memory was larger. People started to use longer names. CALL-
WITH-CURRENT-CONTINUATION (in Scheme) or SET-DISPATCH-MACRO-CHARACTER were the
results. ;-) Now we got nice descriptive names, but we need completion during
input.

There is no way other than to learn a certain base vocabulary. Since the
printer is essential in Lisp, you'll need to learn functions like princ or
print to read older code. In your own code you can just use WRITE, which is a
general interface into the printer.

Fortunately enough, the documentation of these functions is just a keypress
away in any good Lisp implementation.

~~~
coldtea
> _What does tar mean? ls? df? gunzip (something with guns?)?_

How are MORE bad examples an argument against what he says? If anything they
reinforce his statement.

Plus, the thing with "tar" and "ls" is that they've been tar and ls in all
Unices for decades. If you learn "ls", and maybe "dir" if you want to use
Windows, you're golden. Whereas every language seems to use its own names for
"princ", "setf" etc, both before and after CL.

~~~
lispm
> How are MORE bad examples an argument against what he says? If anything they
> reinforce his statement.

These are not bad examples. It is just normal to use short identifiers in many
programming languages and command interfaces.

princ is in Lisp for decades. Emacs Lisp:

    
    
        ELISP> (princ 'foo)
        foo

------
adwf
I've always thought that CL needed a set of common libraries to be strongly
recommended. The problem is that it has been tried before, but never really
taken off.

However, given the recent rise of quicklisp for managing libraries, it's
entirely possible that a project of this type will be much more successful. I
hope so!

I still remember the first time I looked at the Alexandria library and
realised I'd already implemented a good 1/4 of the functionality myself, just
because it was glaringly missing from the CL core spec.

~~~
orthecreedence
> I still remember the first time I looked at the Alexandria library and
> realised I'd already implemented a good 1/4 of the functionality myself

Yeah, same here. I have a bunch of utilities lying around from when I started
that Alexandria would have completely obliterated.

I'm interested in cl21's use of symbol partitioning. I've always thought the
`cl:` package was really, really bloated and somewhat confusing to newcomers.
Something that divides everything into "this is for math" "this is for
primitive data types" etc would make things a bit easier to manage.

I know /r/lisp didn't really like it for the most part, but since the spec is
frozen it's nice to see people who are involved in lisp actively trying to
make it better. The world is littered with successful projects that started
out with people saying "You're wrong, don't bother doing this." I wish Mr.
Fukamachi well and look forward to progress.

------
melipone
CL in the 21st Century is Clojure.

~~~
stewbrew
Inexplicable stack traces caused by mediocre tools?

------
kenbot
Lisp for the 21st century and it's.... _more_ object oriented?

~~~
vseloved
cause, in Lisp OO is done right ;)

