Aiding Self-motivation with Readings in Introductory Computing

Students can achieve self-motivation and a broader appreciation of computing by reading widely about computing. This paper advocates discussing self-motivation with students, and suggesting that they read widely as a means to that end. A discussion of how to present these ideas effectively, and an annotated list of suggested readings, appropriate for undergraduate majors in computing, are included

JML\u27s Rich, Inherited Specifications for Behavioral Subtypes

The Java Modeling Language (JML) is used to specify detailed designs for Java classes and interfaces. It has a particularly rich set of features for specifying methods. This paper describes those features, with particular emphasis on the features related to specification inheritance. It shows how specification inheritance in JML forces behavioral subtyping, through a discussion of semantics and examples. It also describes a notion of modular reasoning based on static type information, supertype abstraction, which is made valid in JML by methodological restrictions on invariants, history constraints, and initially clauses and by behavioral subtyping

Reasoning About Object-Oriented Programs That Use Subtypes

Programmers informally reason about object-oriented programs by using subtype relationships to classify the behavior of objects of different types and by letting supertypes stand for all their subtypes. We describe formal specification and verification techniques for such programs that mimic these informal ideas. Our techniques are modular and extend standard techniques for reasoning about programs that use abstract data types. Semantic restrictions on subtype relationships guarantee the soundness of these techniques

Introduction to the Literature on Semantics

An introduction to the literature on semantics. Included are pointers to the literature on axiomatic semantics, denotational semantics, operational semantics, and type theory

Introduction to the Literature on Programming Language Design

This is an introduction to the literature on programming language design and related topics. It is intended to cite the most important work, and to provide a place for students to start a literature search

An Overview of Larch/C++: Behavioral Specifications for C++ Modules

An overview is presented of the behavioral interface specification language Larch/C++. The features of Larch/C++ used to specify the behavior of C++ functions and classes, including subclasses, are described, with examples. Comparisons are made with other object-oriented specification languages. An innovation in Larch/C++ is the use of examples in function specifications. Copyright (c) Kluwer Academic Publishers, 1996. Used by permission. An abbreviated and earlier version of this paper is chapter 8 in the book Specification of Behavioral Semantics in Object-Oriented Information Modeling, edited by Haim Kilov and William Harvey (Kluwer Academic Publishers, 1996), pages 121-142

Modular Verification of Object-Oriented Programs with Subtypes

Object-oriented programming languages like Smalltalk-80 have a message passing mechanism that allows code to work on instances of many different types. Techniques for the formal specification of such polymorphic functions and abstract types are described, as well as a logic for verifying programs that use message passing but not object mutation or assignment. The reasoning techniques formalize informal methods based on the use of subtypes. A formal definition of subtype relationships among abstract types whose objects have no time-varying state but may be nondeterministic or incompletely specified is given. This definition captures the intuition that each instance of a subtype behaves like some instance of that type\u27s supertypes. Specifications of polymorphic functions are written by allowing instances of subtypes as arguments. Restrictions on the way that abstract types are specified ensure that such function specifications are meaningful and do not have to be rewritten when new subtypes are specified. Verification consists of showing that the specified relation among types has certain semantic properties, that each expression\u27s value is an instance of a subtype of the expression\u27s type, and a proof of correctness that ignores subtyping

Specifying and Verifying Object-Oriented Programs: An Overview of the Problems and a Solution

This paper presents a careful analysis of the problem of reasoning about object-oriented programs. A solution to this problem allows new types to be added to a program without respecifying or reverifying unchanged modules --- if the new types are subtypes of existing types. The key idea is that subtype relationships must satisfy certain semantic constraints based on the types\u27 specified behavior. Thus subtyping is not the same as inheritance of implementations (subclassing). Subtyping aids specification and verification of object-oriented programs by allowing supertypes to stand for their subtypes. This reduces the problem of reasoning about both supertypes and their subtypes to the problems of reasoning about just the supertypes and proving that the subtype relationships satisfy the required constraints

Introduction to the Literature On Programming Language Design

This is an introduction to the literature on programming language design and related topics. It is intended to cite the most important work, and to provide a place for students to start a literature search

Following the Grammar

This document explains what it means to ``follow the grammar\u27\u27 for several different grammars. It is intended to be used in class that teach functional programming using Scheme, especially those used for teaching principles of programming languages. In such courses traversal is over abstract syntax tree is defined by a grammar are fundamental, since they are the technique used to write compilers and interpreters