The common gateway interface (CGI) is one of the prevalent methods to provide dynamic contents on the Web. Since it is cumbersome to use in its raw form, there are many libraries that make CGI programming easier. WASH/CGI is a Haskell library for server-side Web scripting. Its implementation relies on CGI, but its use avoids most of CGI's drawbacks. It incorporates the concept of a session, provides a typed, compositional approach to constructing interaction elements (forms), and relies on callbacks to specify control ow. From a programmer's perspective, programming WASH/CGI is like programming a graphical user interface (GUI), where the layout is specified using HTML via a novel monadic interface.

Abstract. Functional reactive programming integrates dynamic dataflow with functional programming to offer an elegant and powerful model for expressing computations over time-varying values. Developing realistic applications, however, requires access to libraries, such as those for GUIs, that are written in mainstream object-oriented languages. Previous work has developed functional reactive interfaces for GUI toolkits but has not provided an account of the principles underlying the implementation strategy. In this paper, we investigate this problem by studying the adaptation of the objectoriented toolkit MrEd to the functional reactive language FrTime. The heart of this problem is how to communicate state changes between the application and the toolkit’s widget objects. After presenting a basic strategy for adaptation, we discuss abstraction techniques based on mixins and macros that allow us to adapt numerous properties in many widget classes with minimal code duplication. This results in a wrapper for the entire MrEd toolkit in only a few hundred lines of code. We also briefly discuss a spreadsheet developed with the resulting toolkit. 1

Abstract. This paper presents FunctionalForms, a combinator library for constructing fully functioning forms in a concise and flexible way. A form is a part of a graphical user interface (GUI) restricted to displaying a value and allowing the user to modify it. The library is built on top of the medium-level GUI library wxHaskell. To obtain complete separation between the structure of a form’s layout and that of the edited values, we introduce a novel use of compositional functional references. 1

Mutual dependencies between objects arise frequently in programs, and programmers must typically resort to manually filling “initialization holes ” to help construct the corresponding object graphs, i.e. null values and/or explicitly mutable locations. This report describes a “base-line ” proposal for a generalized form of value recursion in an ML-like language called initialization graphs, where value recursion is given the simplistic semantics of a graph of lazy computations whose nodes are sequentially forced, with uses of recursive values checked for initialization-soundness at runtime. We then develop examples using this mechanism to show how problematic the issue of value recursion is for ML-like languages, and in particular how sophisticated reactive objects cannot be defined in the language without using initialization holes, and how this forces ML programmers to break abstraction boundaries. At the same time we show how OO languages rely extensively on null pointers during initialization. We propose that a general, semi-safe mechanism allows value recursion to be used in conjunction with existing sophisicated abstract APIs such GUI libraries, and allows freshly defined APIs to be both abstract and yet not require clients to use explicit initialization holes. We propose that the initialization mechanism permits more programs to be expressed in the mutation-free fragment of ML, though we do not formally prove this result. 1

The Virtual Reality Modeling Language (VRML) is a standard format for describing interactive 3d content, especially on the worldwide web. It combines declarative specifications of static scenes with imperative manipulations of scene graphs to realise dynamic scenes. Functional reactive animation (Fran) is a domain-specific modeling language for graphical animations and multimedia. Fran has convincingly demonstrated the value of an entirely declarative approach to modeling built around the concepts of time-varying behaviours interacting with discrete events, embedded in a functional host language enriched with domain-specific primitives (graphics in the case of Fran). One of Fran’s ancestors, named ActiveVRML, was put forward as a proposal for VRML 2.0 by Microsoft graphics groups. It failed to gain acceptance for a variety of reasons, but mostly because its concepts remained alien to the community driving the VRML standardisation process. We set out to re-examine the design space for interactive 3d content, taking

Platform independence is an illusive goal when a system includes libraries which have hardware or low-level software dependencies. To move such code to a different platform, the developer is faced with rewriting several sections to interface directly with a different library or toolkit. We propose an approach where the code remains the same, and the library is replaced ab initio by a machine-independent engine which is retooled into a front end and a back end, of which only part of the backend needs to change for each platform. Our starting point is the.NET framework’s SSCLI platform, Rotor, and the Views GUI engine, which initally ran only on Windows. Views is an XML-based windowing system which provides the functionality of the System.Windows.Forms library, missing from Rotor. ViewsQt is a conversion of the original Views project to support a retargetable back-end. Experiments have shown that the ViewsQt code is portable, with only a few changes to the C++ classes required to compile and execute the code on the Linux and Mac OS X operating systems. On the Windows platform, ViewsQt works well with both the.NET Framework and Rotor. This paper describes the methodology we developed for porting libraries in general, discusses the case study of ViewsQt, and indicates where such work would be applicable for other technologies. Comparison is made with multi-platform toolkits such as Gtk+, and.NET’s new XAML notation.

Gregory Harold Cooper was born on New Year’s Day of 1978 in South County, Rhode Island. He has enjoyed mathematics and logic since he can remember and was addicted to computer programming by age 7. He was valedictorian of the class of 1996 at North Kingstown High School and a National Merit Scholar and Barry M. Goldwater Scholar at the University of Rhode Island. He also received an honorable mention in the National

The development of complex, multi-user, interactive systems is a difficult process that requires both a rapid iterative approach, and the ability to reason carefully about system designs. This thesis argues that a combination of declarative prototyping and formal specification provides a suitable way of satisfying these requirements. The focus of this thesis is on the development of software tools for prototyping interactive systems. In particular, it uses a declarative approach, based on the functional programming paradigm. This thesis makes two contributions. The most significant contribution is the presentation of FranTk, a new Graphical User Interface language, embedded in the functional language Haskell. It is suitable for prototyping complex, concurrent, multi-user systems. It allows systems to be built in a high level, structured manner. In particular, it provides good support for specifying real-time properties of such systems. The second contribution is a mechanism that allows a formal specification to be derived from a high level FranTk prototype. The approach allows this to be done automatically. This specification can then be checked, with tool support, to verify some safety properties about a system. To avoid the state space explosion problem that would be faced when verifying an entire system, we focus on partial verification. This concentrates on key areas of a design: in particular this means that we only derive a specification from parts of a prototype. To demonstrate the scalability of both the prototyping and verification approaches, this thesis uses a series of case studies including a multi-user design rationale editor and a prototype data-link