Subject: Re: ACL vs. CLISP
From: Erik Naggum <>
Date: 1998/05/06
Newsgroups: comp.lang.lisp
Message-ID: <>

* David Bakhash
| I read what Eric wrote, and he's not too particularly fond of CLISP,
| but I must say...

  why?  I stated the specific reasons for which I recommend Allegro over
  CLISP.  you choose to focus on something else.  that's your prerogative,
  but you are also being very _unspecific_ in your complaint.  it looks
  like you are just disappointed without really knowing why.

  for some odd reason, Allegro CL can often be outperformed on simple code,
  but there's _no_ penalty for writing brilliantly abstract code (other
  than compile time, but Allegro CL compiles my code in separate Lisp
  processes, anyway, so I don't have to wait for them).  that translates
  into freedom from the shackles of premature optimization.  it actually
  took me a long time to appreciate this property of Allegro CL, because it
  is so easy to measure performance of simple code, and so hard to measure
  the combined effect of not being penalized in execution speed while being
  encouraged to write code optimized for solving complex problems in their
  own terms.  and as long as my machine is fast _enough_, it also doesn't
  matter in practical terms.

  however, you need to know this: if I were even remotely interested in
  performance, I wouldn't have kept this 50MHz SPARCstation as my main
  system.  I wouldn't have gone out and recommended something you would be
  so disappointed in when your real concerns surfaced if I had known that
  you would come back and complain about performance -- that really doesn't
  do the qualities I value very highly in software any good, does it?

  looking back at what I wrote, I think you're being somewhat destructive
  in your disappointed response.  here's what I wrote:

    it [CLISP] is also slow in some areas and very fast in others, which
    skews your priorities in optimizing your code, basically away from
    writing your own abstractions and using "raw Common Lisp", because it
    does that really fast.  it has an amazingly fast bignum implementation,
    for instance.  it also sports variable-length floating point numbers.
    such things may matter much to some.

  you obviously fall in the latter category.  why aren't you aware of it?

| CLISP sucks up less than half of the memory.  Not only that, but it seems
| faster too, though I'll be 100% sure in a few hours.

  keeping the old adage "from one data point, you can extrapolate in all
  directions" forcefully in mind, I bet you use a lot of bignums.  as I
  implied, if not said outright in the above quoted paragraph, I used to
  appreciate CLISP for these things.  then other problems quickly made
  CLISP a hellish frustration, and I associated them as a price I had to
  pay for bignum performance, I price I didn't want to pay at all.

| Just wanted to mention this because, jeez, a factor of two...

  look, I'm sorry if I led you to believe that Allegro CL would score high
  on your performance meter with your particular code.  if you're
  interested in raw performance, I have nothing to tell you, except to
  illustrate how unrelated _my_ performance is to the performance of the
  computers I use.  my Internet link is slow, too, and an inexpensive
  upgrade would more than double its speed, but I don't need that, because
  I'm not into high-bandwidth activities like graphics or music: I simply
  don't want to use my computer for entertainment, too.  what matters to me
  is that it is connected to the Net 86,400,000 milliseconds a day, and I'm
  currently giving the telephone company a _very_ rough time for having
  deprived me of about 400 seconds of connect time a day for a while, now.
  the technology we use should give 100% uptime statistics (that's why I
  use it instead of faster, less reliable technology), and 99.5% uptime is
  intolerable for my use.  the same goes for the computer and the software
  I use and all the software I _write_, too.  consequently, I don't work
  for people who want me to squeeze the last drop of blood out of the iron,
  but for people who want to be certain that the software does what they
  want it to do, _only_ what they want it to do, and never _ever_ anything
  else, no matter _what_ happens.  that's why I cannot use C++ or Perl and
  certainly cannot afford to use any Microsoft products.  that's also why I
  use Allegro CL for Unix, and I sometimes give Franz Inc a rough time, but
  I also stay with them because they can handle it.  not many companies are
  able to give me what I want in today's software climate.

  however, if _you_ want to measure the relative merits of Common Lisp
  implementations in terms of memory size and raw performance, that's
  perfectly OK with me.  (just don't call on me for help.)  I'm aware that
  my demands on modern technology are _way_ outside the public acceptance
  criteria and people can use whatever junk they want as long as I don't
  have to, but you _should_ be just as aware of your priorities as I am of
  mine.  that way, you won't get disappointed with the advice you get from
  those with different priorities than your own and you may well be
  satisfied with the choices you make.

  Support organized crime: use Microsoft products!