1424753
Monad transformers and modular interpreters
We show how a set of building blocks can be used to construct programming language interpreters, and present implementations of such building blocks capable of supporting many commonly known features, including simple expressions, three different function call mechanisms (call-by-name, call-by-value and lazy evaluation), references and assignment, nondeterminism, first-class continuations, and program tracing.
The underlying mechanism of our system is monad transformers, a simple form of abstraction for introducing a wide range of computational behaviors, such as state, I/O, continuations, and exceptions.
Our work is significant in the following respects. First, we have succeeded in designing a fully modular interpreter based on monad transformers that incudes features missing from Steele's, Espinosa's, and Wadler's earlier efforts. Second, we have found new ways to lift monad operations through monad transformers, in particular difficult cases not achieved in Moggi's original work. Third, we have demonstrated that interactions between features are reflected in liftings and that semantics can be changed by reordering monad transformers. Finally, we have implemented our interpreter in Gofer, whose constructor classes provide just the added power over Haskell's type classes to allow precise and convenient expression of our ideas. This implementation includes a method for constructing extensible unions and a form of subtyping that is interesting in its own right.
9087296
Using Types to Parse Natural Language
We describe a natural language parser that uses type information to determine the grammatical structure of simple sentences and phrases. This stands in contrast to studies of type inference where types and grammatical structure play opposite roles, the former being determined by the latter. Our parser is implemented in Haskell and is based on a linguistic theory called applicative universal grammar (AUG). Our results should be interesting to computer scientists in the way in which AUG relates to types and combinatory calculus, and to linguists in the way in which a very simple, brute force parsing strategy performs surprisingly well in both performance and accuracy.
12155836
Using parameterized signatures to express modular structure
Module systems are a powerful, practical tool for managing the complexity of large software systems. Previous attempts to formulate a type-theoretic foundation for modular programming have been based on existential, dependent, or manifest types. These approaches can be distinguished by their use of different quantifiers to package the operations that a module exports together with appropriate implementation types. In each case, the underlying type theory is simple and elegant, but significant and sometimes complex extensions are needed to account for features that are important in practical systems, such as separate compilation and propagation of type information between modules.This paper presents a simple type-theoretic framework for modular programming using parameterized signatures. The use of quantifiers is treated as a necessary, but independent concern. Using familiar concepts of polymorphism, the resulting module system is easy to understand and admits true separate compilation. It is also very powerful, supporting high-order, polymorphic, and first-class modules without further extension.
14632058
First-class polymorphism with type inference
Languages like ML and Haskell encourage the view of values as first-class entities that can be passed as arguments or results of functions, or stored as components of data structures. The same languages offer parametric polymorphism, which allows the use of values that behave uniformly over a range of different types. But the combination of these features is not supported-- polymorphic values are not first-class. This restriction is sometimes attributed to the dependence of such languages on type inference, in contrast to more expressive, explicitly typed languages, like System F, that do support first-class polymorphism.This paper uses relationships between types and logic to develop a type system, FCP, that supports first-class polymorphism, type inference, and also first-class abstract datatypes. The immediate result is a more expressive language, but there are also long term implications for language design.
2346657
ML Typing, Explicit Polymorphism and Qualified Types
The ML type system was originally introduced as a means of identifying a class of terms in a simple untyped language, often referred to as core-ML, whose evaluation could be guaranteed not to “go wrong”. In subsequent work, the terms of core-ML have also been viewed as a ‘convenient shorthand’ for programs in typed languages. Notable examples include studies of ML polymorphism and investigations of overloading, motivated by the use of type classes in Haskell.
12891588
Implementing type classes
We describe the implementation of a type checker for the functional programming language Haskell that supports the use of type classes. This extends the type system of ML to support overloading (ad-hoc polymorphism) and can be used to implement features such as equality types and numeric overloading in a simple and general way.
The theory of type classes is well understood, but the practical issues involved in the implementation of such systems have not received a great deal of attention. In addition to the basic type checking algorithm, an implmenentation of type classes also requires some form of program transformation. In all current Haskell compilers this takes the form of dictionary conversion, using functions as hidden parameters to overloaded values. We present efficient techniques for type checking and dictionary conversion. A number of optimizations and extensions to the basic type class sytems are also described.
6148133
Wild Things
The children's book Where the Wild Things Are by Maurice Sendak was animated using Alice version 2.0 for an introductory undergraduate 14-week programming course at Immaculata University. Using the software development lifecycle, the designers/developers collaborated on the requirements and design phases while the implementation phase was completed individually. The animation was designed and developed with the intent of applying objectoriented principles and reusing objects where appropriate.
 Three individual scenes were created using Alice version 2.0. Upon the completion of the scenes, a screen capture tool (Hypercam2), and an audio capture tool (River Past) were used to break down the animation. Those components were synchronized using Windows Movie Maker and then the animation was converted to a Flash file.
 • Scene 1 - Tommy's Bedroom: Tommy is sent to his room and his imagination creates a jungle that grows around him.
 • Scene 2 - Sailing the Ocean: Tommy imagines sailing across the sea towards an island and encounters wild things along the way.
 • Scene 3 - An Island Encounter: Tommy reaches the island and meets the wild things only to awaken back in his bedroom as his mother calls him for dinner.
18996618
The Production of Volume Data from Triangular Meshes Using Voxelisation
Voxelisation is the term given to the process of converting data from one source type into a three dimensional volume of data values. The techniques known collectively as volume visualisation can then be applied to the data in order to produce a graphical representation of the object. This paper gives a practical approach to the voxelisation of data in the form of triangular meshes, and demonstrates the use of the method on various datasets. Visualisation is achieved by a method also described in the paper.
5463102
Improving photo searching interfaces for small-screen mobile computers
In this paper, we conduct a thorough investigation of how people search their photo collections for events (a set of photographs relating to a particular well defined event), singles (individual photographs) and properties (a set of photographs with a common theme) on PDAs. We describe a prototype system that allows us to expose many issues that must be considered when designing photo searching interfaces. We discuss each of these issues and make recommendations where applicable. Our major observation is that several different methods are used to locate photographs. In light of this, we conclude by discussing how photo searching interfaces might embody or support such an approach.
9636203
Two case studies in predictable application scheduling using Rialto/NT
This paper analyzes the results of two case studies in applying the Rialto/NT scheduler to real Windows 2000 applications. The first study is of a soft modem-a modem whose signal processing work is performed on the host CPU, rather than on a dedicated signal processing chip. The second is of an audio player application. Both of these are frequently used real-time applications-ones running on systems that were not designed to support predictable real-time execution. To function correctly, both applications require that ongoing computations be performed in a timely manner. In both cases, we first measured an original version designed to run on Windows 2000, and then modified the application to take advantage of ongoing CPU reservations provided by the Rialto/NT scheduler. We report on the benefits and problems observed when using reservations in these real-world scenarios. In both cases, we found that a real-time scheduler can provide the needed predictability for the application in the presence of competing applications, while also providing other benefits, such as minimizing the soft modem's impact on the scheduling predictability of other computations in the system. We also describe the methodologies we used to analyze the real-time behavior of the operating system and applications during these studies, including the use of instrumented kernels to produce execution traces.
32525185
Don't Emancipate, Exaggerate: Rhetoric, Reality and Reengineering