In article <email@example.com>,
Scott Schwartz <firstname.lastname@example.org.NO-SPAM> wrote:
>Erik Naggum <email@example.com> writes:
>| ANSI Common Lisp, and even Common Lisp the Language, 2nd edition, specify a
>| language that is, in practice, _routinely_ compiled to code as fast as C,
>| often faster because Common Lisp programmers use better algorithms and have
>| more time to optimize where it is needed than C programmers.
>The catch, as you well know, is that those implementations also have
>huge, expensive runtime systems and slow startup times, so to be
>usable you have to live inside them.
This is true of most Common Lisp implementations, but it doesn't have to be,
and it certainly doesn't have to be the case for a small Scheme system
if you build your implementation to be small rather than fast, featureful,
and inclusive of cool editing and debugging tools.
> On this topic, you yourself have
>argued that the lisp repl should be one's shell and that it should be
>judged in that context.
I think that's the wrong tack to take in a discussion of scripting
languages. You don't have to live inside Scheme, for example. If
you don't want a significantly bigger footprint due to GC, run your
GC faster to reclaim memory quickly. It'll slow you down a little
bit, but it'll still be vastly faster than Tcl. Likewise, if you
don't want a compiler in your system, don't have one. Or have a
simple one that compiles to bytecodes. And maybe have a turbo version
to batch-compile standalone executables that are small and fast.
(Actually, you can mix various kinds of code in a single system
with no problem.)
None of this is particularly difficult. It's just that most Lisp
implementors have favored fast and featureful over small and
quick-to-start-up. Nothing here has anything to do with Lisp per
se (i.e., the basic structure of Lisp), only to due with language
and environment design decisions. If you want to make a tiny
embeddable Scheme, you can do it just fine. (Check out SIOD.)
> While that might be to your taste, you should
>acknowledge that it is totally at odds with how things are done in the
>(much nicer) underlying system, and pretty much proves Ousterhout's
I think it doesn't. I think Ousterhout, like most people, doesn't
know that Lisp is a very flexible language, suitable for tiny
scripting-oriented dialects. And like most people, he doesn't
know that this is basically straightforward off-the-shelf
technology that'll get you much better performance than Tcl's
without much effort in building the system.
| Paul R. Wilson, Comp. Sci. Dept., U of Texas @ Austin (firstname.lastname@example.org)
| Papers on memory allocators, garbage collection, memory hierarchies,
| persistence and Scheme interpreters and compilers available via ftp from
| ftp.cs.utexas.edu, in pub/garbage (or http://www.cs.utexas.edu/users/wilson/)