State Machines which one may view as code written in an abstract programming language, can be applied to other virtual machines and to other programming languages as well. The target readers are practitioners---programmers, implementors, standardizers, lecturers, students---who need for their work a complete, correct, and at the same time transparent definition, and an executable model of the language and of the virtual machine underlying its intended implementation. As a consequence, in our models for the language and the machine, we first of all try to directly and faithfully reflect, in a complete way, as far as possible without becoming inconsistent, and in an unambiguous yet for the human reader graspable way, the intuitions and design decisions which are expressed in the reference manuals [18, 23] and underlie the current implementations of the language and the machine. We clarify various ambiguities and inconsistencies we discovered in the manuals and in the implementations, concerning fundamental notions like legal Java program, legal bytecode, verifiable bytecode, etc. Our analysis of the JVM bytecode verifier, which we relate to the static analysis of the Java parser (rules of definite assignment and reachability analysis), goes beyond the work of Stata and Abadi [34], Qian [27, 28], Freund and Mitchell [16], and O'Callahan [26]. 1.1 The goals of the book 3 In this introduction, we give an overview of the general goals of the book, its contents, the structuring techniques we use for decomposing Java and the JVM, and the literature we used. For additional information on the book and updates made after its publication, see the Home Page of Jbook at http://www.inf.ethz.ch/~jbook. 1.1 The goals of the book Our main goal is not to write an introduction to progr...

In this paper we describe the implementation of several graphical programming paradigms (Model View Controller, Fudgets, and Functional Animations) using the GUI library TkGofer. This library relies on a combination of monads and multiple-parameter type classes to provide an abstract, type safe interface to Tcl/Tk. We show how choosing the right abstractions makes the given implementations surprisingly concise and easy to understand.

Abstract. Feris is a library and runtime environment for creating interactive programs. Programs written using Feris may be run as GUI applications, but also in other ways, such as as web pages, text mode applications, or embedded in another program. In addition to being of practical use in itself, Feris demonstrates a programming model based on translation between different abstractions, and an approach to interfacing functional languages with the outside world. The core of the system is a network of translators that translate between different abstractions. Applications can describe their interface in terms of whatever abstractions they like (e.g. diagrams or actions), and low level environments can describe their interface using another set of abstractions (e.g. pixels or text), and translators to translate between them. Also noteworthy is that Feris programs cannot directly perform actions on global state, even when working with files. 1

Without adding any primitives to the language, we define a concurrency monad transformer in Haskell. This allows us to add a limited form of concurrency to any existing monad. The atomic actions of the new monad are lifted actions of the underlying monad. Some extra operations, such as fork , to initiate new processes, are provided. We discuss the implementation, and use some examples to illustrate the usefulness of this construction.

Abstract not found

To implement a system for the declarative programming of interactive applications, such that these applications may be presented as GUIs, or represented in other ways. This is to be done without allowing applications to perform actions on global system state. Work Completed The system was implemented. Several targets were written, including a GTK GUI target, a GDK graphics target, a web target and a file target. This allows simple programs to be written and run, and targetted at different runtime environments.