C vs. Lisp, or UNIX vs. Genera, or just US vs. THEM

[magerman@Neon.Stanford.EDU]

I have watched the mail go back and forth with discussions and interpretations
of the relative merits of C and Lisp, and also of UNIX and Genera (although
more of the former than the latter).  I understand the fervent defense of the
Lisp machine and language against UNIX and C.  A few years ago, when I was
introduced to the Symbolics lisp machine, I too thought the Lispm was the
neatest thing since sliced bread (although I admittedly prefer whole loaves).
The user interface was and is the most facile and effective I have encountered.
The complexity of the window system is amazing, and yet it is so easy to
program its features.  Compared to it, X seems virtually unusable, from a
programming viewpoint.  And the presentation system, combined with
mouse-capabilities (especially the ever-present mouse-documentation line),
shows that X has a long way to go.

But just as X can (and should) learn from Genera, Genera must recognize its
failings in comparison to X.  X is lightning fast, especially compared to
Genera.  I've waited almost minutes to switch from one DW to another and
to refresh.  X windows can be opened and closed and switched usually
instantaneously.

What does this have to do with this discussion?  Well, the point is
that if you don't learn from the pluses and minuses of every environment, then
there can be no improvement.  Sure, lisp is great.  So is C.  I wish I could
defend C better, but I am half lisp-hacker and half C-hacker, so it is hard
for me to fight one against the other.  I considered cross-posting this
whole discussion to comp.lang.c, but I didn't think slug would want to deal
with the volume of traffic that would cause, much less the reality of it all.

UNIX/C extols (or tries to anyway) standardization with low cost.  Genera/lisp
promotes extreme abstraction.  But you *must* recognize that there is a high
cost to abstraction.  By building up abstracted window data types, where a
simple function means an incredible number of different things depending on
what window you are talking to, the basic window operations which must be
performed in *every* phase of computer usage are guaranteed to be slow.  You
have to deliberately bypass these window hierarchies to get fast windows.
I had to do this once in order to create a large array of scrollable windows.
I would have had to rewrite scrolling and redisplay in order to do this.
X may be more complicated to use, but by using the standard mechanisms for
windows in X produces fast windows.  You have to bypass the normal window
system to get fast windows in Genera, if that is possible.

I am sure someone can shoot down this claim with an example of a fast-windows
application under Genera.  But that's not the point.  I'm trying to give an
example of how both window systems can learn from each other.  The same is
true with languages.  If you stand up and proclaim, "C programming is only
useful for trivial tasks, by definition," you can't possibly learn from C.

C is a useful language.  UNIX is a powerful operating system.  You can dismiss
then both if you want, but you will cut yourself off from a large segment of
the computer science and programming community.  Accept them and you and the
community gain.

-- David Magerman
Stanford University

P.S. - If these comments offend anyone, seem obnoxious, or are totally obvious,
I apologize.  Late at night, I get *very* blunt, and even more verbose.
I just hate to see people dismiss C and UNIX without experiencing it.
Learn awk and/or sed, and write a few scripts.  Then try to duplicate the
performance on a Lispm.  As much as I loved the Lispm's, UNIX tools taught me
to love UNIX.  Don't knock it until you've tried it.