James W. Thatcher

Initial Algebra Semantics and Continuous Algebras

Many apparently divergent approaches to specifying formal semantics of programming languages are applications of initial algebra semantics. In this paper an overview of initial algebra semantics is provided. The major technical feature is an initial continuous algebra which permits unified algebraic treatment of iterative and recursive semantic features in the same framework as more basic operations.

Generalized finite automata theory with an application to a decision problem of second-order logic

Many of the important concepts and results of conventional finite automata theory are developed for a generalization in which finite algebras take the place of finite automata. The standard closure theorems are proved for the class of sets “recognizable” by finite algebras, and a generalization of Kleenes regularity theory is presented. The theorems of the generalized theory are then applied to obtain a positive solution to a decision problem of second-order logic.

Characterizing derivation trees of context-free grammars through a generalization of finite automata theory

The recognizable sets of value trees (pseudoterms) are shown to be exactly projections of sets of derivation trees of (extended) context-free grammars.

Generalized2 sequential machine maps

The introduction of syntax directed translations and transformations into formallanguage theory presents a very interesting area with considerable promise of application to questions of syntax and semantics of programming languages. The concept of generalized sequential machine (gsm) mapping (already of importance in language theory) is developed here in its natural extension to trees (or expressions). That generalized concept of gsm mapping encompasses most of the previously defined concepts relating to translations and transformations.

Rational algebraic theories and fixed-point solutions

In a wide variety of situations, computer science has found it convenient to define complex object as (fixed-point) solutions of certain equations. This has been done in both algebraic and order-theoretic settings, and has often been contrasted with other approaches. This paper shows how to formulate such solutions in a setting which encompasses both algebraic and order-theoretic aspects, so that the advantages of both worlds are available. Moreover, we try to show how this is consistent with other approaches to defining complex objects, through a number of applications, including: languages defined by context-free grammars; flow charts and their interpretations; and monadic recursive program schemes. The main mathematical results concern free rational theories and quotients of rational theories. However, the main goal has been to open up what we believe to be a beautiful and powerful new approach to the syntax and semantics of complex recursive specifications.

Parameter passing in algebraic specification languages

Abstract In this paper we study the semantics of the parameter passing mechanism in algebraic specification languages. More precisely, this problem is studied for parameterized data types and parameterized specifications. The given results include the extension of the model functor (which is useful for correctness proofs) and the semantic properties of the result of inserting actual parameters into parameterized specifications. In particular, actual parameters can be parameterized and the result is nested parameterized specification. Correctness of an applied ( matrix ( int )) or a nested ( bintree ( string ())) parameterized specification is shown given correctness of the parts. The formal theory in this paper is restricted to the basic algebraic case where only equations are allowed in the parameter declaration and parameter passing is given by specification morphisms. But we also give the main ideas of a corresponding theory with requirements where we allow different kinds of restrictions in the parameter declaration.

More on advice on structuring compilers and proving them correct

Abstract Following Lockwood Morris, a method for algebraically structuring a compiler and proving it correct is described. An example language with block structure and side-effects is presented. This determines an initial many-sorted algebra L which is the ‘abstract syntax’ of the example language. Then the semantics of L is completely determined by describing a semantic algebra M ‘similar’ to L . In particular, initiality of L ensures that there is a unique homomorphism Lsem: L →> M . This is algebraically structuring the semantic definition of the language. A category of flow-charts over a stack machine is used as a target language for the purposes of compilation. The semantics of the flow charts (Tsem: T → S ) is also algebraically determined given interpretations of the primitive operations on the stack and store. The homomorphism comp: L → T is the compiler which is also uniquely determined by presenting an algebra T of flowcharts similar to L . This is algebraically structuring the compiler. Finally a function encode: M → S describes source meanings in terms of target meanings. The proof that the compiler is correct reduces to a proof that encode: M → S is a homomorphism; then both comp ∘ Tsem and Lsem ∘ encode are homomorphisms from L to S and they must be equal because there is only one homomorphism from L to S .

Initial algebra semantics

Many apparently divergent approaches to specifying formal semantics for programming languages are applications of initial algebra semantics. Here we provide an overview of the concept of initial algebra semantics.

Data type specification: Parameterization and the power of specification techniques

This paper extends our earlier work on abstract data types by providing an algebraic treatment of parametrized data types (e.g., sets-of-(), stacks-of-(), etc.), as well as answering a number of questions on the power and limitations of algebraic specification techniques. In brief: we investigate the “hidden function” problem (the need to include operations in specifications which we want to be hidden from the user); we prove that conditional specifications are inherently more powerful than equational specifications; we show that parameterized specifications must contain “side conditions” (e.g., that finite-sets-of-d requires an equality predicate on d), and we compare the power of the algebraic approach taken here with the more categorical approach of Lehman and Smyth.

Screen reader/2: access to OS/2 and the graphical user interface

Screen Reader/2 is IBMs access system for OS/2, providing blind users access to the graphical user interface (GUI) of Presentation Manager, to Windows programs running under OS/2, and to text mode DOS and OS/2 programs. Screen Reader/2 is a completely redesigned and rewritten follow-on to IBMs Screen Reader Version 1.2 for DOS. There has been considerable discussion about the technical challenges, difficulties, and inherent obstacles presented by the GUI. Not enough time and energy has been devoted to the successes in GUI access, in part because the developers of GUI access software have had their hands full trying to solve very difficult problems. This paper will describe how IBM Screen Reader makes the GUI accessible.