We report on our experience using functional programming languages in the development of a commercial GNU/Linux distribution, discussing features of several significant systems: hardware detection and system configuration; OS installer CD creation; package compilation and management. Static typing helps compensate for the lack of a complete testing lab and helps us be effective with a very small team. Most importantly, we believe that going beyond merely using functional languages to using purely functional designs really helps to create simple, effective tools.

No abstract available.

We argue that runtime program transformation, partial evaluation, and dynamic compilation are essential tools for automated generation of flexible, highly interactive graphical interfaces. In particular, these techniques help bridge the gap between a high-level, functional description and an efficient implementation. To support our claim, we describe our application of these techniques to a functional implementation of n-Vision, a real-time visualization system that represents multivariate relations as nested 3D interactors, and to Auto Visual, a rule-based system that designs n-Vision visualizations from high-level task specifications. n-Vision visualizations are specified using a simple functional language. These programs are transformed into a cached dataflow graph. A partial evaluator is used on particular computation-intensive function applications, and the results are compiled to native code. The functional representation simplifies generation of correct code, and the program transformations ensure good performance. We demonstrate why these transformations improve performance and why they cannot be done at compile time.

Interactive visualization systems provide a powerful means to explore complex data, especially when coupled with 3-D interaction and display devices to produce virtual worlds. While designing a quality static 2-D visualization is already a difficult task for most users, designing an interactive 3-D one is even more challenging. To address this problem, AutoVisual, a research system that designs interactive virtual worlds for visualizing and exploring multivariate relations of arbitrary arity, is being developed. AutoVisual uses worlds within worlds, an interactive visualization technique that exploits nested, heterogeneous coordinate systems to map multiple variables onto each spatial dimension. AutoVisual's designs are guided by user-specified visualization tasks, and by a catalog of design principles encoded using a rule-based language.>

No abstract available.

1 Introduction One common problem in graphical user interface design has been n-Vision is a testbed for exploring n-dimensional worlds the need to manipulate and view 3D environments using containing functions of an arbitrary number of variables. inherently 2D interaction devices and displays. Although Although our interaction devices and display hardware are graphics researchers have long been developing true 3D inherently 3D, we demonstrate how they can be used to support interaction and display devices [SUTH65; VICK70; KILP76], it is interaction with these higher-dimensional objects. We introduce a only over the past decade that high-performance 3D graphics new interaction metaphor developed for the system, which we call workstations have been coupled with commercially available 3D "worlds within worlds": nested heterogeneous coordinate devices such as polarized liquid crystal shutters for stereo viewing systems that allow the user to view and manipulate functions. [TEKT87; STER89]...

We describe the design and prototype implementation of Scope, a system that generates graphical user interfaces for applications programmed in C++. The programmer chooses application data objects and functions that define the capabilities of the interface. At runtime, an interface design component, implemented as a set of production system rules, transforms this semantic specification into an interface built using a window system, an associated user interface toolkit, and the hardware input devices available on the system. The rules match application requirements against a semantic description of the toolkit, selecting virtual devices for input, output, and layout. Thus, Scope uses design rules to create interfaces from high-level programming semantics that are customized both for the application and the run-time environment.