Subject: Re: compiling lisp files into executables..
From: Erik Naggum <>
Date: 1999/08/27
Newsgroups: comp.lang.lisp
Message-ID: <>

* Barry Margolin <>
| Huh?  Standalone executables are the norm in Unix?

  I'm not quite sure what you are replying to, but I'm arguing that only
  the _impression_ that programs are _stand-alone_ executables remains --
  the reality is very little under Unix is actually stand-alone in any way
  that it makes sense to continue to call it.

| You type a command name at the shell prompt, the system loads that
| executable into memory, and runs it.  Why is it so hard to understand
| writing the program in Lisp to create that executable?

  did you see the question I answered?  why does it matter whether it is
  _stand-alone_?  why is the user unhappy that there are shared libraries,
  .fasl files to load (automatically!), etc?  you seem to argue as if I had
  argued against making executables.  I haven't.  I have argued against the
  very silly notion that today's executables are stand-alone, because they
  aren't.  only the terminology remains.

| I don't know the specifics for ACL (or any other Lisp, for that matter),
| but in general you load the fasl file into Lisp, you use an
| implementation- dependent function to save an image file, and this
| function usually has a parameter where you specify a function to be
| executed as the "main program" when the image is started back up.  Check
| your manual, it should be explained pretty well there.

  I would have thought this would be sufficient, too, but let's consider
  the case where this dumping of an image file creates _two_ files.  one is
  a simple (symbolic) link to the runtime system loader (including a big
  shared library), and the other is an image file selected automatically
  according to the name of the actual executable file you invoked.  this is
  not a stand-alone executable.  it _is_ an executable program invokable
  from the command-line like all other Unix programs, however.

  for the purposes of creating even more arguments against something I have
  explicitly said I don't mean, let me be specific: I think creating small
  "executables" is a meaningless exercise.  I think having a means to make
  each individual, incremental program small is very beneficial.  to this
  end, I don't think loading a .fasl file at startup is a big deal, but
  some others seem to think not having the actual code in the _first_ file
  loaded when the program starts running somehow defeats the concept of
  "executable".  e.g., I'd be delighted if .fasl files were "executable" in
  the sense that they had "x" permission bits and could load their Lisp
  environment on their own, if that's all it takes to satisfy the concept
  of "executable" implied by "the file with the name I invoke" idea.

  save the children: just say NO to sex with pro-lifers