Guile (with tables)

Guile is a library designed to help programmers create flexible applications. Using guile in an application allows programmers to write plug-ins, or modules (there are many names, but the concept is essentially the same) and users to use them to have an application fit their needs.

There is a long list of proven applications the employ extension languages. Successful and long-lived examples in the free software world are GNU Emacs and The GIMP.

Very popular examples of server-based applications are apache's perl (add link here) and php (add link here) extensions.

Extension languages allow users, programmers, and third-party developers to add features to a program without having to re-write the program as a whole, and it allows people extending a program to co-operate with each other, without having to expend any extra effort.

Guile is a programming language.

Guile is an interpreter for the Scheme programming language.

nicely packaged as a library you can link into your programs. Your program has full access to the interpreter's data structures, so you can extend Guile with your own primitives, datatypes and syntax. The result is a scripting language tailored to your application.

A good extension language lowers your code's hacktivation energy.

Giving your program an extension language broadens the audience of people who can hack on it. People don't need to learn the internals of your application to extend it; they just need to understand the language, and the primitives you've provided. They can easily trade and share ideas by passing around scripts, instead of trading patches and recompiling their applications. They don't need to coordinate with you, or anyone else.

GNU Emacs acquired much of its bulk by simply waiting to see which Emacs Lisp packages became ubiquitous; the vast majority of the lisp library is contributed by people not directly associated with Project GNU. And even Peter Mattis and Spencer Kimball couldn't have written all those GIMP plugins.

A good extension language takes time. We've taken that time for you.

When you decide you need a scripting language or a configuration file, the first impulse is, ``I'll just do something clean and simple.'' This is the right impulse: a full programming language with conditionals, loops, local scopes, and procedures is just a distraction from your project. But simple languages never stay simple. For example, early releases of PHP, a language for generating web pages on the fly, touted its minute memory footprint and simplicitly. Well, the latest release of PHP has its own object system. Compare Tcl circa 1988 with the modern beast. Same story with Perl. The point here is not to criticize these (very successful) tools, but rather to show that simplicity in a scripting language doesn't last long. The real challenge is to age well.

Guile has the fundamentals you need; you simply specialize it for your application. It has arrays and lists; modules; objects; and first-class functions. It has garbage collection --- which Perl and Tcl are just now coming around to, although not gracefully. You enter the game with a full-featured scripting language, so interpreter limitations don't cramp the rest of your design.

What's the latest news?

The web pages are being updated!

A Guile maintainer committee now coordinates Guile work. It consists of Maciej Stachowiak, Marius Vollmer, Jim Blandy and Mikael Djurfeldt

The most recent release is Guile 1.4, available via anonymous FTP; its address is http://ftp.gnu.org/pub/gnu/guile/ .

As mentioned above, the bleeding edge of development is available via anonymous CVS.

At the moment, the immediate priority is documentation. The lack of documentation is pretty daunting for a lot of people; it's not a simple API.

Future plans include:

• internationalization/multilingualization
• a revised module system, which can handle modules written in translated languages, and accomodate syntactic variations within the Scheme family (like SCSH and DSSSL).
• a generational garbage collector. An incremental garbage collector should follow; it would be nice for these to be selectable at run-time, but it may be necessary to make it a configuration time option.
• support for preemptive threading

The latest release of Guile is available via anonymous FTP, at http://ftp.gnu.org/pub/gnu/guile/. However, please consider also making a donation to the FSF. The software page has full details about mirror sites, etc.

As a shabby excuse for not making real releases with any reasonable frequency, we also make our development sources available, via anonymous CVS and nightly snapshots, available via FTP. If you want to live on the bleeding edge, this is the way to go.

Reporting Bugs in Guile

Change this to "participating" and make it a contributers section

You do us a much-appreciated service when you report the bugs you find in Guile. Please don't assume we already know about them; they're almost always news to us. (We know about different bugs from the one you've found.)

To report a bug, send mail to <bug-guile@gnu.org>.

When you report a bug, please try to provide exact directions we can follow to make the bug show itself on our own machine. If we can make a bug happen, it's almost certain we will be able to fix it; if we can't, it's almost certain we won't be able to.

If you have a fix, wonderful! Some favors we ask, though:

• Please send either a context diff or a unified diff (diff -c or -u); diff's default output format is almost useless to us.
• Please include a ChangeLog entry with your fix, so we don't have to guess why you did what you did. A guide to writing good ChangeLog entries can be found on the ChangeLog page.
• Don't neglect to include the bug report! If we just get a patch, and can't figure out what it's supposed to accomplish, we may not apply it.
• If the patch changes more than about ten lines of code, then you have a copyright on it, whether you want one or not. In order for us to use your fix, we need you to assign your copyright interest to the FSF, using some standard forms we've developed for this purpose. We agree this is annoying and bureacratic, but it's critical if we want to be able to defend Guile's license in court. Whoever handles your patch will get in touch with you about this.

Hubbub, hubbub, hubbub, hubbub...

There are several mailing lists associated with Guile:

guile@sourceware.cygnus.com (to subscribe: <guile-subscribe@sourceware.cygnus.com>)

This is the market square for Guile. Everyone, including the Guile maintainers, floats their ideas here. A nice bunch of folks. If you want a blast from the past, you can find a web archive, and an ftp archive (messages in mbox format) of the list.

guile-numerical@nis.lanl.gov (to subscribe, send mail to Mark Galassi <rosalia@nis.lanl.gov>.)

There are a lot of people who want to use Guile for numeric applications. Guile's own numeric performance isn't anything to write home about, but it makes a very nice interactive front end for numeric libraries written in C. Myself, I never use floating-point, except to do my checkbook; this is where to find the people who live the numeric lifestyle, and know how to make Guile work with it.

spacey-guile-db@lenin.nu (to subscribe: send email to <spacey-guile-db-subscribe@lenin.nu>)

There's been a lot of discussion on the Guile list about how Guile ought to talk to databases of every flavor --- from simple key-value Btree libraries to SQL servers. This is where it all gets discussed.

Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.

Please send comments on these web pages to webmasters@www.gnu.org, send other questions to gnu@gnu.org.

Copyright (C) 2000 Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA

Verbatim copying and distribution of this entire web page is permitted in any medium, provided this notice is preserved.

Updated: 23 Sep 2000 ttn