
Performance and Evaluation of Lisp Systems (1985) [pdf] - mpweiher
http://rpgpoet.com/Files/Timrep.pdf
======
norswap
This is by Richard Gabriel, who coined "worse is better"
([https://www.dreamsongs.com/RiseOfWorseIsBetter.html](https://www.dreamsongs.com/RiseOfWorseIsBetter.html)).
He's also the author of Patterns of Software
([https://news.ycombinator.com/item?id=13799628](https://news.ycombinator.com/item?id=13799628)).

Incidentally I just finished reading it and found it quite fascinating.

~~~
tmccrmck
Could you write about what you found fascinating? I read through the first 10
pages and it was mostly about how system architecture applies to Lisps.

As someone who has written the back-end of a compiler, I was surprised to
learn that roughly 25% of execution time is building stack frames for a caller
and a callee.

~~~
norswap
Poor writing, I meant that Patterns of Software was fascinating. I'd be
interested to give a glance to the above though, precisely for insights like
that which you highlighted.

I'm not surprised at all. Java has the same kind of situation going on, and
its performance depends on the ability of the JIT compiler to kick in and
perform inlining. When this is not possible (e.g. calls sites where you call a
virtual method with many implementations), performance degrades a lot. This is
especially bad with interfaces, which have intrinsically higher costs.

As for Lisp, it can be even worse if you take things like multimethods into
account.

------
samth
The benchmarks gathered for this book continue to be incredibly significant
(though not really for good reasons) 30+ years later. Quite remarkable.

~~~
mpweiher
OK, curiosity piqued: why not really for good reasons?

~~~
samth
The translation of these programs to JS via a translation to Scheme turns out
not to end up reflecting modern programs.

------
daliwali
I think one of the reasons why C became popular in industry and Lisp didn't,
is because Lisp is harder to translate into efficient machine code. C was
closer to how the hardware works. In the earlier days, specialized hardware
was built to run Lisp code: Lisp Machines. When computers were sufficiently
fast enough, the specialized hardware was no longer necessary.

The software industry could have been vastly different, if Lisp took off
instead of C, which I think had more to do with business, culture, & politics
than the technology itself.

~~~
pjmlp
Not really, Lisp Machines were expensive, UNIX was free with a plain symbolic
license during the AT&T was prevented from selling it.

If UNIX had a price tag similar to all other OSes, the revolution would never
have happened.

~~~
DonaldFisk
I don't think it's that simple.

Until the 1980s, there were various different hardware architectures, each
with its own operating system. Their manufacturers sold mainframes/mini-
computers which came with the operating system installed. The operating
systems weren't portable, and were included in the price of the hardware.

Unix was originally developed for the PDP-11, and written in C, which though
influenced by the PDP-11 architecture was at the same time low level and
machine independent.

BSD Unix was available for the DEC VAX, and could be run instead of DEC's VMS.
Back then, this was most people's first experience of Unix. Franz Lisp was
included with BSD Unix.

Around this time, the market for proprietary mainframes was collapsing, so
there wasn't much demand for their operating systems (or for people with
experience with them). New manufacturers, e.g. Sun and Apollo, entered the
market with workstations running either Unix or Unix-like systems. Vaxes were
still around, by now often running Unix instead of VMS. Anyone manufacturing
new hardware had the choice of developing a proprietary operating system,
which was a lot of effort and would die with the machine, or porting Unix to
it.

The Lisp Machine market collapsed for various reasons which are reasonably
well-known. Lisp lives on, but was always a niche language, and there are
various explanations for its lack of popularity. It was never really an
alternative to C, which is a lot lower level.

~~~
pjmlp
> BSD Unix was available for the DEC VAX

Which only happened thanks to the AT&T tapes that were taken to Berkely, and
the work of Bob Fabry.

If it wasn't for that, BSD Unix might never have happened.

> Anyone manufacturing new hardware had the choice of developing a proprietary
> operating system, which was a lot of effort and would die with the machine,
> or porting Unix to it.

Because UNIX's source code was available under a "cheap" license.

If it was an AT&T product like those mainframe OSes, that would never been a
path they would take.

~~~
DonaldFisk
Portability was important for Unix's success. The other operating systems were
free (as in beer) but wouldn't run except on the expensive machines they came
on. ITS could have been free, and wasn't proprietary, and was (at the time) a
better development environment than Unix, but it was limited to PDP-10s.

MS-DOS was proprietary but was more popular than Unix, because it ran on even
cheaper hardware.

~~~
pjmlp
Nothing prevented the other companies to port their OSes, many of each were
implemented in variants of Algol and PL/I, they just didn't saw a business
value in doing so, and thus lost to the availability of an almost freely
available OS, that universities which didn't want to pay for mainframe OSes,
adopted to their existing computer labs, instead of getting more licenses.

Students at those universities then picked UNIX for their startups, for the
newly workstation market, like Sun did.

~~~
DonaldFisk
There were only two operating systems written in high level languages before
Unix: MCP and MULTICS. Burroughs mainframes had a 48 bit word, and Honeywell
mainframes had a 36 bit word. Burroughs and Honeywell were interested in
selling those machines, not in spending considerable effort porting their
systems to competitors' hardware with smaller word sizes. There was no
business value in doing this.

Unix, which was very much influenced by MULTICS, initially ran on 16 bit
machines. It's a lot easier to scale up (to run on Vax) than scale down, which
is why Stallman based his GNU project around Unix rather than attempt to port
ITS.

