The Java Virtual Machine (or JVM) is central to the system's aim of providing a secure program execution environment that operates identically on a wide variety of computing platforms. To be most effective in this role, the JVM needs a rigorous, complete description, to specify precisely the behavior required of implementations. In response, a number of researchers have produced formal accounts of the JVM that seek to define it in an unambiguous and comprehensible manner. Unfortunately, the size and complexity of the JVM means that many of these formal accounts must either restrict their scope substantially, or risk becoming unwieldy and intractable. This paper suggests an alternative approach to the specification of the JVM that seeks to ameliorate such problems by composing together a small set of "microinstructions" to produce the full bytecode set. These microinstructions are encapsulated as functions in the polymorphic functional programming language Haskell, using the familiar mechanisms of Hindley-Milner type inference to characterize the JVM's rather thorny verifier. In this way, its is hoped that a foundation will be laid for formal descriptions of the Java Virtual Machine that need not trade tractability for completeness.

This report describes an experiment carried out at ParcPlace-Digitalk which sought to increase the look-and-feel compliance of portable applications built using the company's Smalltalk-based VisualWorks product. We outline the structure of the current VisualWorks user interface framework, and the precise requirements which the experimental system sought to fulfill. We go on to show how we were able to reuse design patterns from the literature in a generative fashion, to direct the evolution of the new framework. This contrasts with most pattern-related work to date, which has concentrated on discerning design patterns in existing systems. Finally, we draw generalizations from our experience concerning the evolution of software architecture using patterns.

There have been a number of attempts to blend objectoriented programming languages with techniques commonly employed for knowledge representation in artificial intelligence.In the main, such exercises have entailed the incorporation of rule-based programming ideas into object-oriented languages, or the imposition of object-oriented constructs on logical programming notations.In this report, we describe a system with a slightly different approach to the problem, which augments an object-oriented language with term classification capabilities like those found in KL-One and its successors.We hope to establish that this approach results in a more natural and efficacious integration of conventional object-oriented programming and knowledge representation than has been attained up to now.1.This research was conducted under B.T. Corporate funding.

A number of denotational models have been proposed for object-oriented languages. Authors of more recent models have expressed dissatisfaction with the lack of ‘abstractness’ in earlier ones. They claim that these earlier models describe details of objects which are invisible to an external observer – in short, that they are not fully abstract. In this paper, we present a formal characterisation of the visible behaviour of objects. We show that using a natural full abstractness criterion based on this definition, even more recent models of object-oriented languages are unnecessarily ‘concrete’. We go on to present a semantics for a very simple object-oriented language based on projections of state-transition graphs for programs, and demonstrate that it is fully abstract.