* oldprint.scm (print-table-add!): Ditto.

[bpt/guile.git] / devel / policy / goals.text

This file states the goals of Guile.

* 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 for the GNU system.  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.

** Guile as a basis for other languages

Scheme is a very powerful language, which makes it possible
to implement other languages by translating them into Scheme.

By writing translators that convert various popular scripting
languages into Scheme, we can enable users to choose their favorite
languages for extending any program that provides extensibility using
Guile.