
The Roots of Lisp - DanielRibeiro
http://www.paulgraham.com/rootsoflisp.html
======
agavin
For nearly two decades I was a diehard LISP advocate. I even forced all my
programers to code three Crash Bandicoot and four Jak & Daxter games in custom
LISP dialects that I wrote the compilers for (an article on one here
[http://all-things-andy-gavin.com/2011/03/12/making-crash-ban...](http://all-
things-andy-gavin.com/2011/03/12/making-crash-bandicoot-gool-part-9/)).

But by the mid 2000s I started doing the kind of programming I used to do in
LISP in Ruby. It's not that Ruby is a better language, but mostly it was the
momentum factor and the availability of modern libraries for interfacing with
the vast array of services out there. Using the crappy unreliable or outdated
LISP libraries -- if they worked at all -- was tedious. Plus the LISP
implementations were so outmoded. It was very hard to get other programers
(except a couple enthusiasts) to work that way.

Ruby struct a decent compromise. And it's type system and object model are
better than CL anyway. The syntax is more inconsistent, and the macro model
nowhere near as good. But it turns out. Libraries and implementation matter a
lot. Still, you can feel lots and lots of LISP influence in all the new
runtime typed languages (Ruby, Python, etc). And 30 years later, listeners
still rule!

~~~
agavin
Thanks for all fan love :-)

One of the interesting things about LISP is that it's actually a pretty easy
language to parse, interpret, and compile. This isn't actually an accident as
the S-expression syntax I'm sure was initially chosen for it's machine
regularity (in those early days of underpowered machines). Newer languages are
syntactically much more complicated. Ironically most normal programmers, being
human, seem to find the more complicated syntax easier and the "simple"
S-expression syntax confusing (being backward much of the time to normal human
convention). I always found it unambiguous, but go figure. It's also precisely
this regularity that makes the awesome macrology of LISP possible. In Ruby you
can manually build up strings and feed them into the interpreter, which is
equivalent to simple backquote. But you can't do the kind of cool nested
constructions that are trivial in LISP.

~~~
kamaal
Its really not about the syntax. Its about writing in AST. Availability of
large set of libraries. And especially I find it very difficult to use it for
my day to day uses(Places where I use Awk, sed and Perl) or in other words
everyday practical needs.

I still don't know _How to start learning lisp_ as a beginner and _use it for
my day to day needs_?

I don't think anybody today has the time to study the science behind lisp and
then see where its useful to them.

We want some thing that we can browse through and straight away go and use
_now_!

Is there a recipe book?

~~~
KaeseEs
I don't know about recipe books, but for a general introduction I've found
Conrad Barski's _Land of Lisp_ to be very good and loads of fun, although the
commentary gets a little triumphalist at times. You can grab it through
NoStarch or Amazon iirc.

------
charlieok
PG: "It seems to me that there have been two really clean, consistent models
of programming so far: the C model and the Lisp model. These two seem points
of high ground, with swampy lowlands between them."

We lost founders of both in the last couple weeks. Ritchie for C, McCarthy for
Lisp.

What's cool about the paper Paul is talking about here: if you start with car,
cdr, cons, quote, cond, atom, eq, and a notation for functions expressed as
lists, you can write an "eval" function reimplementing the language. The rest
can be built on top of it.

Graham calls this an "axiomatization of computation". The notion of a Turing
machine was already well known before McCarthy's paper, and is its own
fundamental description of computation. Then came this high-level language
which constitues a new one. It isn't "THE axiomatization of computation", just
"AN axiomatization of computation".

PG continues the story in a later essay, "Revenge of the Nerds":

"What happened next was that, some time in late 1958, Steve Russell, one of
McCarthy's grad students, looked at this definition of eval and realized that
if he translated it into machine language, the result would be a Lisp
interpreter."

"This was a big surprise at the time. Here is what McCarthy said about it
later in an interview:"

"'Steve Russell said, look, why don't I program this eval..., and I said to
him, ho, ho, you're confusing theory with practice, this eval is intended for
reading, not for computing. But he went ahead and did it. That is, he compiled
the eval in my paper into [IBM] 704 machine code, fixing bugs, and then
advertised this as a Lisp interpreter, which it certainly was. So at that
point Lisp had essentially the form that it has today....'"

"Suddenly, in a matter of weeks I think, McCarthy found his theoretical
exercise transformed into an actual programming language-- and a more powerful
one than he had intended."

<http://www.paulgraham.com/icad.html>

Pretty cool story :)

~~~
Peaker
There are more clean, consistent and interesting models of programming besides
the C and Lisp models.

The Ml/Haskell family of languages. Logic languages (though these are somewhat
subsumed by the former). Dependent-type languages.

~~~
0x12
TILs such as forth.

Smalltalk.

What family does APL belong to?

~~~
gruseom
Certainly its own family, along with its successors J and K.

~~~
Peaker
You could argue those languages are not very clean, at least syntactic-wise.

~~~
silentbicycle
Don't confuse having lots of operators with being unclean. They're
syntactically more internally consistent than Common Lisp, for example.

------
dxbydt
[http://www.cs.uni.edu/~wallingf/blog-images/code/jmc-
lisp.sc...](http://www.cs.uni.edu/~wallingf/blog-images/code/jmc-lisp.scm)

------
mjbellantoni
"As computers have grown more powerful, the new languages being developed have
been moving steadily towards the Lisp programming model. A popular recipe for
new programming languages in the past 20 years has been to take the C model of
computing and add to it, piecemeal, parts from the Lisp model[.]"

Hey! That's what I think, too!

Around 2007 when I'd had quite a bit of exposure to both Python and then Ruby
I'd started to think the same thing. Although I didn't have the foresight to
say it in a public essay I would tell my friends "In five years Javascript
will start to become a popular general (i.e. non-web only) programming
language and Lisp in 20."

I now think think the big Lisp (or Scheme) event will happen even sooner--say
in 5 to 7 years. (Meaning you will see the kinds of articles you see around
Node today on HN about Lisp.)

------
denarvaez
spanish translation [http://codigomaldito.blogspot.com/2008/02/las-rases-de-
lisp....](http://codigomaldito.blogspot.com/2008/02/las-rases-de-lisp.html)

