The Roots of Lisp (2002) [pdf]

http://slackwise.net/files/docs/The%20Roots%20of%20Lisp.pdf

by malisper • 12 years ago

57 11 12 years ago

frownie• 12 years ago

Not to sound smart ass but I got that in 1996 when I was fortunate enough to have a course on Scheme by D. Ribbens here at Liege University in Belgium. He showed us how to build that very interpreter and how powerful it was (he used to say : forget about algorithms or OOP, here's the truly powerful stuff :-) ). Since then I contemplate the slow evolution of languages, leaning to functional programming (although Scheme is not FP, that's for sure).

That said, what could be taught to a young student today that would provide the same kind of enlightenment I had with those few pages of list(p) ?

pjmlp• 12 years ago

Funny I also got some enlightenment in the same year but with Caml Light and Prolog with a little Smaltalk on the side (VisualWorks). At Nova University in Lisbon.

And that was just the beginning as my university had a few lectures that made use of them, since a few of the major teachers were quite into FP and LP communities.

Then I had to traverse the desert of mainstream languages, until being finally allowed to use such concepts on the programming languages I work with.

Slackwise2• 12 years ago

I used ps2pdf[1] to make a cleaner/better version from the original PostScript[2] file from Paul Graham's site[3]:

http://slackwise.net/files/docs/The%20Roots%20of%20Lisp.pdf

The tracking/kerning is still off, but not as much. It's definitely easier to read than the one linked in this post. Anyone know a better utility, or is the source PostScript just poorly typeset?

Edit: I've just applied pkfix[4] to the file as mainland recommended[5], and it looks wonderful! I've replaced the file on my server, so you can Ctrl-F5 it to see the wonderful crisp text.

[1] http://ghostscript.com/doc/current/Ps2pdf.htm [2]: http://lib.store.yahoo.net/lib/paulgraham/jmc.ps [3]: http://www.paulgraham.com/rootsoflisp.html [4]: http://ctan.mackichan.com/support/pkfix/pkfix.pl [5]: https://news.ycombinator.com/item?id=8350995

mainland• 12 years ago

Using pkfix before ps2pdf will improve the final output---it replaces bitmap fonts with Type 1 fonts.

Slackwise2• 12 years ago

That is amazing. I've gone and used pkfix and updated the file. It looks perfect now. Thanks!

dang• 12 years ago

Since that's more readable, and since the original url (http://www.cs.uml.edu/ecg/pub/uploads/OPLspr09/genesis-of-li...) wasn't canonical, we updated it to yours. Thanks!

drostie• 12 years ago

I've on more than one occasion used Lisp's "everything is data" idea to build little domain-specific languages in JSON. One of the easiest places to start is with representing HTML this way; you can e.g. start to write the Python or JS code:

    ["table", ["tbody", ["tr", ["td class=first", 1], ["td", 2]]]]

instead of:

    <table><tbody><tr><td class="first">1</td><td>2</td></tr></tbody></table>

A really early attempt at this is: https://github.com/drostie/d.o/blob/master/build.js but I haven't maintained it in a while.

If you're interested in language design, there appears to be a "little gap" which means a lot between a Lisp data structure and an XML data structure: In XML's view, every list's first element is a string; in Lisp's, it can be anything. This little gap actually corresponds to one of the interesting habits which has disappeared since compilers took over our assembly-writing: it used to be the case that programmers would sometimes compute an instruction code for the next instruction; similarly in Lisps you sometimes (but not too often; it's confusing!) compute a function for your next operation.

If that confuses you because you're not good with Lisp, it's equivalent in Python or JS is:

     (f(x, y, z))(a, b, c)

so that you figure out which function to call and then immediately call it on some parameters. It's not necessarily a difference in expressiveness, as the XML-style just can add an atom 'call' which expresses the above as:

    call(f(x y z) a b c)

but it does seem to correspond to some deeply different philosophy for the system.

davexunit• 12 years ago

Your JSON snippet is reminiscent of SXML, a format for describing XML/HTML as s-expressions. The difference being that, using quasiquote and unquote, Lisps are full-fledged templating languages.

Here's a simple template written in Scheme:

  (define stuff '("foo" "bar" "baz"))
  
  `(ul (@ (class "foo"))
       ,@(map (lambda (thing)
                `(li ,thing))
              stuff))

Output:

  (ul (@ (class "foo")) (li "foo") (li "bar") (li "baz"))

Fun stuff!

zwp• 12 years ago

representing HTML

The Roots of Lisp (2002) [pdf]

Related Stories