WOOL(ID:2618/woo002)

OO window-manager language from INRIA 

for Window Object Oriented LISP.

Colas Nahaboo INRIA

Small Common Lisp-like extension language. Claims to be the fastest interpreted language in C with run-time types.

Version 1 used by the GWM window manager.

Version 2 has an object system.

Structures:
Related languages
CLX => WOOL   Dissatisfaction Mild Influence
EMACS LISP => WOOL   Influence
Mock Lisp => WOOL   Influence
WOOL => Wool2   Evolution of
References:
  • Nahaboo, Colas and Jolobo, Vania "GWM, the Generic Window Manager" Proceedings of Xhibition'90 view details Abstract: The Gwm (Generic Window Manager) is an extensible Window Manager for the X Window System Version 11. It is based upon a Wool (Window Object Oriented Lisp) kernel, which is an interpreted dialect of Lisp written in C featuring incremental garbage collection via reference counting, lists stored as arrays, and object-oriented internal structure with specific window management primitives. The user builds its own window manager by writing Wool les to describe objects to be added as decorations around X applications windows, as pop-up menus or as independent windows, and by associating with each object a Finite State Machine triggering Wool actions on response to X events. Gwm should be able to emulate easily and eciently any other window manager, and play the same role for window managers as Emacs do for text editors.
    Extract: WOOL, ELusp, MockLisp
    In order to reach those goals, an approach was followed for Gwm realizing a transposition into the X-Window world of the Emacs editor where new editing functions can be added, and personal keys bound to those functions. Emacs is an editor where basic editing commands are defined as Lisp functions, a specific Lisp that knows about editing and includes a number of primitive functions. New commands can be created by coding new functions, and dynamic behavior may be obtained. The customization of a screen editor is limited to keystrokes, but emacs provide a simple way of redefining the meaning of keystrokes. In the Interpress Emacs version the Lisp language is not a full implementation but a fast, small, reduced implementation of Lisp, called MockLisp, implemented in C, and the whole implementation takes around 256K.
    This makes emacs usable on most machines with fast response time, yet it allows exibility and customization.
    This effcient and practical scheme has been transposed in Gwm to a full X Windows environment. The basic idea was to develop first a Lisp like language, specifically dedicated to window management, using an object oriented approach. It is called Wool: Window Object Oriented Lisp. Wool knows about X-Window, has primitive functions for handling windows, and others a framework for implementing a window management policy.
    Implementing a particular Window Manager then amounts to coding a few pages of Wool code.
    As with Emacs, however, not everybody will extensively customize Gwm, but rather one person per project (such as the system engineer).
    The Wool language has a Lisp syntax and supports a number of Lisp features, however it is clearly not a full Lisp. Wool is not Common Lisp for X (CLX) because it was felt mandatory that never any interaction would be delayed by garbage collection, that the interpreter should take less than 100 K, and specific window management concepts were necessary. On the other hand, it supports real memory management and parameter passing, unlike Interpress Emacs, where developing a large amount of lisp code is somewhat cumbersome without these features. One well known problem with Lisp is garbage collection and saturation of the memory space. Because it is unbearable for a Window Manager to garbage collect during interactions, Wool uses an original technique borrowed to modern ephemeral garbage collectors. Wool uses a memory management technique distributing the load of garbage collection on every computation, providing a smooth operation, eliminating the need to periodically stop handling user input. There is no specific memory space, so guaranteeing that there will be no deadlock due to memory shortage.
    Wool and Gwm are coded in an object-oriented layer on top of C, giving us the necessary power of object oriented programming with nearly no portability problems.
    One big drawback to the Emacs approach is that if everybody customizes its environment, you end up with as many incompatible editing environments as there are people under emacs. Thus we want to develop a set of rules, called the standard profile which should allow users to share easily decorations and placement algorithms.

    Resources
    • ftp

      "
    • History file from MIT archive
      History
      -------

      Our Koala project was one of the first to base its experiments on the new X11
      window system. One of our ambitions was to continue the research work of the
      ROOMS team at Xerox, who designed this revolutionary window managing system
      back in 1986 but on proprietary systems. We planned to realize a research
      prototype flexible enough to prototype easily new ideas, but at the same time
      always validate our ideas by making real users use our prototype in everyday
      use to gain relevant feedback, so the system could be run on low-end
      workstations currently in use, e.g. 68020s with 4M ram total.

      I decided to go the emacs way, but with a lisp dialect that would be much more
      efficient in machine ressource use. So I designed WOOL, a very special kind of
      lisp dialect in January 1988. After a first rewrite, GWM was running better
      than we could expected so we make it publicly available in July 1989.

      GWM was a success, but was overwhelmed by its maintenance and support due to
      the feedback brought back by the internet community, so that in the following
      years I did not have time to put actual research work on the original goal, the
      profiles on top of the kernel. Then I became too busy to maintain it so I kept
      a low profile so as not to attract new user and keep a small base of faithful
      users. I wanted to change a lot of things but did not want as it would have
      induced incompatibilties for my users. So I waited for GWM to die slowly and
      some other new Window Manager to come and replace it.

      Present state
      -------------

      But, 6 years after, I still use GWM. Why? because it stills offers the best
      environment a hacker can dream of among the available WMs. So I decided to
      clean the distribition, integrate all the patches sent to me by contributors,
      and issue the 1.8 release (30 June 1995) to offer a stable useful base for all
      hackers to use while I could begin writing a new incompatible incarnation with
      all insight gained by these years. GWM now can now do a suprising amount of
      things, at the expense of a quite involved hacking part from profile writers.
      So gwm 1.8 can be seen as the "final edition" of gwm.

      external link
    • Koala home page at ILOG France
      What is GWM?
      The GWM (Generic Window Manager) is an extensible Window Manager for the X Window System Version 11. It is based upon a WOOL (Window Object Oriented Langage) kernel, which is an interpreted dialect of Lisp with specific window management primitives. The user builds a window manager by writing WOOL files to describe objects on the screen, including a Finite State Machine triggering WOOL actions on response to X events (e.g. mouse buttons) on that object. These objects can be used as decorations around X applications windows, as pop-up menus or as independent windows. GWM should be able to emulate efficiently other window managers, and play the same role for window managers as EMACS does for text editors. external link