
Lisp Machine Manual (1984) - sillysaurus3
https://hanshuebner.github.io/lmman/title.xml
======
DonHopkins
The cover of the Lisp Machine Manual had the title printed in all caps
diagonally wrapped around the spine, so on the front you could only read "LISP
CHINE NUAL". So the title was phonetically pronounced: "Lisp Sheen Nual".

My friend Nick made a run of custom silkscreened orange LISP CHINE NUAL
t-shirts (most places won't print around the side like that).

[https://www.facebook.com/photo.php?fbid=74206161754&l=54ec4e...](https://www.facebook.com/photo.php?fbid=74206161754&l=54ec4efc30)

I was wearing mine in Amsterdam at Dappermarkt on Queen's Day (when everyone's
supposed to wear orange, so I didn't stand out), and some random hacker (who
turned out to be a university grad student) came up to me at random and said
he recognized my t-shirt!

[http://www.textfiles.com/hacking/hakdic.txt](http://www.textfiles.com/hacking/hakdic.txt)

CHINE NUAL (sheen'yu-:l) noun.

The reference manual for the Lisp Machine, a computer designed at MIT
especially for running the LISP language. It is called this because the title,
LISP MACHINE MANUAL, appears in big block letters -- wrapped around the cover
in such a way that you have to open the cover out flat to see the whole thing.
If you look at just the front cover, you see only part of the title, and it
reads "LISP CHINE NUAL"

~~~
toomanybeersies
Link to an image of the manual, for the lazy:
[https://c1.staticflickr.com/1/101/264672507_307376d26c_z.jpg](https://c1.staticflickr.com/1/101/264672507_307376d26c_z.jpg)

~~~
flavio81
Thanks for this! Looks elegant.

------
fusiongyro
The classic joke in here is that if you look up "fascism" in the index, it
goes to the section about logging in. User authentication wasn't part of the
dream, so having been forced to build it, they embedded a dig on it right in
the manual.

[https://hanshuebner.github.io/lmman/files.xml#fascism](https://hanshuebner.github.io/lmman/files.xml#fascism)

I think there are a few other jokes in the index but I don't recall what they
are.

~~~
Animats
That was probably Stallman's doing. He wrote most of the LISP machine code.

~~~
lispm
> He wrote most of the LISP machine code.

That's nonsense. The Lisp Machine code was written by several people, some
which had significant contributions.

~~~
ScottBurson
Indeed. Before they left to found Symbolics, David Moon, Howard Cannon, Dan
Weinreb, and others (I'm sure I'm forgetting at least one name) wrote the vast
bulk of the system. I think Richard Greenblatt wrote most of the microcode (he
also did most of the hardware design and construction).

After Symbolics formed, RMS did an amazing job at reimplementing many of the
new features Moon and company were adding, so as to keep the MIT version of
the system at rough parity with the Symbolics version. So his name belongs in
the story, but not first.

~~~
Zigurd
The MIT version was commercialized, too. Lisp Machine Inc. employed Stallman
and Greenblatt, and was back primarily by Texas Instruments.

~~~
erikj
Both Lisp Machines Inc. and Symbolics were selling the MIT version before
redesigning it into their own brand new products, the LMI-LAMBDA and the
Symbolics 3600.

------
feelin_googley
"I believe the commercialization of software has harmed the spirit that
enabled such systems to be developed."

------
davexunit
A not-so-close approximation to using a Lisp Machine these days is to use the
GuixSD distro. It features a package manager, init system, and initial RAM
disk all written in Scheme. Combine that with Emacs, the guix-emacs extension,
and, if you are so inclined, a Lispy WM like StumpWM and you have a system
where a large number of critical components are implemented in Lisp.

------
hoodoof
There seems to be plenty of people who think Lisp is awesome.

If so, then why hasn't it become "mainstream"?

~~~
dwheeler
Asbestos suit on.

There are many positive things you can say about Lisp.

However, _many_ day-to-day developers, and their managers, believe that Lisp's
syntax creates nigh-unreadable programs. For example, there's no built-in
infix syntax, as opposed to practically all other programming languages, and
many modern programmers today expect infix as minimum table stakes for a
language. Lisp syntax is extremely _simple_ , but that doesn't mean the
resulting code is easily read. Very smart people will _disagree_ with that
opinion - especially a number of people on Hacker News!! However, just look up
phrases like "lots of irritating silly parentheses" and you'll see that this
opinion is extremely widespread. Many people here will _disagree_ with the
sentiment, and that's fine, but it's a _fact_ many people believe programs in
Lisp syntax are hard to read.

A lot of people will reply that Lisp's syntax is simple, that real programs
have been written in Lisp, that it has a kind of simplicity/elegance, and that
Lisp syntax enables powerful facilities like Lisp macro processing. All of
that is absolutely true. Lisp is quite powerful. But trying to convince people
that Lisp is "advanced", even though it doesn't support basic capabilities
like infix out of the box, is a losing battle. Forth is one of the few other
languages that has an odd syntax and lacks support for infix, and it is also
rarely used today.

Feel free to reply, but thoughtful responses preferred :-).

~~~
ScottBurson
The odd thing about the fully parenthesized syntax is that it's offputting at
first, but once you've been doing it for a little while, _in an editor that
does parenthesis matching and auto-indentation_ , it gets to be just as easy
and pleasant to work with as more common languages, or even more so. (Packages
like Emacs 'paredit' make it even better. (I haven't tried 'parinfer'.))

I understand this is hard to believe if you haven't tried it, and it certainly
does take some getting used to. Lisp is, in short, an acquired taste. Think of
it like very spicy food: many people avoid it, but those of us who like it,
like it _a lot_.

~~~
dreamcompiler
Completely agree. Lisp code I wrote 10 years ago is still _very_ readable to
me. It makes perfect sense once you're "over the hump" but you gotta make that
investment.

Contrast this with Forth, which I was at one time equally expert at, and where
I could rarely read my own code 10 _days_ later.

~~~
abecedarius
The biggest reasons for this are local variables vs. stack ops and
parenthesized expressions vs. having to know the arities of the words called.
You can add local variables to Forth, but afaik nobody did during its heyday;
and "phrasing" your code with whitespace can help some on the latter issue,
but it's admittedly not as explicit as parens.

(From another one-time Forther and more recent Lisper.)

~~~
dreamcompiler
Mach 2 Forth for the Mac in the late 80s had local variables and when I wrote
a Forth compiler for the TI 34010 I included local variables. They helped a
lot, but they still don't make Forth as readable as Lisp.

------
Chaebixi
If you have NoScript and Firefox, you have to enable JS on the domain for the
stylesheet to render the documents.

------
SirFatty
"Those not on the Arpanet may send U.S. mail to.."

Ah.. nostalgia.

