[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Scheme-reports] "module" vs. "library"

Four hours ago, Denis Washington wrote:
> To be honest, Scheme is one of the few languages I know in which you
> have to tie yourself so intimately with one single implementation to
> write any serious applications. I mean, how often do you write, say,
> a C++ implementation that only works with the Wacom C++ compiler? I
> find it a bit sad that there are such a wealth of Scheme
> implementations, but such little ground for actually sharing Scheme
> code, especially for things that need interaction with native
> libraries.

Calling them "Scheme Implementations" is misleading.  A better name is
"Scheme-based languages", since they *are* different languages.

Some people like to stick to the idea that a 50-page standard makes
Scheme a wonderful gem-like language.  And that's true -- it's easy to
keep a gem-like language if there's so little that needs to be kept in
it.  But that comes at a high cost, which is exactly what you note in
the above.

C++ is a language, and the Watcom compiler implements it.  On the
other hand, Scheme is a template of a language -- a bare skeleton that
implementations need to dress up.  They need to do the feature piling
that programmers need to get real work done.  These piles are
necessary, yet they are abolished from R5RS by design and on
principle.  Obviously, there are people that are perfectly happy with
nothing but a minimalistic core; most notably, if you want to teach a
CS course a small core is better and you need very little of that real
world stuff.  (Things do break down though, as CS moves on and there
are more and more core CS things that go well beyond the core R5

One of the glaring core deficiencies in R5 is a module system: and
that was the main contribution of R6.  But for some reason "they"
decided to re-do that, nearly from scratch.  So now, in addition to
figuring out the differences between implementations (and realizing
that they are actually different languages), you will need to figure
out the differences between standards -- and realize that they are
different language templates (as they are still too small to be
practical).  This makes "Scheme" not just a template for a bunch of
loosely related languages, but a vague cloud of ideas about language

(And as someone who appreciates language design for its utility in
terms of actually *using* a language, I consider this a destructive

          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!

Scheme-reports mailing list