Abstract. It is important to be able to program GUI applications in a fast and easy manner. Current GUI tools for creating visually attractive applications offer limited functionality. In this paper we introduce a new, easy to use method to program GUI applications in a pure functional language such as Clean or Generic Haskell. The method we use is a refined version of the model-view paradigm. The basic component in our approach is the Graphical Editor Component (GECτ) that can contain any value of any flat data type τ and that can be freely used to display and edit its value. GECτ s can depend on others, but also on themselves. They can even be mutually dependent. With these components we can construct a flexible, reusable and customizable editor. For the realization of the components we had to invent a new generic implementation technique for interactive applications. 1

Abstract. This article demonstrates how a powerful and expressive abstraction from concurrency theory—monads of resumptions—plays a dual rôle as a programming tool for concurrent applications. The article demonstrates how a wide variety of typical OS behaviors may be specified in terms of resumption monads known heretofore exclusively in the literature of programming language semantics. We illustrate the expressiveness of the resumption monad with the construction of an exemplary multitasking kernel in the pure functional language Haskell. 1

This paper is a complete description of mHaskell, an extension of Concurrent Haskell for mobile computation. We describe new stateful mobility primitives that use higher-order channels, giving their operational semantics and an implementation outline. We show how medium-level coordination abstractions can be constructed using monadic composition of the mobility primitives.

In this paper we explore the potential of functional languages in designing and implementing complex distributed systems. We focus on the areas of parallel computation and coordination, and describe the prototype implementation of a generic runtime environment (RTE) for parallel execution. In particular, we discuss the implementation of scheduling algorithms in this context. Key features of our design are modularity, a separation between basic components, and employing a hierarchy with increasing levels of abstractions. The microkernel of this system is accessed via a narrow interface and most of the coordination of the system is realised in a functional language, (Concurrent) Haskell [5], at system level. Thus, we obtain a prototype in the form of an executable specification, amenable to formal reasoning, and easier to maintain and more flexible than conventional RTEs. In particular, components can be easily replaced, and we demonstrate the flexibility of this approach by presenting different variants of the scheduling component for the parallel execution of Haskell programs, put on top of GHC [4]. In the full paper we add sophisticated work distribution policies. With our approach we target complex architectures such as Computational Grids [1]. To handle such heterogeneous, global architectures with potentially thousands of machines a modular design with easily replacable components is crucial. More generally, this work underlines the usability of a high-level language such as Concurrent Haskell as a systems programming language [2].

Dynamic types allow strongly typed programs to link in external code at run-time in a type safe way. Generic programming allows programmers to write code schemes that can be specialized at compiletime to arguments of arbitrary type. Both techniques have been investigated and incorporated in the pure functional programming language Clean. Because generic functions work on all types and values, they are the perfect tool when manipulating dynamic values. But generics rely on compile-time specialization, whereas dynamics rely on run-time type checking and linking. This seems to be a fundamental contradiction.

Abstract. We present the design and prototype implementation of the scheduling component in ArTCoP (architecture transparent control of parallelism), a novel run-time environment (RTE) for parallel execution of high-level languages. A key feature of ArTCoP is its support for deep process and memory hierarchies, shown in the scheduler by supporting light-weight threads. To realise a system with easily exchangeable components, the system defines a micro-kernel, providing basic infrastructure, such as garbage collection. All complex RTE operations, including the handling of parallelism, are implemented at a separate system level. By choosing Concurrent Haskell as high-level system language, we obtain a prototype in the form of an executable specification that is easier to maintain and more flexible than conventional RTEs. We demonstrate the flexibility of this approach by presenting implementations of a scheduler for light-weight threads in ArTCoP, based on GHC Version 6.6.

Abstract.. This paper presents a library for the run-time construction and specialisation of generic or polytypic functions. This library utilises the type information that is available in dynamics to implement generic functions on their values. The library closely follows the static generic framework, both in its use and in its implementation. It can dynamically construct generic operations ranging from equality, map and parsers to pretty printers and generic graphical editors. A special feature of the library is that it can also be used to derive meaningful specialisations of generic functions that operate on the type representation of the dynamic. 1