James K. Huggins

The Semantics of the C Programming Language

We present formal operational semantics for the C programming language. Our starting point is the ANSI standard for C as described in [KR]. Knowledge of C is not necessary (though it may be helpful) for comprehension, since we explain all relevant aspects of C as we proceed. Our operational semantics is based on evolving algebras. An exposition on evolving algebras can be found in the tutorial [Gu]. In order to make this paper self-contained, we recall the notion of a (sequential) evolving algebra in Sect. 0.1. Our primary concern here is with semantics, not syntax. Consequently, we assume that all syntactic information regarding a given program is available to us at the beginning of the computation (via static functions). We intended to cover all constructs of the C programming language, but not the C standard library functions (e.g. fprintf(), fscanf()). It is not di cult to extend our description of C to include any desired library function or functions. Evolving algebra semantic speci cations may be provided on several abstraction levels for the same language. Having several such algebras is useful, for one can examine the semantics of a particular feature of a programming language at the desired level of abstraction, with unnecessary details omitted. It also makes comprehension easier. We present a series of four evolving algebras, each a re nement of the previous one. The nal algebra describes the C programming language in full detail. Our four algebras focus on the following topics respectively:

A toolset for supporting UML static and dynamic model checking

The Unified Modeling Language has become widely accepted as a standard in software development. Several tools have been produced to support UML model validation. However most of them support either static or dynamic model checking; and no tools support to check both static and dynamic aspects of a UML model. But a UML model should include the static and dynamic aspects of a software system. Furthermore, these UML tools translate a UML model into a validation language such as PROMELA. But they have some shortcomings: there is no proof of correctness (with respect to the UML semantics) for these tools. In order to overcome these shortcomings, we present a toolset which can validate both static and dynamic aspects of a model; and this toolset is based on the semantic model using Abstract State Machines. Since the toolset is derived from the semantic model, the toolset is correct with respect to the semantic model.

The Railroad Crossing Problem: An Experiment with Instantaneous Actions and Immediate Reactions

We give an evolving algebra solution for the well-known railroad crossing problem and use the occasion to experiment with agents that perform instantaneous actions in continuous time and in particular with agents that fire at the moment they are enabled.

Specification and verification of pipelining in the ARM2 RISC microprocessor

Gurevich Abstract State Machines (ASMs) provide a sound mathematical basis for the specification and verification of systems. An application of the ASM methodology to the verification of a pipelined microprocessor (an ARM2 implementation) is described. Both the sequential execution model and final pipelined model are formalized using ASMs. A series of intermediate models are introduced that gradually expose the complications of pipelining. The first intermediate model is proven equivalent to the sequential model in the absence of structural, control, and data hazards. In the following steps, these simplifying assumptions are lifted one by one, and the original proof is refined to establish the equivalence of each intermediate model with the sequential model, leading ultimately to a full proof of equivalence of the sequential and pipelined models.

Engaging computer science students through cooperative education

Computer science educators continuously seek creative and effective ways of engaging students. The model of cooperative education, in which students systematically combine academic learning with practical work experiences, provides opportunities to deepen student learning, promote student retention, and prepare students for professional life. We discuss ways in which cooperative learning can engage students in the broader discipline of computer science.

An ASM Dynamic Semantics for Standard ML

The Abstract State Machines (ASM) methodology is a methodology for formally specifying computing systems. We use the ASM methodology to give the dynamic semantics of the functional programming language Standard ML. We give an operational semantics for Standard ML by means of an interpreter for (appropriately pre-processed) Standard ML programs; the effect of a Standard ML instruction can be seen in terms of the corresponding actions performed by the ASM.

A UML validation toolset based on abstract state machines

The Unified Modeling Language has become widely accepted as a standard in software development. Several tools have been produced to support UML model validation. These tools translate a UML model into a validation language such as PROMELA. However they have some shortcomings: there is no proof of correctness (with respect to the UML semantics) for these tools; and there is no tool that supports validation for both the static and dynamic aspects of a UML model. In order to overcome these shortcomings, we present a toolset which is based on the semantic model using abstract state machines. Since the toolset is derived from the semantic model, the toolset is correct with respect to the semantic model. In addition, this toolset can be used to validate both the static and dynamic aspects of a model.

Equivalence Is In The Eye Of The Beholder

Abstract In a recent provocative paper, Lamport points out “the insubstantiality of processess” by proving the equivalence of two different decompositions of the same intuitive algorithm by means of temporal formulas. We point out that the correct equivalence of algorithms is itself in the eye of the beholder. We discuss a number of related issues and, in particular, whether algorithms can be proved equivalent directly.

The assumptions of computing

The use of computers, like any technological activity, is not content-neutral. Users of computers constantly interact with assumptions regarding worthwhile activity which are embedded in any computing system. Directly questioning these assumptions in the context of computing allows us to develop an understanding of responsible computing.

Modular term-long CS2 projects

We present a model for a term-long computer science CS2 project which emphasizes modular code development and code-reuse while providing the opportunity to cover many traditional CS2 concepts. The project focuses on the construction of a simplified database system. The project is composed of a series of smaller assignments; each assignment requires students to replace or enhance work completed in previous assignments, thereby allowing students to experience the benefits of good modular design. Each project is of manageable size and complexity for both student and instructor, the final product is a program of non-trivial size and substantial functionality. The project can be easily varied from term to term in order to combat plagiarism, yet remains similar enough to administer reliably. We have successfully used this model over the last three years.