. Interactive programming is a convenient programming style that supports fast prototyping and debugging but often results in a loss of modularity and security. This article addresses the problem of supporting reliable and modular interactive programming. A module system designed for interactive use is introduced. This module system supports separate compilation and automatic updating of module interfaces during program development. It also allows the programmer to obtain a fresh program state for reliable testing, eliminating the need to reload an entire program. 1. Introduction Modular programming facilitates large-scale program development and system maintenance by providing a clean way for programs to be organized and enforcing barriers between program pieces. In module systems supporting a batch-oriented programming style, each module of a program is compiled separately and linked with other modules before execution. Upon discovery of an error, the programmer modifies and recompi...

Abstract not found

In existing work on graph algorithms, it is known that a linear time algorithm can be derived mechanically from a logical formula for a class of optimization problems. But this has a serious problem that the derived algorithm has huge constant factor. In this work, we redene this problem on recursive data structures as a maximum marking problem and propose method for deriving a linear time algorithm for that. In this method, speci cation is given using recursive functions instead of logical formula, which results in a practical linear time algorithm. This method is mechanical and in fact, based on this deriving method, we make a system which automatically generates a practical linear time algorithm from specication for a maximum marking problem.

We present a systematic construction of a variadic applicative-order multiple fixed-point combinator in Scheme. The resulting Scheme procedure is a variadic extension of the n-ary version of Curry’s fixed-point combinator. It can be used to create mutually-recursive procedures, and expand arbitrary letrec-expressions.

Extension languages are an important part of modern applications development. Java as a platform does not provide a standard extension language. Scheme is one possible choice as an extension language for Java. There are a variety of techniques for implementing Scheme in Java varying from interpreting s-expressions to compiling into Java byte-codes. The historical evolution of one implementation is discussed over the course of several years. The design of the Java-to-Scheme and Scheme-to-Java interfaces is reviewed. The advantages and disadvantages of Java and Scheme are compared.

Any significant difference from the version available at the start of term will be documented onwww.cs.bham.ac.uk/˜mmk/teaching/Foundations/errata08.html 1 Contents

Abstract not found

As software developers we are engineers because we make useful machines. We are concerned both with the world, in which the machine serves a useful purpose, and with the machine itself. The competing demands and at-tractions of these two concerns must be appropriately bal-anced. Failure to balance them harms our work. Certainly it must take some of the blame for the gulf between re-searchers and practitioners in software development. To achieve proper balance we must sometimes fight against tendencies and inclinations that are deeply in-grained in our customary practices and attitudes in soft-ware development. In this paper some aspects of the relationship between the world and the machine are ex-plored; some sources of distortion are identified; and some suggestions are put forward for maintaining a proper bal-ance. 1 Introduction: Engineering

Lisp is well known for its metacircular definitions. They differ by their intent (what they want to prove), their means (what linguistic features are allowed for the definition) and by their scope (what linguistic features are described). This paper provides a new metacircular definition for a complete Lisp system including traditionally neglected features such as cons, read, print and error. The programming style adopted for this interpreter is inspired both by denotational semantics and its continuation passing style (to explain continuation handling) and by the object oriented paradigm as highlighted by typedriven generic functions. The resulting interpreter lessens the number of primitives it uses to only eight: car, cdr, rplaca, rplacd, eq, read-char, write-char and end, while still providing Scheme-like essential capabilities (less arithmetic). The overall size is near 500 lines of fully encapsulated code that, if efficiency is not the main requirement, can be easily turned into...

The ability to construct programs in an incremental fashion is a premise of popular programming paradigms such as modular programming, object-oriented programming, and interactive programming. Incremental program development amounts to filling the holes of well-planned program contexts with new experimental components, or assembling new programs from previously developed and thoroughly tested components, or a combination of both. Its popularity lies in the flexibilities it provides for reusing existing program components and program structures. The benefits of constructing programs incrementally are reduced demand on human and computing resources, faster turn-around time, and enhanced program reliability. We present a schema for enhancing programming languages with incremental program construction capabilities based on the notion of program contexts. By perceiving fully-evolved program contexts (proper parse trees) as compiled code, partiallyevolved program contexts (improper parse tre...