Kim B. Bruce

A Statically Safe Alternative to Virtual Types

Parametric types and virtual types have recently been proposed as extensions to Java to support genericity. In this paper we investigate the strengths and weaknesses of each. We suggest a variant of virtual types which has similar expressiveness, but supports safe static type checking. This results in a language in which both parametric types and virtual types are well-integrated, and which is statically type-safe.

Comparing object encodings

Recent years have seen the development of several foundational models for statically typed object-oriented programming. But despite their intuitive similarity, differences in the technical machinery used to formulate the various proposals have made them difficult to compare. Using the typed lambda-calculus F < ω : as a common basis, we now offer a detailed comparison of four models: (1) a recursive-record encoding similar to the ones used by Cardelli [Car84], Reddy [Red88, KR94], Cook [Coo89, CHC90], and others; (2) Hofmann, Pierce, and Turners existential encoding [PT94, HP95]; (3) Bruces model based on existential and recursive types [Bru94]; and (4) Abadi, Cardelli, and Viswanathans type-theoretic encoding [ACV96] of a calculus of primitive objects.

PolyTOIL: A Type-Safe Polymorphic Object-Oriented Language

PolyTOIL is a new statically-typed polymorphic object-oriented programming language which is provably type-safe. By separating the definitions of subtyping and inheritance, providing a name for the type of self, and carefully defining the type-checking rules, we have obtained a language which is very expressive while supporting modular type-checking of classes. The matching relation on types, which is related to F-bounded quantification, is used both in stating type-checking rules and expressing the bounds on type parameters for polymorphism. The design of PolyTOIL is based on a careful formal definition of type-checking rules and semantics. A proof of type safety is obtained with the aid of a subject reduction theorem.

A paradigmatic object-oriented programming language: Design, static typing and semantics

To illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes and inheritance. It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing typechecking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. To achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language. The design of TOOPL has been guided by an analysis of the semantics of the language, which is given in terms of a model of the F-bounded second-order lambda calculus with fixed points at both the element and type level. This semantics supports the language design by providing a means to prove that the type-checking rules are sound, thus guaranteeing that the language is type-safe. While the semantics of our language is rather complex, involving fixed points at both the element and type level, we believe that this reflects the inherent complexity of the basic features of object-oriented programming languages. Particularly complex features include the implicit recursion inherent in the use of the keyword, self , to refer to the current object, and its corresponding type, MyType . The notions of subclass and inheritance introduce the greatest semantic complexities, whereas the notion of subtype is more straightforward to deal with. Our semantic investigations lead us to recommend caution in the use of inheritance, since small changes to method definitions in subclasses can result in major changes to the meanings of the other methods of the class.

A modest model of records, inheritance and bounded quantification

The authors give a formal semantics for the language Bounded Fun, which supports both parametric and subtype polymorphism. They show how to use partial equivalence relations to model inheritance in this language, which supports the notion of subtype and record types. A generalization of partial equivalence relations, known as omega -sets, is used in combination with modest sets to provide the first known model of Bounded Fun (with explicit polymorphism). Connections with previous work on the semantics of explicit parametric polymorphism is established by noting that the semantics of polymorphic types presented here (using dependent products) is isomorphic to that given by the intersection interpretation of polymorphism. >

On Reacting to Assertions and Polar Questions

The aim of this paper is to capture the similarities and differences between assertions and polar questions so as to be able to account for the systematic partial overlap that exists in reactions to these speech acts in English and beyond. We first discuss the discourse components we assume, and then define default assertions and default polar questions in a way that allows us to characterize two types of responses to these speech acts, confirming and reversing reactions. The common characteristics of assertions and polar questions are responsible for the fact that both allow these reactions; the differences between the two speech acts explain the different contextual effects confirming and reversing moves have depending on whether they react to an assertion or a polar question. We then examine the distribution of a set of ‘polarity’ particles in Romanian in terms of the notions defined in the rest of the paper, and end with a series of predictions concerning polarity particles across languages.

Subtyping is not a good “match” for object-oriented languages

We present the design and rationale of a new statically-typed object-oriented language, LOOM. LOOM, retains most of the features of the earlier language PolyTOIL. However the subtyping relation is dropped from LOOM in favor of the matching relation. “Hash types”, which are denned in terms of matching, are introduced to provide some of the benefits of subtyping. These types can be used to provide support for heterogeneous data stuctures in LOOM. LOOM. is considerably simpler than PolyTOIL, yet is just as expressive. The type system for the language is decidable and provably type safe. The addition of modules to the language provides better control over information hiding and allows the provision of access like that of C++s friends.

Controversy on how to teach CS 1: a discussion on the SIGCSE-members mailing list

A discussion took place on the SIGCSE mailing list in late March of 2004 that raised important issues on how to teach introductory courses using Java. This article attempts to summarize several of the important points raised during this discussion, among them whether or how objects should be taught early or late in a CS 1 course, or indeed, whether object-oriented languages should be postponed until a second course.

Safe type checking in a statically-typed object-oriented programming language

In this paper we introduce a statically-typed, functional, object-oriented programming language, TOOPL, which supports classes, objects, methods, instance variable, subtypes, and inheritance. It has proved to be surprisingly difficult to design statically-typed object-oriented languages which are nearly as expressive as Smalltalk and yet have no holes in their typing systems. A particular problem with statically type checking object-oriented languages is determining whether a method provided in a superclass will continue to type check when inherited in a subclass. This program is solved in our language by providing type checking rules which guarantee that a method which type checks as part of a class will type check correctly in all legal subclasses in which it is inherited. This feature enables library providers to provide only the interfaces of classes with executables and still allow users to safely create subclasses. The design of TOOPL has been guided by an analysis of the semantics of the language, which is given in terms of a sufficiently rich model of the F-bounded second-order lambda calculus. This semantics supported the language design by providing a means of proving that the type-checking rules for the language are sound, ensuring that well-typed terms produce objects of the appropriate type. In particular, in a well-typed program it is impossible to send a message to an object which lacks a corresponding method.

Provable isomorphisms of types

A constructive characterization is given of the isomorphisms which must hold in all models of the typed lambda calculus with surjective pairing. By the close relation between closed Cartesian categories and models of these calculi, we also produce a characterization of those isomorphisms which hold in all CCC’s. By the correspondence between these calculi and proofs in intuitionistic positive propositional logic, we thus provide a characterization of equivalent formulae of this logic, where the definition of equivalence of terms depends on having “invertible” proofs between the two terms. Rittri (1989), on types as search keys in program libraries, provides an interesting example of use of these characterizations.