Newsgroups: comp.lang.lisp
Path: cantaloupe.srv.cs.cmu.edu!das-news2.harvard.edu!news2.near.net!news.mathworks.com!europa.eng.gtefsd.com!howland.reston.ans.net!gatech!rutgers!att-out!nntpa!nntpa.cb.att.com!lgm
From: lgm@polaris.ih.att.com (Lawrence G. Mayka)
Subject: Re: Why do people like C? (Was: Comparison: Beta - Lisp)
In-Reply-To: gclement@keps.com's message of Wed, 12 Oct 1994 08:59:01 -0400
Message-ID: <LGM.94Oct19083020@polaris.ih.att.com>
Sender: news@nntpa.cb.att.com (Netnews Administration)
Nntp-Posting-Host: polaris.ih.att.com
Organization: AT&T Bell Laboratories, Naperville, Illinois, USA
References: <36g8e6$2f4@relay.tor.hookup.net> <Cx5xsA.681@cogsci.ed.ac.uk>
	<781453181snz@wildcard.demon.co.uk> <hbakerCxDu55.9HH@netcom.com>
	<781909250snz@wildcard.demon.co.uk> <37ga57$9v8@disunms.epfl.ch>
	<gclement-1210940859010001@155.50.21.58>
Date: Wed, 19 Oct 1994 13:30:20 GMT
Lines: 90

In article <gclement-1210940859010001@155.50.21.58> gclement@keps.com (Geoffrey Clements) writes:

   Every time I need to hack up a quick and dirty tool I usually turn to my
   trusty C compiler and dash something off. I think most people do the same
   thing because it is easy to start coding WITHOUT a design in C.

   When you code in C++, Lisp, Smalltalk, etc. you need some kind of design
   before you can start.

   Every C program starts out like:

   main (int argc, char *argv[]) {
   }

   Then you add:

   main (int argc, char *argv[]) {

      parse_arguments (argc, argv);
   }

   Then:

   main (int argc, char *argv[]) {

      parse_arguments (argc, argv);

      do_stuff ();
      clean_up ();
   }

   There we have a nice C program without having any design or even a concept
   of what the program is supposed to do.

If you're referring to the ability to generate standalone
applications, it is true that CLOS (ANSI Common Lisp) implementations
often make the packaging of a standalone application for delivery more
difficult than typical C/C++ implementations do, especially if the
application in question is a trivial "Hello world" program, which
C/C++ excels at.

On the other hand, if you're referring to program functionality
itself, clearly the "nice C program" you cite is simply useless
baggage that CLOS avoids entirely.  CLOS already knows how to accept
and parse arguments, invoke operations on them, and "clean up" (e.g.,
garbage collection, which CLOS does automatically, or environmental
cleanup, which CLOS does via WITH- macros).  This is why the "nice C
program" requires no design: because it doesn't actually do anything
useful!  It is true, however, that mindless busy-work such as the
"nice C program" gives novices the =illusion= that they are getting
useful work done.  This =illusion= of immediate productivity does
serve the purpose of retaining their interest and increasing their
self-esteem.

This "busy-work => self-esteem" effect I have observed even in highly
experienced programmers.  It appears that everyone has a psychological
need for repetitive ritual.  Some people satisfy that need with
religious or family-life rituals, which (I believe) actually serve
useful transcendental purposes.  Others, though, project their need
for ritual onto programming, not only wasting their and others' time
and money but also dragging down the entire industry by effectively
coercing everyone else (by reason of "popularity," or the misuse of
terms like "industry standard" and "open system") to do the same.
Very unfortunate.

   People have been talking about converting C programmers to Lisp by
   describing some of the goodies Lisp has that C doesn't. What are they? 

Essentially, CLOS offers various abstractions, and various kinds of
abstraction, which reduce development and maintenance time as well as
human-perceived complexity, thereby making software systems more
powerful, flexible, and evolvable.  The difficulty I've seen is that a
person who =likes= to repetitively program the same low-level
operations over and over doesn't really =want= such abstraction,
because abstraction reduces the busy-work that provides her/him with
self-esteem.

   Can you write a Photoshop plugin in Lisp? An INIT? A cdev? These are the
   things I normally do to make a living. People use the tools that let them
   get their job done. If I was writting a large simulation or testing
   programming language designs I'd probably use Smalltalk or Lisp.

If everyone had the freedom to use the best tool for the job, the
programming industry would be a much better place.
--
        Lawrence G. Mayka
        AT&T Bell Laboratories
        lgm@ieain.att.com

Standard disclaimer.
