H. Conrad Cunningham

A UNITY-Style Programming Logic for a Shared Dataspace Language

The term shared dataspace refers to the general class of programming languages in which the principal means of communication among the concurrent components of programs is a common, content-addressable data structure called a dataspace. In the programming language and artificial intelligence communities, there is considerable interest in such languages, e.g., logic-based languages, production rule systems, and the Linda language. However, these languages have not been the subject extensive program verification research. This paper specifies a proof system for the shared dataspace language Swarm a proof system similar in style to that of UNITY. The paper then uses the... Read complete abstract on page 2.

Using classic problems to teach Java framework design

Abstract All programmers should understand the concept of software families and know the techniques for constructing them. This paper suggests that classic problems, such as well-known algorithms and data structures, are good sources for examples to use in a study of software family design. The paper describes two case studies that can be used to introduce students in a Java software design course to the construction of software families using software frameworks. The first is the family of programs that use the well-known divide and conquer algorithmic strategy. The second is the family of programs that carry out traversals of binary trees.

Mapping component specifications to Enterprise JavaBeans implementations

Component-based software development has become an important approach to building complex software systems. Much research focuses on component specification to achieve the advantages of the component-based approach in theory. Most of this research pays little attention to the mappings from component specifications to component implementations. However, the mappings are important because they determine whether the implementations perform satisfactorily to meet the specifications. After presenting a general approach to component specification and the technology of Enterprise JavaBeans (EJB) component model, this paper presents three approaches to mapping from component specification to EJB implementation. This paper uses a course registration system as an example to demonstrate the ideas. The approaches presented will be helpful to those who are working on the realizations of component systems.

BoxScript: a component-oriented language for teaching

As component-oriented approaches become increasingly pervasive in the development of complex software systems, it becomes increasingly important to introduce computing science students to appropriate programming concepts, languages and techniques. This paper describes the design of the component-oriented language BoxScript, which seeks to address the needs of teachers and students for a clean, simple language. This paper first enumerates the principles applied in the language design and then presents the key concepts and features of BoxScript. The paper illustrates the language features by using an example and by comparing it with several other component-oriented programming languages.

Building a layered framework for the table abstraction

This paper describes the design of a small application framework for building implementations of the Table Abstract Data Type (ADT). The framework is built upon a group of Java interfaces that collaborate to define the structure and high-level interactions among components of the Table implementations. The key concept in the design is the separation of the Table’s key-based record access mechanisms from the physical storage mechanisms. The design is sufficiently flexible to support a wide range of client-defined records and keys, indexing structures, and storage media. The design also takes advantage of several well-known software design patterns and of formal design contracts to increase reliability, understandability, and consistency.

Specification and refinement of a message router

The paper considers a variant of the message router problem discussed during the Concurrency and Distribution sessions of IWSSD-6 by H.C. Cunningham and J.T. Udding (1992). First, it presents a high-level specification of the router as a reactive system expressed in the UNITY logic. Second, it refines the interface of the router using a new approach called the reactive envelope heuristic. Third, it decomposes the router into a grid of switches. In closing, the paper analyzes the specification and refinement techniques used in the study and proposes future research.<<ETX>>

Toward Comprehensive Specification of Distributed Systems

A new approach to modelling distributed systems is presented. It uses sequential processes and event synchronization as building blocks to construct a cohesive picture of the interdependent requirements for the functionality, architecture, scheduling policies, and performance attributes of a distributed system. A language called CSPS (an extension of Hoares CSP) is used in the illustration of the approach. Employing CSP as a base allows modelled systems to be verified using techniques already developed for verifying CSP programs and leads to the emergence of a uniform incremental strategy for verifying both logical and performance properties of distributed systems. Several small... Read complete abstract on page 2.

Mapping SPL Feature Models to a Relational Database

Building a software product line (SPL) is a systematic strategy for reusing software within a family of related systems from some application domain. To define an SPL, domain analysts must identify the common and variable aspects of systems in the family and capture this information so that it can be used effectively to construct specific products. Often analysts record this information using a feature model expressed visually as a feature diagram. The overall goal of this project is to enable wider use of SPLs by identifying relevant concepts, defining systematic methods, and developing practical tools that leverage familiar web programming technologies. This paper presents a novel approach to specification of feature models: capture the details using automatically generated user interfaces, encode the models in a relational database, and then validate the models and construct specific products using SQL.

Designing a Flexible Framework for a Table Abstraction

In a provocative essay from the mid-1980s, Brooks asserts that “building software will always be hard” because software systems are inherently complex, must conform to all sorts of physical, human, and software interfaces, must change as the system requirements evolve, and are inherently invisible entities (Brooks 1986). A decade later Brooks again observes, “The best way to attack the essence of building software is not to build it at all” (Brooks 1995). That is, software engineers should reuse both software and, more importantly, software designs.

Framework design using function generalization: a binary tree traversal case study

A software framework is a technology that enables software reuse, potentially yielding rich dividends but requiring significant long-term investment. However, a framework is not a panacea because it is more difficult to design than a single application. Systematic approaches seek to make framework design more convenient and less error-prone. This paper illustrates the function generalization approach to framework design by developing a framework for binary tree traversals. A binary tree traversal is a well known algorithm, which makes it an excellent example. The approach involves a systematic process for generalizing a fixed application expressed as Haskell functions to produce a set of functions that precisely describe the generalized application. This generalized application encompasses various common and variable aspects of a family of applications. By using design patterns as a guide, the resulting set of functions can be converted to a Java framework.