Newsgroups: comp.lang.lisp
Path: cantaloupe.srv.cs.cmu.edu!rochester!udel!news.mathworks.com!newsfeed.internetmci.com!howland.reston.ans.net!ix.netcom.com!netcom.com!vrotney
From: vrotney@netcom.com (William Paul Vrotney)
Subject: Re: Common Lisp is dead (was: Re: Why garbage collection?)
In-Reply-To: haible@ma2s2.mathematik.uni-karlsruhe.de's message of 11 Feb 1996 01:48:53 GMT
Message-ID: <vrotneyDMn59o.526@netcom.com>
Organization: NETCOM On-line Communication Services (408 261-4700 guest)
References: <rvillDL4v3n.I8r@netcom.com> <s08wx6akhlt.fsf@lox.ICSI.Berkeley.EDU> <4eqh8l$c9f@news2.ios.com> <s08g2cu4zdg.fsf@lox.icsi.berkeley.edu> <4fjhu5$o2s@nz12.rz.uni-karlsruhe.de>
Date: Mon, 12 Feb 1996 02:22:35 GMT
Lines: 87
Sender: vrotney@netcom9.netcom.com

In article <4fjhu5$o2s@nz12.rz.uni-karlsruhe.de>
haible@ma2s2.mathematik.uni-karlsruhe.de (Bruno Haible) writes:

> Marco Antoniotti <marcoxa@lox.icsi.berkeley.edu> wrote:

> >
> > But since we are at it, I want to complete the list of penances that
> > have been required from me. (Please assume the warning is repeated here).
> >
> > ...
> >
> > 3 - Common Lisp is dead.
> 
> The king is dead, who's the next king? Let's try it:
> 
> "Hurray! Long live ISLisp!"
> 
> Well, ISLisp is not accepted because it doesn't come with C++ syntax.
> So let's try it this way:
> 
> "Hurray! Long live Dylan!"
> 
> But Dylan is suddenly already dead as well. How come? Never mind, let's try
> it this way:
> 
> "Hurray! Long live Java!"
> 
> Seems to be for real this time. But: Where are the macros?
> 
> Dazed and confused.
> 

Please don't be dazed and confused to the point of giving up on Lisp, we
need your dedication.  And thank you for your contributions.

I look at it this way.  Lisp is the ONLY language that is STILL ALIVE (after
all these years)!  I am still making a living writing Lisp programs as well
as a number of other people I know.  Not a lot, but Lisp certainly is not
dead by any means, and there is a good chance that it will be rediscovered
and thrive in the 21st century.  The reason for this is that most currently
popular languages have and are discovering ideas that Lisp has already (not
to make a pun) addressed, but have not combined all of the ideas cohesively
as Lisp has done.  I see most of these popular languages as addressing a
specific need and not a more general programming problem as Lisp has
addressed.  If you solve somebody's specific problem with a specific
solution you are guaranteed short term success with that solution but not
necessarily long term success.

Perhaps not directly addressing your bedazzlement with Dylan and Java but
maybe some help to someone, I predict the "Static Typing" argument, which in
my opinion is the root of the current practical argument against Lisp with
any substance, will peter out in the near future.  The reason being that it
is probably too hard for code analyzers to do a perfect job.  And if it is
not perfect then it is not good enough to merit dealing with the
difficulties associated with it.  The best written complex C++ programs,
from my experience, will eventually break unpredictably.  Code "purifiers"
do a pretty good job, but once again they are not and probably can not be
made perfect, and hence the same argument applies.  One of the difficulties
with Static Typing is that it impedes natural programming constructs that
support generality and hence further abstraction.  Programmers have now seen
complex C++ projects fizzle due to becoming unmanageable from the standpoint
of building higher level abstractions simply because of the weight of the
artificial tricks built into the class hierarchy.  These artificial tricks
are there simply to support the Static Typing pedantics, ie. in a
Dynamically Typed system they would not be there.  C++ programmers,
including myself, are quite proud of these tricks when we discover them.
But basically we are all fooling ourselves and avoiding the higher level
view of things.  Even the definition of the C++ language itself has to use
some artificial tricks for the language to be usable, but these make the
language itself more complex and harder to learn.  Virtual Functions and
Templates are two good examples of such tricks.  Clever, but unnatural and
necessary only to satisfy the Static Typing pendatics.  Virtual Function
implementation in Lisp for example is just one of many ways to do dynamic
type dispatching, but it is not required in the definition of the language.
And Templates can be completely avoided.  I'm still waiting for a GOOD
solution for heterogeneous container classes in C++, something you don't
even have to think about in Lisp.

So to sum up, I say

        "Hurray, long live Lisp!  But put up with specific solutions in
         the mean time."


-- 

William P. Vrotney - vrotney@netcom.com
