Newsgroups: alt.lang.design,comp.lang.c++,comp.lang.lisp
Path: cantaloupe.srv.cs.cmu.edu!nntp.club.cc.cmu.edu!hudson.lm.com!news.pop.psu.edu!psuvax1!uwm.edu!spool.mu.edu!sgiblab!pacbell.com!att-out!nntpa!nntpa.cb.att.com!lgm
From: lgm@polaris.ih.att.com (Lawrence G. Mayka)
Subject: Re: Comparing productivity: LisP against C++ (was Re: Reference Counting)
In-Reply-To: det@sw.stratus.com's message of 20 Dec 1994 17:54:34 GMT
Message-ID: <LGM.94Dec21092505@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: <19941203T221402Z.enag@naggum.no> <BUFF.94Dec15103904@pravda.world>
	<D0xAIp.3Dn@rheged.dircon.co.uk> <vrotneyD11MDv.Ks7@netcom.com>
	<vogtD12y8D.HLL@netcom.com> <3d5alh$6j7@celebrian.otago.ac.nz>
	<3d6s2q$h20@jabba.ess.harris.com> <3d75oq$r1q@transfer.stratus.com>
Date: Wed, 21 Dec 1994 15:25:05 GMT
Lines: 42
Xref: glinda.oz.cs.cmu.edu comp.lang.c++:104366 comp.lang.lisp:16133

In article <3d75oq$r1q@transfer.stratus.com> det@sw.stratus.com (Dave Toland) writes:

   I don't think anyone would argue against the statement that a small program
   in C++ takes more design and planning than one in C, or Lisp.  But when
   the program gets larger, the pieces tend to fit together with fewer
   deleterious interactions than programs written from a procedural
   mindset.  On the other hand, Lisp takes a functional approach, with
   procedural features tacked on to the language after.  My question
   really comes down to, "Does the functional approach of Lisp scale up
   as well as the OO approach of C++ (and other OO languages)."

Let me bring you up to date: Flavors, a first-generation
object-oriented programming system that included multiple inheritance
and method combination, was added to MIT Lisp around 1979, began
selling commercially in 1981, and was subsequently adopted as a de
facto standard by major Common Lisp vendors.  CLOS, a
second-generation OOP system that adds multiple-argument dispatch
capability, was voted into the draft ANSI standard for Common Lisp in
1988 following an experimentation period, and was subsequently folded
into all major commercial and free-of-charge implementations,
replacing Flavors.  ANSI should be proclaiming the Common Lisp
standard officially within a few weeks from now.

In ANSI Common Lisp, every information element is an object, belonging
to a class.  Classes form an inheritance lattice, and can be
meta-classified as built-in (not further inheritable), structured
(extendible via single inheritance), and standard (extendible via
multiple inheritance).  Methods can specialize on any class, including
built-in classes, as well as on individual objects.  Methods can
specialize on any or all of their required positional arguments, not
just the first.  Most major Common Lisp implementations also support a
meta-object protocol which permits the extension of the OOP system
itself.

In short, the Common Lisp community actually has more experience with
the OOP paradigm than perhaps anyone else.
--
        Lawrence G. Mayka
        AT&T Bell Laboratories
        lgm@ieain.att.com

Standard disclaimer.
