This is the mail archive of the
mailing list for the Guile project.
Re: guile as applications language
"Neil W. Van Dyke" <email@example.com> writes:
> The clarification on the focus I would like is this: Is Guile to be an
> applications language or merely an extension language?
There is guile-core/devel/policy/goals.text in CVS which addresses
To foster discussion, I append it below.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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
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
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
** 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