Guile maintainer comittee

[Mikael Djurfeldt <mdj at mdj dot nada dot kth dot se>]

Jim Blandy, Maciej Stachowiak, Marius Vollmer and Mikael Djurfeldt are
now the official maintainers of Guile.

Guile has a good set of dedicated, skilled, developers, and, although
it probably is a good thing for Guile if developers can work to a
large extent independently, sometimes Guile development needs fast
access to decision making in order to proceed smoothly.  Therefore,
RMS has appointed a maintainer committee for Guile.  We hope that the
new responsibilities for Marius and Mikael, and the added support to
Jim and Maciej will encourage us to jointly make a better job as Guile
maintainer.

People have asked for a clearer definition of Guile's goals, and a
Guile policy.  Below, you'll find a first sketch of the current goals
of Guile.  This document will also be available in the directory
guile-core/devel/policy in the CVS repository, together with documents
describing the plans for Guile and the principles for Guile
development.

In order to speed up Guile maintainer work, we have installed a
Maintainer Daemon which will regularly take possession of our minds.
When making decisions, one of us is thus always speaking with full
authority as The Maintainer.

Together we hope to give "joint work" a new definition!

The Gang of Four

----------------------------------------------------------------------

* Goals of Guile

Guile is many things to many people.  It has multiple ways to approach
it: as a C library that provides an extension language, as a
programming language in its own right, as a interface to the operating
system, as an interactive shell, or as a platform that integrates many
independent subsystems.

These different roles have a lot in common, but there are also some
opposing forces that need to be balanced.

Not everything of what is outlined below has been realized yet.  The
things that are missing will receive high priority from the
maintainers of Guile.  One thing that is not mentioned below because
it goes without saying is documentation.  It is of course a goal of
Guile to have high quality documentation.

More information about the current status of Guile and planned changed
can be found in the file "plans.text".

** Guile as an extension language library

Guile's primary aim is to provide a good extension language which is
easy to add to an application written in C on a UNIX machine.  This
means that it must export the features of a higher level language in a
way that makes it easy not to break them from C code.

For example, one important feature of Guile is automatic garbage
collection.  The C interface to the garbage collector makes it easy to
use its services for the data structures of the application itself.

** Guile as a programming language

It is an aim to support easy programming using Guile.  This includes
providing the powerful features of the programming language Scheme,
like garbage collection, dynamic types, hygienic macros and higher
order functions.

This also includes things that go beyond standard Scheme, like a
module system to manage multiple name spaces, a system for object
oriented programming, support for comfortable multi-threading, and
internationalization features like Unicode support.

To make it useful, Guile offers good performance.

** Guile as an interface to the operating system

Guile supports most of the POSIX system calls.  Most of Scsh is
available to Guile users and Guile programs.  Beyond POSIX, Guile also
makes available important system libraries like the graphical toolkit
Gtk+.

** Guile as an interactive shell

Guile provides a command line interface with readline support.  The
interactive features of the programming language allow you to
incrementally alter a running system.  A integrated debugger allows
you to analyze such a running system in great detail.

Guile provides online documentation for most of its features.

Guile can also be controlled from Emacs.  This allows you to update
the definition of a function or some other object in a Guile process
with the touch of a few keys.  You have access to the documentation in
a context sensitive way.  It also integrates the debugger nicely into
your editing environment.

** Guile as an integration platform

With all the features describes above, Guile allows the implementation
of well behaved modules.  When most of an application is implemented
as modules with generality and re-usability in mind, Guile will be the
platform where the integration and reusing will take place.

Thus, Guile makes it easy to factor your application into well
separated modules and then finish it off by combining them with a thin
layer of Scheme code.

Guile has support for writing modules in C or other compiled
languages.