[chicago-lisp] (no subject)

Damien Kick dkixk at earthlink.net
Fri Dec 8 03:10:22 UTC 2006 

On Dec 4, 2006, at 19:06, Corey Sweeney wrote:

> On 12/4/06, John Quigley <jquigley at jquigley.com> wrote:
>
> I think the general feeling is that we should remain as the Chicago  
> Lisp.  I'm happy with that, though I do recognize the problems
> associated with a group becoming 'pigeon-holed;' if you meet long  
> enough, there's only so many topics one can discuss about a certain  
> technology.

Of course, the flip side is being thinly spread over too many  
things.  Oh, and John, I apologize as this will duplicate a lot of  
what I wrote to you in a private e-mail.

> Hmm, I'm confused.  Lets establish some terminology to help clarify:
>
> Scheme is a dialect of lisp
> Common lisp is a dialect of lisp
> {emacs lisp is too}
>
> So let's use "lisp" without any further constraints to refer to the  
> "family" of lisp languages.

Kent Pitman, "Lambda, the Ultimate Political Party" <http:// 
tinyurl.com/y5ou9j>:

> ``If they're all Lisps, presumably they're all built around some  
> common core. Right?''
>
> Not necessarily. Some years ago, when I was first becoming involved  
> with language standards, I did a personal study of languages in the  
> Lisp family to determine whether there was a common core of  
> operators that were present throughout the family with the same  
> name and semantics.
In case you haven't heard of Kent Pitman before (sorry to be  
repetitive if you already have), he was the editor of the ANSI  
standard for Common Lisp, the effort to take what was at the time of  
the start of the standardization process, any number of divergent  
Lisp dialects and try to come up with something common.  I think he  
would be in a very good position to know how similar or not all of  
those various lisp dialects where.

Corey wrote:

> Now scheme is a impure functional language (i.e. it has a "set"  
> command), just like Common lisp is a impure functional language.
> I believe ML is a pure functional language. {i don't actually use  
> it though, so don't quote me on that}

Scheme, from comp.lang.functional FAQ <http://tinyurl.com/yl6gln>:

> [...] in (strict) functional languages such as SML or Scheme, [...]  
> it is more common to find such programs written with an explicit  
> loop, often expressed recursively. Nevertheless, there is still no  
> need to update the values of the variables involved: [...]
>
> Scheme:
> (define sum
>    (lambda (from total)
>        (if (= 0 from)
>            total
>            (sum (- from 1) (+ total from)))))
> (sum 10 0)

Common Lisp, from something as "general purpose knowledge" as  
Wikipedia <http://tinyurl.com/zql2x>:

> Lastly, the Scheme standards documents require tail-call  
> optimization, which the CL standard does not. Most CL  
> implementations do offer tail-call optimization, although often  
> only when the programmer uses an optimization directive.  
> Nonetheless, common CL coding style does not favor the ubiquitous  
> use of recursion that Scheme style prefers -- what a Scheme  
> programmer would express with tail recursion, a CL user would  
> usually express with an iterative expression in do, dolist, loop,  
> or (more recently) with the iterate package.

"Most" Common Lispniks would write an iterative, i.e. non-functional,  
version, such as the following:

(loop for i from 1 upto 10 summing i)

When the most exposure to lisp I had was the usual cursory intro from  
a comparative languages course and a intro to AI course in college, I  
had the impression that everything in lisp was always recursion.   
Having been reintroduced by Paul Graham's ANSI Common Lisp, I was  
under the impression that doing things like using setq should be done  
only in emergencies.  I forget how he phrases it.  Something like  
pretending that it incurs a cost to the function or something like  
that.  But that's why I'm personally glad that Peter Siebel wrote  
Practical Common Lisp, as it focuses more on getting useful stuff  
done, and shows quite a bit of the "just get stuff done" aspects of  
the language.

Common Lisp and Scheme do come from different communities.  I think  
it is interesting to note that most all the many divergent lisp  
dialects that were used at one time <http://tinyurl.com/y7puru>,  
3Lisp, Flavors, Franz Lisp, Interlisp, Lisp 1.5, LOOPS, XLisp,  
ZetaLisp, etc., have been subsumed by Common Lisp.  However, Scheme  
remains distinct.  I think that is indicative of the differences  
between the languages and the communities.  But like is mentioned in  
the comp.lang.functional FAQ (ibid):

> It is often possible to write functional-style programs in an  
> imperative language, and vice versa. It is then a matter of opinion  
> whether a particular language can be described as functional or not.
If one wants to slide far enough down the slippery slope, even C/C++  
could be considered functional languages because one can write such  
code without using assignment (or iteration (...)).

int sum(int from, int total)
{
     if (from == 0) {
         return total;
     } else {
         sum(from - 1, total + from);
     }
}

Many C/C++ compilers support tail-call optimizations, too.  However,  
"most" C/C++ programmers would not write sum like this, using a for  
loop instead, just like "most" Common Lispniks.  Probably because  
both of these languages consider tail-call optimization as a viable  
optimization technique (not explicitly mentioned in the standard),  
not a fundamental aspect of the language (unlike Scheme, which does  
explicitly require this behavior in the standard).  "Most" Schemers  
would, however, use the recursive version.

Corey wrote:

> I would personally prefer having some room for non-lisp languages,  
> but I would still be ok with constraining ourselfs to lisp ( i.e.  
> no ML or haskel (or erlang ;) ).  I would have a issue though if we  
> were to constrain ourselfs to the common lisp dialect.

I personally would not have an issue with including many divergent  
dialects in the lisp family.  In fact, I would love it if somebody  
could get Paul Graham to come talk about Arc, the newest vaporware  
member of the family.  I suppose I would have an issue with a lisp  
group which was not cognizant of the distinctions, though.

> Question.  Does Allegroserve *require* you to buy allegro common  
> lisp?  You might alienate some potential helpers that way.

No.  There is Portable AllegroServe <http:// 
portableaserve.sourceforge.net/>.  It works with:
> CMU Common Lisp
> Steel Bank Common Lisp
> GNU clisp (only single-threaded operation)
> OpenMCL
> Xanalys Lispworks
> MCL
> Scieneer Common Lisp (slightly broken as of 2004-02-29)
> Corman Common Lisp (with non-standard install method, might be  
> broken as of 2004-02-29)
> Allegro Common Lisp
The only reason I mentioned it was that it is an entire HTTP server  
in CL, as opposed to only part of it, as one would find with  
something like mod_lisp.  But as others have mentioned, there are  
lots of other alternatives.  Personally, I am looking for a lisp  
group because I like lisp and don't have enough excuse to use it at  
work.  In fact, I think it would be sweet if we could get our hands  
on an old Symbolics machine and have everything be lisp, from the raw  
iron all the way up.  But I'm strange like that.  I don't expect a  
Linux group to host its web-server on a box running something other  
than Linux and I like my lisp groups to use as much lisp as possible.

Corey wrote:

> Also as I mentioned before {in person}, having just implemented a  
> wiki in scheme, I would probably be able to give some guidance if  
> you decide to do a wiki.

And there is CLiki <http://www.cliki.net/CLiki> and The Common Lisp  
Directory <http://tinyurl.com/y3fkb6>, both written in CL.

Corey wrote:

> This is probably too big of a project, but I'll toss out the idea  
> anyway. What about writing a common lisp "interpreter" in scheme?

Yeah, you're right.  It probably is too big of a project.  Sure, we  
could knock out the basics of the language, what with lexical scoping  
and closures coming for free from Scheme, and adding dynamic scoping  
(special variables) in a few lines of code.  Sure, CL style macros  
would be a day or two at best.  Pathnames, logical pathnames,  
packages, and reader macros aren't even worth mentioning.  CLOS would  
be a week or two.  A full meta-object protocol might take another  
week.  Maybe two.  Adding CL style conditions would probably be two  
weeks, maybe three tops.  But doing things like getting unwind- 
protect and call/cc to play well together might be a bit harder  
<http://tinyurl.com/y8pl6r>.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mailman.common-lisp.net/pipermail/chicago-lisp/attachments/20061207/449771b9/attachment.html>

More information about the Chicago-lisp mailing list