
Doug McIlroy: McCarthy Presents Lisp - pg
http://www.paulgraham.com/mcilroy.html
======
gcv
I just finished reading the LISP 1.5 Programmer's Manual (still readily
available from Amazon), published in 1962. The book is mind-blowing, because
it mixes discussions of high-order functions with instructions on how to
properly lay out programs on punch cards.

The "high level language" which shipped on every microcomputer platform of the
1970s and 1980s was Basic. I have often wondered why. Compared to Lisp, it is
inelegant and inexpressive. Perhaps people who hacked larger computers of the
era did not interact with microcomputer hobbyists. Perhaps it was too
difficult to get Lisp fast enough to be usable on the old hardware, although
if it was possible on big iron in the late 1950s, it should have also been
possible on microprocessors in the 1970s.

An entire generation of programmers grew up using GOTO _< line number>_ to
call subroutines and execute loops. That same generation could have grown up
using lambdas. How sad.

~~~
adamo
LISP 1.5 Programmer's Manual (and others) in PDF:
<http://www.softwarepreservation.org/projects/LISP/book>

~~~
silentbicycle
Nice link! There are PDFs of old APL texts, too.

------
grosales
An excerpt from The Dream Machine:

"As a Lisp programmer continued to link simpler functions into more complex
ones, he or she would eventually reach a point where the whole program was a
function-which, of course, would also be just another list.. So to execute
that program, the programmer would simply give a command for the list to
evaluate itself in the context of all the definitions that had gone before,
And in a truly spectacular exercise in self-reference, it would do precisely
that. In effect, such a list provided the purest possible embodiment of John
von Neumann's original conception of a stored program: it was both data and
executable code, at one and the same time

In Mathematics, the technical name for this sort of thing is recursive
function theory, which was why McCarthy called his first public description of
Lisp 'Recursive Functions of Symbolic Expressions and Their Computation By
Machine' Today ranked as one of the most influential documents in the history
of computer languages, that paper established that a language could have a
rigorous mathematical foundation. And it signified that John McCarthy had
finally come up with a framework that was precise enough, rigorous enough, and
compelling enough to satisfy even him"

His paper can be found here: <http://www-
formal.stanford.edu/jmc/recursive.pdf>

I am just amazed how often his name appears on this book (the first time he is
mentioned, Waldrop talks about how strange people said he is). But in my book
he will always be a legend and a visionary.

~~~
ieure
I read that paper around six months ago. I found it a little dry at first, and
then absolutely enlightening. It's amazing what beautiful and complex things
can be built with such a small handful of functions.

------
Keyframe
I always wondered why Lisp is dead in the water. I got replies from people
that never professorially coded anything in Lisp or Scheme (yeah..) - argument
was along the lines that in the past hardware was always dictating lower level
languages and leagues of people were taught the ways of the everyday code that
was only a few (if any) levels above the hardware. Thus, all of the primitives
of the age (ASM, C, Pascal, whatnot).

However, I don't think that is the main story here. It sure is a big part, but
not main for sure. I mean, there were LISP systems in usage at the big boys
houses where money/hardware was no object. Later on, Moore law brought us
supercomputers of the past to our desktops and we got C++, Java and Python;
Even Ada was formed and deployed.

So, what's the deal? My primary focus in life has been computer graphics, and
my first language was C. I was born in 1980 and my early serious computer
endeavor is inherently tied to the Amiga platform (SAS C and alike), so I
didn't have exposure to other language paradigms at all until later.

Later on, through a marvelous turns of event I was exposed to Scheme and at
first I didn't "get it" - but there was this epiphany moment or two where I
could see almost everything I needed in computer language for my needs, yet it
was so simple.

Not to bore you more with details - I always wanted to get into game
development. Career of TV and Commercials direction happened in the mean time,
and now I am back into making my game development ideal a reality. My weapon
of choice is D/Tango, since it really best suites my mindset. However, after
seeing a PPT/PDF from naughty dog earlier this year about how they have
utilized an embedded PLT Scheme, I came to wonder once again about maybe using
Scheme as a scripting language after all.

tl;dr; Can anyone, preferably a pro Lisp or Scheme developer give a rationale
why it isn't used more often? Everything I've read makes absolutely no sense
why it isn't. Oh, and about the python argument that gets thrown around - I
like the python as the next guy, but let's not fool ourselves.

</rant>

~~~
derefr
I'm not a pro Lisper, but I think reasons offered for this include:

* The AI winter (with Lisp, at the time, being seen as "the AI language")

* The heavy-cost and closed nature of the toolchain, and lack of standardization between toolchains, when industry was searching for a language to rally behind several decades ago

* The continued lack of standardization on all the "included batteries" when the open source movement was looking for languages to adopt for scripting a decade ago

* The deep semantic rabbit-hole a Lisp codebase can turn into when any macro-like functionality is used, meaning that a programmer has to basically learn every project as its own language (that is, DSL) before they can get to work—further meaning that projects grow a sense of individual stewardship/artistic direction, and become harder to work on by hiring committees and one-off contractors

* The continued outside impression of Lisps as slow, pure-functional and academic (even though most today are none of those)

* The unwillingness for most Lisps to embrace the Unix philosophy (meaning that it's easier to write a web browser in e-lisp than to loosely couple to one already written in some other language. Clojure is basically the only Lisp that escapes this, cleanly interoperating with the APIs of other languages... on the JVM, which itself throws Unix design principles out the window.)

I'm sure there are more well-founded answers, but all of those came to mind on
my road to accepting Lisp.

~~~
silentbicycle
Your point about "embrac[ing] the Unix philosophy" is a good one. Probably not
the biggest factor for mainstream adoption, but significant nonetheless. While
there are some Lisps now that that do this well (particularly those that
compile to C, such as Chicken Scheme), it has a big historical precedent.

I've been wondering how Lisp would look if it were redesigned from the ground
up to include Unix's philosophy, and I'm beginning to think that Erlang would
be a good candidate. (With a healthy dose of Prolog as well.)

~~~
mononcqc
Check out Lisp Flavored Erlang for a lisp developed on the Erlang VM.
<http://github.com/rvirding/lfe>

~~~
silentbicycle
Thanks! (erlog in his other projects looks good too.)

------
raghus
_It occurred to me recently that 1959 is the 50th anniversary.._ \- did you/he
mean 2009 is the 50th anniversary? The talk presumably was in 1959.

------
dca
* It turned out you could do it: I programmed it for the IBM 704.*

Anyone else find this comment motivating? It kind of sums up a moment of
reflection I guess I somehow aspire to. Find an insanely difficult challenge,
that you deem important enough to devote a significant amount of time and
energy to, and then one day: "It turns out you could do it: I programmed it
for the _${preferred architecture}_." Thanks Doug^H^H^H^H hold on - didn't
Steve Russell implement McCarthy's original Lisp on the IBM 704 - not Doug
McIlroy. What am I missing that pulled me away from my moment of zen here?

~~~
gruseom
I took him to mean that he had programmed a subroutine that could call itself,
but only as a curiosity, and that it was McCarthy's talk that made it clear
for the first time what was important about recursion.

Speaking of Steve Russell, does anybody know what became of him? It's
extraordinary that he wrote both the first Lisp interpreter and the first
computer game.

~~~
leoc
And continuations, apparently. As of 2002, he was apparently working in
embedded for Nohau Corporation:
[http://www.nytimes.com/2002/02/28/technology/a-long-time-
ago...](http://www.nytimes.com/2002/02/28/technology/a-long-time-ago-in-a-lab-
far-away.html?pagewanted=2)

~~~
gruseom
That's a really interesting article about the guys who created Spacewar. I
hadn't realized, for example, that there were six of them. Anyway, you should
post it in its own right.

