About modules

[Marius Vollmer <mvo at zagadka dot ping dot de>]

Hi,

I recently hit upon a different view of this "module" issue that I
want to share with you.  The gist of it is that

    Guile should not have a "module" system.

Modules are an important concept in programming and Guile should of
course support the writing of modules, but it should not pretend to
have a strict definition of what a module is.

I see the term "module" as a very high level means of talking about
the various parts of a large program or programming system and the way
they interact.  Modules should have certain properties, for example,
they should have sane and well defined interfaces and they should not
be unecessarily dependent on other modules.  Modules should be
reusable, general and robust.  Etc.

Guile should provide means for writing great modules.  Among these
means are the choice of Scheme as the programming language, because
Scheme allows the definition of nice and extensible interfaces due to
its dynamic typing, closures and garbage collection; and GOOPS,
because GOOPS provides a very powerful object system.

Guile should also have means for partitioning Scheme code into
multiple files, and managing names so that conflicts can be detected
and controlled.

This managing of names is what we use to call the "module system", but
I think it is important that we should _only_ be talking about a
mechanism for managing names.

Modules are important, and one needs much more than a well behaved way
of naming things, and these other things needs to be provided as well.
In my view, they already are provided, in the form of GOOPS and the
general features of Scheme.