Articles > GNU Friends - An Interview with GNU Guile maintainer Marius Vollmer

For those who aren't familiar with Guile, can you give an brief description of what it does and its role in the GNU Project?

The name "Guile" stands for "GNU's Ubiquitous Intelligent Language For Extension". You could argue about Ubiquitous and Intelligent, but it certainly is a general purpose extension language.

Emacs Lisp is probably the best example of an extension language: in addition to being an editor that can be controlled interactively by the user, Emacs can also execute Lisp programs and these programs can perform editing operations or other actions. When the programs are simple, one might call them "macros" or "scripts" but Emacs Lisp is powerful enough to allow the writing of big applications such as a mail and news reader, a web browser or games.

However, Emacs Lisp is tied to Emacs and the Lisp dialect it implements is not very modern. Guile is intended to fix this: it offers Scheme as the basic language and it comes as a library that can be linked into any program that wants to be extensible.

The application can add new functions and data types and Scheme code can then use them. The Scheme programs in turn can define functions that are invoked by the application whenever appropriate. For example, a window manager might offer functions for moving windows around and the user might write a Scheme function that arranges windows just like he wants it and bind it to a menu or key.

Another fundamental idea about Guile is that it was planned to offer more than one language. Not all people might like Scheme, and for those people we want to have a syntax that is more like C or Python, say.

The role of Guile in the GNU Project is that all packages that want to be extensible should use Guile, including Emacs.

What is the current status of Guile, and can you tell us a little about the history of the project?

We have two branches of development right now: a stable one that only gets bug fixes, and one where all the new developments happen. This reflects the status of Guile. It is complete and stable enough to be used for serious things, but at the same time, there are numerous opportunities to improve the external API as well as the internals if Guile itself.

In the development branch, we have better multi-threading support, for example, we use GNU GMP for arithmetic on large numbers, debugging support has been improved and the module system has been made more predictable.

Guile has been started in 1994 when RMS posted "Why you should not use Tcl" to comp.lang.tcl, resulting in the infamous "Tcl War" (http://www.vanderburg.org/Tcl/war/). In that article, he stated that extension languages like Tcl are important but that Tcl is not powerful enough for writing big applications. RMS then came up with the initial design for Guile (which was called GEL at that time, I think, but no release was made with that name).

Before you became maintainer who were the other people who worked on Guile?

The first maintainer was Tom Lord, who was followed by Jim Blandy. Then Mikael Djurfeldt and Maciej Stachowiak and later myself joined Jim. Gradually, people dropped out from this 'gang of four' (or 'guile fours', as I liked to call us) and but I'm still left. Many skilled people are working on Guile and some can be regarded as co-maintainers: Rob Browning is doing the 1.6.x releases among other things, Neil Jerram is working on the manual, and I would like the audience to give a big hand to Dirk Herrman for skillfully cleaning up the messiest internals of Guile, and to Kevin Ryde for a god-like amount of high quality bug fixes.

Many people are aware of some popular applications which use Guile, such as GIMP and Gnucash. Could you tell us about some other applications which also use it?

Actually, the GIMP uses SIOD, which is the predecessor to SCM.

Some Guile using applications that I find interesting are TeXmacs (a scientific text editor with high quality wysiwyg), Snd (a sound editor), Guppi (a data plotter and analyzer), LilyPond (a music type setter), GNU Robots (a game), and GNU MDK (a MIX development kit).

Are there any GNU programs which don't use Guile currently, that you would like see converted to use it?

Nothing specific, but then again I don't have a good overview of all the GNU programs. I guess the Gimp would be nice. Also, having access to the Gnome APIs.

If somebody wants to use Guile as a simple extension language for an application -- for example, for reading runtime-parameters like strings and numbers from a "dotfile"-type configuration file -- is it complicated to do that?

No, I don't think so.

However, there are so many ways to integrate Guile into your application, the hardest part might be to decide which way to chose. You could use Scheme data syntax in your dotfile and just use Guile to parse it, or you could execute your dotfile as a Scheme program (the way Emacs executes .emacs as Lisp). You can design a special purpose language (which is really easy in Scheme) and interpret the dotfile in that language. Etc.

How would you compare Guile with other languages such as Perl, Python, Tcl and Ruby?

In theory and in my opinion, Scheme is the best language of them all, but there is nothing fundamentally wrong with Perl, Python, Java, etc. The more options there are, the better.

In practice, core Scheme is missing important real world features such as records, hash tables, generic functions, standardized error handling, name spaces, or established libraries for tasks such as string handling or accessing the operating system. Each Scheme implementation adds these and additional things on top of 'Standard Scheme', but each in its own way. The Scheme community is working on this with the 'Scheme Requests for Implementation' (SRFIs) and things look better each day.

As to Guile specifically, I think that it clearly has drawbacks compared to other Scheme implementations but it still offers the easiest way to embed it into your application (and it is getting easier). Some common things might seem to be a bit complicated, such as getting a backtrace from within C code, but everything is possible.

What is your background as a developer? How did you become active in Guile and free software?

I'm a self-taught hacker; I was always more interested in programming than in gaming. I still remember when I discovered the assembly language of the Commodore C128. That was way cooler than any of the games. Later, I discovered GCC on some fish disks for the Amiga and I was pretty thrilled that you could get the complete source for a real compiler. My Amiga was too small for really playing with the source, and it was over my head anyway. But I was totally impressed that such a thing existed, and I learned about the rest of the GNU Project, and about the mission of Richard Stallman, and it all made so much sense to me.

Later, when a friend showed me this new Linux thing that he was to trying out, I bought my first PC and installed Slackware on it, from about thirty floppies. I'm pretty proud that I never did DOS or Windows.

The rest followed naturally. I do all my work with Free Software, and the thing that interested me most was Guile. I started contributing stuff and eventually, I became its maintainer.

Apart from Guile, what do you work on?

I'm in my last month of being a research assistant at the University of Dortmund, in the department for Electrical Engineering and Information Technology. I haven't really started yet to look for a new job (but I'm open to suggestions...)

I also enjoy hacking on 'Gossip' (http://www.nongnu.org/gossip), the simulator that I've written for my thesis work. Of course, it is based on Guile.

Is there any story behind how you became a supporter of the free software philosophy?

No, not directly, I was lucky enough to not have come into significant contact with proprietary software at all. But my limited experience with it has only reinforced my commitment to Free Software. These proprietary software vendors promise so much, keep so little, and don't let you fix their bugs. It's appalling.

What do you think the main challenges are for the free software community today, and the best way to overcome them?

In the past, one challenge was to find enough people to work on Free Software. Today, I think the main challenge is that we have to fight to be allowed to work on Free Software. Things like software patents, the DMCA, the push for the perversions that are 'Trusted Computing' and 'Digital Rights Management', they all work against us.

It might even seem as if the technical progress that enables society to advance nowadays comes from the hacker community and small, independent firms, not from the big 'innovators'.

This only tells me that Richard Stallman was right all along: it is all about freedom.

From your experience of working on Guile do you have any practical tips or wisdom you'd like to share with other developers?

Only the usual ones: keep it simple and optimize later.

If somebody wants to learn more about Guile (or Scheme) are there any books or tutorials that you would recommend?

The web site http://www.schemers.org/ is a good starting point for Scheme in general. It lists online resources and has book recommendations, among other things. Documentation for Guile can be found at http://www.gnu.org/software/guile.

Thanks for taking the time for this interview and for your work on free software!