Subject: Re: [executables] was: why Haskell hasn't replaced CL yet?
From: Erik Naggum <>
Date: 2000/02/28
Newsgroups: comp.lang.lisp
Message-ID: <>

| On 28 Feb 2000 11:39:14 +0000, Erik Naggum <> wrote:
| >time (for x in 0 1 2 3 4; do for y in 0 1 2 3 4 5 6 7 8 9; do ./allegro -batch -kill & done; done; wait)
| That looks like you're starting up 50 copies and waiting for them all to
| exit.  (If I understand what the '&' does.)

  you don't.  waiting for zombies doesn't take time, and processes aren't
  started up _all_ in parallell.  as you could have seen from the output if
  you had cared to, the processes clearly start up and terminate fairly
  sequentially.  this is a pretty good indication that we are not starting
  up 50 copies all in parallell, not to mention the fact that we manage to
  squeeze 50 full instantiations within one second.  regardless of what you
  think, the fact that this loop terminates in less than 1 second actually
  means that all of them started up and terminated within an average of 20
  ms of real time each.  and since this is a dual processor system, it
  would be pretty stupid not to take advantage of it, so you got what you
  asked for: 50 copies started and terminated in less than 1 second.  now
  is a good time to _believe_, heathen.

| What would the results be if you waited for each to exit before starting
| the next?

  a miniscule waste of time in the looping construct.  the user and system
  time total 1.5 seconds.  the real time is < 1 s.  you do the math.

| Is Allegro written in Lisp?

  yes.  that is, more than 98% is written in Lisp.  (writing a Common Lisp
  system in anything else is _really_ painful.)  the operating system
  interface substrate is written in C because that's what the Unix
  operating system requires for portable substrate code.  if the Unix
  operating system had been intelligently designed and hadn't outboarded so
  much of the kernel interface to the C libraries, it would have been
  easier to deal with the kernel through small, well-defined system calls
  in assembly language, but that's just too much to maintain from version
  to version, where the only stable link to the kernel is the C library.

  I'm somewhat amazed by the resilience of your prejudices.