
New Common Lisp website - ejbs2
http://lisp-lang.org/
======
gkya
Discussion on /r/lisp, yesterday:
[https://www.reddit.com/r/lisp/comments/4j6v8y/lisplangorg_a_...](https://www.reddit.com/r/lisp/comments/4j6v8y/lisplangorg_a_promotional_common_lisp_website/)

~~~
dwc
(Lack of) discussion here yesterday:
[https://news.ycombinator.com/item?id=11691086](https://news.ycombinator.com/item?id=11691086)

------
fadelakin
Can someone explain to me the main differences between a language like Common
Lisp and Haskell?

I'm planning on learning on a purely functional language this year and I've
narrowed it down to Haskell and CL but I don't know which to pick. Haskell has
sort of been winning due to my friends knowing it and using it.

If you have any resources as well, please let me know. I don't know if this is
the right place to post this.

~~~
gkya
Common Lisp is not a purely functional language.

The most caracteristic feature of Lisp in general is that, its whole syntax is
the literal representation of one of it's core datatypes, the linked list.
This allows for creating idioms of arbitrary complexity and reusable
abstractions with ease, one a tiny kernel.

Another wording of this is that the Lisp family of languages represent their
programs as data that those programs _directly_ manipulate, and thus, programs
can manipulate themselves. This is _homoiconicity_.

For who likes laconicisms, Lisp is a pleasant way to write and execute a parse
tree.

The advantage to this is that you can create syntactic abstractions that fit
in nicely, that work on structured data instead of strings not parsed and
verified yet (hey CPP!) and are reusable by other abstractions.

The disadvantage is that your set of abstractions can become very easily
dialects, and the language ecosystem is prone to (and damned by) fragmentation
(i.e. every Scheme has it's own module system, and then there's a late
standard that nobody uses).

Another advantage of Lisp, though not unique to it neither theoretically nor
practically, is the _image_ , that is, the state of the interpreter. Your
average Lisp process is code running on a Lisp VM, and the VM allows you to
modify the running code. This allows you to pause the thread when an exception
happens, modify the code, and _play_ it again, and the program uses the new,
modified version of the code. These are called _restarts_ and supported at
least in Steel Bank Common Lisp, and are well integrated into SLIME, the
canonical Emacs mode for Common Lisp and other uncommon (!) lisps. This is so
powerfull, I read that in one space mission, when they spotted a bug in the
code of a research apparatus already in space, they connected to its image and
hotpatched the code fixing the bug, saving NASA millions of dollars.

~~~
d_j_b
"its whole syntax is the literal representation of one of it's core datatypes,
the linked list"

"Your average Lisp process is code running on a Lisp VM, and the VM allows you
to modify the running code"

Thank you. As a non-Lisper, this is probably the clearest explanation of
Lisp's qualities I've ever read.

------
BMarkmann
I love common lisp. That being said, i feel like this effort might be better
spent contributing to modernizing and cleaning up / updating the existing
community sites like cliki.net.

~~~
sedachv
Out of curiosity, what would you like to see updated on cliki.net? I wrote
cliki2 with Andrey Moskvitin so a lot of the changes from the first cliki
ended up being our opinions.

~~~
BMarkmann
I guess the point I was trying to make wasn't that cliki in particular has any
shortcomings, but that more hands on any particular open source effort tend to
yield more fruit that those hands spread across as many independent efforts.

The CL community in general has some amazingly prolific contributors, though
perhaps fewer in number than other languages enjoy. One thing I've always
noticed, though, is that the resources out there lack the "glue" to tie
everything together. Cliki is definitely one resource that does that,
Quicklisp and its doc page
([https://www.quicklisp.org/beta/UNOFFICIAL/docs/](https://www.quicklisp.org/beta/UNOFFICIAL/docs/))
is another. Here's something of a motivating example... I wanted to mess
around with building a multi-threaded server the other day. I went to Cliki,
found usocket and bordeaux-threads, from their descriptions it sounded like
they would be a reasonable starting point to build on. The API documentation
and tests in their repository for both projects left me scratching my head...
Then I started searching for applications that used them and between Cliki and
Googling didn't find many great examples. Then I said, well, let's step back
and see how Hunchentoot handles its networking layer. Turns out it uses --
wait for it -- usocket and bordeaux-threads.

Maybe it would be helpful to link from the "recommended libraries" (and other
topic pages) to projects that use each library? I don't really have any
concrete advice, I just feel like one of the things the CL resources out there
lack is some layer that ties everything together. Cliki is a great starting
point, but it might benefit from more hands.

That's certainly not (not by a long shot) the only place where the scattered
CL resources out there could benefit from volunteers. There are untold numbers
of things like ([https://common-lisp.net/project/common-lisp-
beginner/](https://common-lisp.net/project/common-lisp-beginner/)) this
floating around that more hands would help.

Sometimes the answer isn't, hey, let me make my own site -- maybe step back
and consider whether your efforts could benefit the community more if you lent
your time to something that already exists. Just a thought.

------
Slippery_John
I find it amusing that their picture for stability is a mountain right next to
a supervolcano.

------
gaius
Here is PG's note on ITA software from 2001
[http://www.paulgraham.com/carl.html](http://www.paulgraham.com/carl.html)

It's all good stuff but I would wonder about any language community that
hadn't gotten any other big hitters onboard in the last 15 years.

~~~
danielam
I used to work at ITA. I seem to recall Carl admitting at one point that the
choice of language had mostly to do with the fact that he and Jeremy were most
familiar with Common Lisp, having used it while pursuing their doctoral
degrees, and that he probably would have chosen Java in retrospect (this was
in 2007). The actual code was not the clean functional code you might expect
(and as the email above notes, much of it was also written in C++, half by
line count IIRC). In fact, there was interest in parallelizing parts of QPX
(the low airfare search engine in question) to speed up search, but it was not
amenable to such changes without first having to untangle a bunch of single
threaded side effecting code and without incurring penalties in performance or
resource consumption.

------
_asummers
Not sure if bug, but the right curly double quotes in the CL snippets bother
me way more than they probably should. In the source, it's simply a "
character, so the CSS is likely conflicting somewhere.

------
Decade
I love (sarcastically) how the Start here -> First Steps does not include any
instructions on how to get a Common Lisp installed and running on your
computer.

~~~
eudox
[http://lisp-lang.org/learn/getting-started/](http://lisp-
lang.org/learn/getting-started/)

The link is above the 'Tutorials' heading. Maybe it needs some custom style to
make it stand out.

~~~
aidenn0
I did a double-take on that as well, so it might.

------
Learn2win
I use (typed) Racket and it's wonderful.

------
golergka
Learning Scheme with SICP right now, and there's a question I'm now pondering:
how does one choose between Common Lisp, Scheme, Racket, Clojure and others?
Is there a good comparison of Lisp-derived languages somewhere?

~~~
Flow
Stick with Scheme for SICP.

As for the other Lisps, I think you should give them all a lengthy and serious
try. It's worth it.

For Common Lisp, when you have learnt it a bit, get the book Let over Lambda.
It's a great bus-ride read and, IMHO, is one of the best Lisp books I've read.

When you get to Clojure, don't be put off by the JVM and the harsh stack
traces and unhelpful error messages. Look at the Rich Hickey video
presentations and realize Clojure is its own thing. There are lots of smart
and practical choices made in Clojure.

I've not had time to give Racket a try yet. But it seems a very nice language
with good implementation, docs and community.

------
protomyth
Click specification: "We're currently working on parsing the TeX sources of
the specification to generate a more modern version of the CLHS.

This might take a while."

Yeah, that's probably not the message you want to send after all the virtues
(e.g. speed) listed on the first page.

~~~
somethingsimple
Why? They're just being honest about it. It's a large spec and it surely isn't
that easy to convert it to a more modern format.

~~~
protomyth
Put up a pdf (if you have TeX you can get a pdf), but don't make some
technical argument that makes you sound slow. This is marketing not a
technical talk.

~~~
kiiski
The CLHS[1] they mentioned has been available online for ages. What they're
talking about is making a more modern site. Generating a PDF from the spec
wouldn't get them any closer to that goal.

[1]:
[http://www.lispworks.com/documentation/HyperSpec/Front/index...](http://www.lispworks.com/documentation/HyperSpec/Front/index.htm)

~~~
protomyth
Then don't put a specification link on the home page and wait until it is
done. The text is non-helpful to marketing the language particularly when
books are actually available and linkable that can be read now.

------
dri_ft
I hate the current trend for websites to have about a page's worth of
information spread over about eight pages' worth of space. I'm used to seeing
it on startup websites, where it doesn't bother me so much because I expect
those to be trendy. But I'm recently seeing it infect websites of old school
geek projects that I feel should know better. This is one example and the new
emacs website a few days ago was another.

~~~
xenophonf
I'll allow it. Lisp in general (and Common Lisp in particular) desperately
needs better marketing, which unfortunately is susceptible to the vagaries of
fashion. If dressing it up a little makes it more attractive to the next
generation, then mission accomplished.

~~~
janoc
Sorry, but a "website" which is basically a set of powerpoint slides in
Javascript is certainly not going to help "market" anything.

And to add insult to the injury, when you actually suffer through those empty
marketing slogans, you get down to a big link "Start here" \- which unveils a
link to few very basic tutorials.

What exactly is the point of such "website"? The information value of this is
zero. What a waste of time.

A much better (but not the latest web framework buzzword compliant) resource
is this: [http://www.lisperati.com/](http://www.lisperati.com/)

~~~
cname
You may have found it to be a waste of time, but I thought it was a pretty
good introduction. Probably the furthest I've gotten into Common Lisp over the
past ten years or so.

