Newsgroups: comp.lang.dylan
Path: cantaloupe.srv.cs.cmu.edu!rochester!udel!news.sprintlink.net!cs.utexas.edu!uwm.edu!fnnews.fnal.gov!gw2.att.com!nntpa!ssbunews!ssbunews.ih.att.com!lgm
From: lgm@polaris.ih.att.com (Lawrence G. Mayka)
Subject: Re: Prefix syntax
In-Reply-To: mbk@jt3ws1.seas.ucla.edu's message of 17 Mar 1995 16:15:18 GMT
Message-ID: <LGM.95Mar26160942@polaris.ih.att.com>
Sender: news@ssbunews.ih.att.com (Netnews Administration)
Nntp-Posting-Host: polaris.ih.att.com
Organization: AT&T Bell Laboratories, Naperville, Illinois, USA
References: <3jn9s4$sps@cantaloupe.srv.cs.cmu.edu> <3k09ve$b43@netnews.upenn.edu>
	<3k0gv3$jpt@cantaloupe.srv.cs.cmu.edu> <3k1t00$4gd@stc06.CTD.ORNL.GOV>
	<3k688r$38l@goanna.cs.rmit.edu.au> <3kccim$ikd@stc06.ctd.ornl.gov>
Date: Sun, 26 Mar 1995 22:09:42 GMT
Lines: 66

In article <3kccim$ikd@stc06.ctd.ornl.gov> mbk@jt3ws1.seas.ucla.edu (Kennel) writes:

   Richard A. O'Keefe (ok@goanna.cs.rmit.edu.au) wrote:

   It's the *lack* of 'irrelevant' helper words and symbols in
   a Lisp like syntax that makes it a little harder to read.

   I.e. Lisp syntax seems *too* homogeneous.  A "verb" and an arbitrary
   sequence of possibly nested lists.    Just rattling off the arguments
   in some order, which may be nested expressions themselves, is difficult. 

I actually agree with you to a significant extent.  Fortunately, ANSI
Common Lisp offers strong support for keyword arguments, which make
even the most unfamiliar argument list more readable.  Unfortunately,
most of Common Lisp's predefined library appears to use keyword
arguments only where "absolutely necessary" rather than as a powerful
aid to readability.  I think this is because (a) much of the CL
library was in common use before keyword arguments were supported, (b)
their usefulness for a given "verb" decreases as programmer experience
increases, and (c) keyword arguments exact a performance penalty on
redefinable and specializable functions [because the keywords can't be
"compiled away" as they can for special operators, macros, and
ordinary, predefined ANSI functions].  Note, however, that very few
other commercial programming languages offer keyword arguments for
user-defined functions, either.  [Ada may be the exception to this.]

The point is that support for keywords =can= be highly regular,
parsable, and extensible, as it is in ANSI Common Lisp.

   In any case there is an observational problem that needs to be explained:

    Why, after 30-35 years, is Lisp like syntax not universal?

Many inventions can be demonstrably superior to their competitors and
still fail to achieve market dominance.  I would ask a contrary
question: Why, after 35-40 years, do other programming-language
communities still find it necessary to borrow their "innovations"
(belatedly!)  from the Lisp community?

   By contrast, consider another innovation from the same time-period,
   Fortran's subroutine.  That was a good idea, and it is universal now.

Actually, the Fortran subroutine is not at all universal.
Modifications and innovations include:

- Pass by value, pass by name, and pass by value/result (instead of
Fortran's pass by reference).

- Lexical scoping of subroutines.

- Ability to recurse.

- Default arguments and keyword arguments.

- Inlining, specified and automatic.

- Method dispatch: on a distinguished argument, and on multiple
arguments.

etc.
--
        Lawrence G. Mayka
        AT&T Bell Laboratories
        lgm@ieain.att.com

Standard disclaimer.
