Just as C provides UNIX with a common language for implementing applications, the X Window system provides it with a common set of tools for handling mice and screens. The packages described in this month's column are built on X for the same reason that dozens of language processors are written in C. C and X are adequate, ubiquitous, and if need be, free.

Following the analogy a bit further, these Graphical User Interface Development Environments (GUIDEs) also hide existing technology under new, and presumably improved, sets of interfaces. Having used C for the analogy, I should note that only one of the packages described in this column is based even partially on C. On the other hand, all of the packages can be layered on top of freeware language processors based on C.

Finally, a word of warning. These are large packages, requiring study, practice, and substantial amounts of computer resources. Don't expect to make them work for you in an evening, and have a substantial amount of free disk space available for unpacking and building before you begin. A reasonable rule of thumb is that you will need at least ten MB of disk space to unpack and build one MB of compressed sources.

Garnet

Garnet (ftp://a.gp.cs.cmu.edu/usr/garnet/garnet/) isn't all that large: 3.2 MB, including 1.3 MB for documentation. It is written in Common Lisp, however, and you will need a suitable environment to run it. I suggest CMU Common Lisp (ftp://lisp-rt1.slisp.cs.cmu.edu/) which was developed, like Garnet, at Carnegie-Mellon University. The compressed archives for CMU Common Lisp take up about 18 MB. Make sure you have a fair amount of RAM on your target machine; Lisp eats up kilobytes like popcorn, and thrashes virtual memory systems without raising a sweat.

Having said all that, Garnet appears to be a nifty and well-developed system. The documentation is clean, readable, and quite substantial (about 700 pages). Don Hopkins, responsible a large amount of interesting NeWS freeware, is now working on the project, and seems quite enthused about it. He says that Common Lisp is really neat, and that folks should give it a try. Here are some official words on the package:

The Garnet User Interface Development Environment contains a comprehensive set of tools that make it significantly easier to design and implement highly-interactive, graphical, direct manipulation user interfaces. Garnet provides a high level of support, while still being Look-and-Feel independent and providing the applications with tremendous flexibility. The Garnet tools are organized into two layers.

The toolkit layer provides an object-oriented, constraint-based graphical system that allows properties of graphical objects to be specified in a simple, declarative manner, and then maintained automatically by the system. The dynamic, interactive behavior of the objects can be specified separately by attaching high-level "interactor" objects to the graphics. This layer includes two complete widget sets, one with the Garnet look and feel, and the other with a Motif look and feel.

The higher layer of Garnet includes three tools at this time. The first is an interface builder tool, called Gilt, which allows dialog boxes and other windows to be created. The second is C32, which is a spreadsheet interface for editing constraints among objects. Last is Lapidary, which allows the user interface designer to draw pictures of all graphical aspects of the user interface. Other tools are currently in production, such as Jade (which creates dialog boxes from a specification).

InterViews

InterViews (ftp://interviews.stanford.edu/pub/) is another biggie. The distribution contains 3.8 MB of sources, 28.4 MB of contributed code, and 3.6 MB of papers. You will also need a C++ environment. The GNU C/C++ suite (see last month's column) can be found in ftp://prep.ai.mit.edu/pub/gnu/ and takes up about 16 MB.

InterViews is a joint effort of Silicon Graphics and Stanford University. It provides lightweight, shareable objects; sophisticated layout objects; resolution-independent graphics, printing, and overlays; incremental update and double-buffering; and a graphical editing framework. Current applications include a drawing editor, a WYSIWYG document editor, and an interface builder. Here are some more quasi-official words:

InterViews is a software system for window-based applications. Like most user environments, InterViews is object-oriented in that components such as windows, buttons, menus, and documents are active elements with inherited behavior. The name InterViews comes from the idea of a user interface object presenting an interactive view of some data. For example, a text editor implements an interactive view of the contents of a text file.

InterViews is a system for building and using interactive software. Written in C++, InterViews provides a set of C++ class libraries with high-level abstractions for implementing interactive programs. InterViews includes specific support for resolution-independent graphics, sophisticated document formatting, and graphical connectivity. InterViews currently runs on top of the X window system.

Serpent

Finally, a package written in C! Well, it also includes code written in two other built-in languages (Saddle and Slang), but let's ignore that for the moment. The Serpent distribution can be found (along with a great deal of other contributed X software) in ftp://ftp.x.org/R5contrib/serpent/. The distribution is actually pretty small, at 3.6 MB, and the use of C means that no other language environment needs to be built.

Serpent consists of several interdependent components: a interface specification language (Slang), an application interfacing language (Saddle), a transaction processing library, an interactive display and dialogue editor, and input/output toolkits.

By separating the application code from the user interface, the authors of Serpent hope to create a more flexible, robust, and maintainable system than would otherwise be possible. In addition, the division encourages the development of powerful, application-independent interface management tools. Here's the official description:

Serpent is a user interface management system (UIMS) being developed at the Software Engineering Institute (SEI) [of Carnegie-Mellon University]. Serpent supports the development and implementation of user interfaces, providing an editor to specify the user interface and a runtime system that enables communication between the application and the end user.