Newsgroups: comp.lang.lisp
Path: cantaloupe.srv.cs.cmu.edu!das-news.harvard.edu!news2.near.net!MathWorks.Com!news.duke.edu!news-feed-1.peachnet.edu!gatech!swrinde!cs.utexas.edu!uunet!sytex!smcl
From: smcl@sytex.com (Scott McLoughlin)
Subject: Re: Comparison: Beta - Lisp
Message-ID: <sooRsc1w165w@sytex.com>
Sender: bbs@sytex.com
Organization: Sytex Access Ltd.
References: <35cqdb$4k4@spool.cs.wisc.edu>
Date: Fri, 16 Sep 1994 22:37:15 GMT
Lines: 90

schumach@ricotta.cs.wisc.edu (Lee Schumacher) writes:

> Of course from the faculties point of view, they don't want to teach
> lisp (thats manual labor, to their eyes), they want to teach AI.  The
> end result is that lisp gets shorted in school, so when the graduates
> of this program get out into the real world lisp is never seriously
> considered for any job at hand - its too esoteric, too academic, too
> damn *hard*...
> 
> sadly,
> 	 Lee ...
> 

Howdy,
        Ok - to sum up as best I can you're reply (thanks):  Lisp is
not used "in the trenches" (not particularly time/space intensive apps -
about 95% of the code hacked out there) because Lisp is not taught well
to CS types in college. It is therefore "too hard" a language to use.
        I'm not sure that I agree.

1. Scheme seems to be an increasingly popular intro CS language. ML
also seems popular (maybe this is irrelevant, but I think of ML as
"same family" as Lisp/Scheme).

2. C and especially C++ are _very_ hard languages to learn. I've lost
count of the times I've explained pointers/arrays to budding C/C++
programmers. Whatever one thinks of coding style and/or what a compiler
_should_ do, all the C code I've looked at or hacked is full of
while(*p++) if (*p==MG_COOKIE) then foobar((CAST_TYPE)p+offset)
etc.  Understanding this type of code (bouncing back and forth between
application level and machine level semantics) is _REQUIRED_ of C/C++
programmers in the trenches.

3. 4GL's, various BASIC dialects, Turbo Pascal and the now ubiquitous
giant Windows API are, in my experience, _NOT_ taught in colleges (not
widely anyway).  Programmers in the trenches learn this stuff from
_BOOKS_ and/or from training sessions and/or "on the job". Visual Basic
is a pretty giant beast (not your old Apple BASIC) with all kinds of 
weird special cases and options.  Variable scoping is downright weird
(Form level variables), etc.  But this is tossed at folks with a 2
year community college degree.  Most folks program with one eye on
the manual or online help.

4. Given (2) and (3) above, there are _lots_ of nice Lisp books. 
Furthmore, Lisp and Scheme are much cleaner regarding heap objects
(vectors, strings, cons cells).  Why aren't folks hacking Lisp with
one eye on Wilensky or Winston/Horn or Simply Scheme????

Here is an initial conjecture:

1. Cost of commercial implementations. Plain and simple. Look at
PowerBuilder and Gupta SQL Windows. Obaining market share requires
a low cost implementation. (Personal Eiffel, also - $49)  Free is
generally no good "in the trenches".

2. Nasty file/io.  Folks want/need to write files of structured
data types and read them back in without thinking too hard about
it, e.g. pascal's FILE of RECTYPE or C's fwrite(f,&s,sizeof(RECTYP)).
Lot's of simple file/io in the trenches.

3. Nasty looping constructs.  Hard to hack DO looking at the
manual.  LABELS and LETREC are elegant, but complicated. DOTIMES and
DOLIST are a step in the right direction. There should have been
a CL standard WHILE/UNTIL for "bootstrapping" nincompoops (sp?).
LOOP is newer and not so widely used and/or written about. Otherwise
LOOP is fine.  Of _course_ Lisp has superior looping/iteration 
constructs, but it takes new comers a few months to realize this.

4. Doesn't fit in well with popular version control products. Even
small, unsophisticated shops will use PVCS or a similar product.
Edit/Compile/Link/Debug works well with these products. This is
not a killer though -- only "sophisticated" trench shops rely
on VC.

5. Money (BCD) and Date types. Lots of trenches proramming is about
dates and dollars.  VB has a gadzillion date and money formatting
operations/options. Of course, C and Pascal don't have these, so these
are not necessarily "killers". C/Pascal "trenches" programming tends to
be full of rounding errors, etc. because of the absence of these types.

Anyway, these are probably "sufficient" conditions to keep Lisp from
being "popular" in every 1-4 dude(tte) project that goes on across
the U.S. in suburban green wall-to-wall carpet corporate and govt.
offices.  It's too bad.  These folks could _really use_ a Lisp.
More of these projects might succeed/survive.

=============================================
Scott McLoughlin
Conscious Computing
=============================================
