From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-0.8 required=5.0 tests=BAYES_00,INVALID_DATE
	autolearn=no autolearn_force=no version=3.4.4
Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!csd4.milw.wisc.edu!lll-winken!ames!zodiac!ZOOKS.ADS.COM!rar
From: rar@ZOOKS.ADS.COM (Bob Riemenschneider)
Newsgroups: comp.lang.ada
Subject: Re: Ada vs. LISP (Response to Robert Eachus's second posting)
Message-ID: <8903152108.AA06589@zooks.ads.com>
Date: 15 Mar 89 21:08:49 GMT
Sender: daemon@zodiac.UUCP
List-Id: <comp.lang.ada>

Robert:

Thanks for posting the examples.  While they may not "satisfy the skeptics",
they make the details of your claims for AdaLISP considerably clearer.  It
now seems to me that most of the "extreme" reaction was due to a 
misinterpretation of your original claim.

=>	One of the things which I did during the ANSI standardization of
=>   Ada was to look for ANYTHING in the standard which would make
=>   translation of LISP programs into Ada difficult.  There were a few
=>   problems in the early drafts, but they were all eliminated by the
=>   final draft.  As one of the problems for the AdaCan contest I proposed
=>   writing a compatiblity package to allow transliterated Common LISP to
=>   be compiled by any Ada compiler.  (There are certain LISP lexical
=>   conventions that are incompatible with Ada, but they are easily dealt
=>   with: 'a --> QUOTE(A).)  
=>
=>	The problem was eliminated from the final list as too easy, but I
=>   still recieved two proposed solutions from LISP and Ada programers I
=>   showed the writeup to! ...

I now understand you to be claiming that the bulk of most Lisp application
programs can be easily rewritten in Ada given a fairly small collection of
fairly simple library packages.  I've had some experience porting Lisp
applications to Ada, and, based on that experience, I certainly agree.
(In fact, as your examples show, it's easier to "transliterate" Lisp into 
Ada than into, say, Pascal.) 

There are exceptions, however.  Based on your latest posting, I take it
you believe "(apply (read) (read))" to be a specially concocted example,
intended to make your claim sound dubious.  It wasn't; it was a (simplified) 
example taken from an actual Lisp application.  (The program supports
interactive multi-attribute utility analysis.  Rather than having the 
user supply weights used in a linear combination of utilities across
attributes, the user is asked for an arbitrary computable function from
[0,1]^number-of-attributes to [0,1] to be used for combination.  The
designer (me) has arguments that, for many applications, non-linearity
is required.)  When time for considering translation to another language
came around, "(apply (read) (read))"--which, when expanded out to include the
syntactic analysis of the sexpr read in, etc., made up a goodly chunk of
the program--was the only really hard part.  Writing a simple Lisp-interpreter
equivalent was evidently necessary, as you observed.  I asked about
"(apply (read) (read))" because I wanted to know whether either of the
AdaLISP submissions you received contained at least a simple interpreter
of the sort you sketch in your posting.  I still want to know.

I think if you re-read the passage I quoted above, you'll see that it
could be understood as saying that translation of virtually *any* Common 
Lisp program into Ada is easy, since you never explicitly restrict the class
of Lisp programs you're discussing.  The point of most of the "uncivil"
replies is that that's false, because some programs would require writing a 
Common Lisp interpreter in Ada, and writing a *Common* Lisp interpreter in 
any language is *hard*.  You seem to be well aware of this, and, perhaps
justifiably, to take offense at replies that suggest that you aren't.
On the other hand, Lisp proponents are ever more frequently having to
argue that *some* applications are orders of magnitude easier to
program in Lisp than in Ada, attempting to justify it's use to someone
who doesn't have any idea what Lisp is or why this is the case.  Every
time someone posts a message to comp.lang.ada that *can* be interpreted
as saying "there's never any significant advantage in using Lisp rather
than Ada", some people who do (or want to) believe that will take the
posting as evidence that that's the case.  So, you've made Lisp proponents'
lives more difficult, and some of them, understandably, got upset.  

You might have some disagreement with Lisp proponents as to which
applicaions are better coded in Lisp than Ada, but I think everyone
agrees that Lisp has no great advantage when it comes to simple list 
processing, and that it has a big advantage when a full-blown Common
Lisp interpreter is needed.  I'd be very interested in seeing Ada fans
address some of the features on Tim King's list, in the way that Mike
Linnig addressed John Gateley's dynamic typing example.

							-- rar