Newsgroups: alt.lang.design,comp.lang.c++,comp.lang.lisp
Path: cantaloupe.srv.cs.cmu.edu!fs7.ece.cmu.edu!kinky.eng.gtefsd.com!europa.eng.gtefsd.com!howland.reston.ans.net!pipex!uknet!festival!edcogsci!jeff
From: jeff@aiai.ed.ac.uk (Jeff Dalton)
Subject: Re: Interpreters (Re: Comparing productivity: LisP against C++ (was Re: Reference Counting))
Message-ID: <D2x55L.8Ht@cogsci.ed.ac.uk>
Sender: usenet@cogsci.ed.ac.uk (C News Software)
Nntp-Posting-Host: bute.aiai.ed.ac.uk
Organization: AIAI, University of Edinburgh, Scotland
References: <hbaker-1601952306420001@192.0.2.1> <3fgug3$552@news.panix.com> <RFB.95Jan20150836@cfdevx1.lehman.com>
Date: Tue, 24 Jan 1995 16:44:08 GMT
Lines: 46
Xref: glinda.oz.cs.cmu.edu comp.lang.c++:109078 comp.lang.lisp:16478

In article <RFB.95Jan20150836@cfdevx1.lehman.com> rfb@lehman.com (Rick Busdiecker) writes:
>In article <3fgug3$552@news.panix.com> Viktor Yurkovsky <n4mation@panix.com> writes:
>
>   I wrote:
>   >  Syntax of the language matters very little.
>   >  ===========================================
>   > 
>   hbaker@netcom.com (Henry Baker) wrote:
>   > Agreed, unless the language is Lisp.  In that case, you can use the full
>   > power of macros to write most of the code for you in Lisp.  In this case,
>   > the simple syntax matters a lot.
>
>   The interesting point here is that many people have a misconception about
>   what an interpreter is really for.
>
>The point that Henry was making wrt macros and syntax is unrelated to
>interpreters.
>
>I think that there is a common misconceptions that Lisp is an
>``interpreted language''.  In fact, there is nothing to prevent anyone
>from building either a Lisp or a C++ in any of these configurations:
> 1. Compiler and interpreter.
> 2. Compiler with no interpreter
> 3. Interpreter with no compiler
>
>The fact that most Lisp implementations are of type 1 and most C/C++
>implementations are of type 2 does not reflect anything fundamental
>about the languages themselves, but rather about the decisions made by
>people who chose to build implementations of the languages.

Since Lisp interpreters are usually fairly easy to write, that
may be one reason why Lisps tend to include interpreters (even
if they have a compiler as well) while Cs and C++s don't.
However, Common Lisp interpreters tend to me more complex than
those of simpler Lisps, which may have had an effect on
implementation techniques (e.g. so the interpreter and compiler
can share more code).

In any case, I think your point is a very important one, and not only
when it comes to macros.  Many of the things people think of as properties
of langauges are actually due in large part to implementation traditions
instead.  C programmers often (usually?) know the kind of code they'll get
from various constructs, and they know this even though the language
definition allows things to work very differently.

-- jd
