Gerald M. Karam

Visualization using timelines

A timeline is a linear, graphical visualization of events over time. For example, in concurrent application, events would represent state changes for some system object (such as a task or variable). A timeline display generator creates the graphical visualization from some record of events. This paper reports on a model for timeline display generators based on a formal model of event history and the objectives of timeline visualization. In this model, any timeline display generator is completely described through the definition of a set of mathematical functions. The exact characteristics and flexibility of a particular implementation of a timeline display generator, depends on the way in which these functions have been implemented. The current prototype, xtg, (Timeline Display Generator for X-windows) serves as an example implementation of these ideas. Characteristics of xtg are presented, and its use in the analysis of a real-world client-server application is discussed. Xtg has been applied to several other applications to-date and is being applied by several telecommunications companies to areas ranging from software process analysis to call trace data analysis.

Cooperating knowledge-based assistants for the office

This paper presents an approach to high-level support of office workers by embedding office knowledge in a network of distributed cooperating knowledge-based or expert “assistants” and servers. These knowledge-based systems incorporate both factual and procedural knowledge and are capable of making use of existing conventional office technology. They constitute a form of computer-supported cooperative work. We describe a common architecture for our assistants and servers that incorporates several key features. Our systems are capable of supporting concurrent multiple consultations or tasks and have facilities for the interruption and resumption of consultations as appropriate. The various assistants and servers, which may reside on different machines, cooperate in solving problems or completing tasks by passing messages. We propose a taxonomy of the general office knowledge normally used by office workers, together with a frame and rule-based knowledge representation scheme. We also describe an experimental system, written in PROLOG, that incorporates the above design principles.

A cataloging framework for software development methods

A framework providing a basis for comparing and evaluating software development methods (SDMs), which are systems of technical procedures and notational conventions for the organized construction of software-based systems, is presented. Using the framework, practitioners and methodologists can describe and rate an SDMs support for 21 properties. The application of the framework to two examples, OMT and R.J.A. Buhrs (1990) architectural design, is discussed. Several suggested uses of the framework include: comparing a group of SDMs with one another; defining a standard in terms of the framework and then using this as a basis for discussion; examining an SDM to discover its coverage and capabilities; and combining the properties of different SDMs to create a new SDM.<<ETX>>

Software CAD: a revolutionary approach

A research project is described in which an experimental software CAD environment called the Carleton embedded system design environment (CAEDE), oriented toward embedded systems and Ada, was developed to provide a demonstration of the concept and to serve as a research testbed. The major contribution of CAEDE is a demonstration of a visual paradigm which combines semantic depth and syntactic shallowness, relative to Ada, in a manner that makes it possible for the embedded-system designer to work in terms of abstract machines while still thinking Ada. A secondary contribution is the identification of Prolog as a promising approach for supporting tool development in an environment which supports the visual paradigm. Also described are experimental tools for temporal analysis, performance analysis, and the generation of skeleton Ada code. >

Starvation and critical race analyzers for Ada

Starvation and critical race analysis tools for Ada designs are described. These tools are part of a temporal analysis toolset that includes an operational specification language, a language interpreter, and a deadlock analyzer for Ada. The starvation analyzer is based on a set-theoretic model of starvation. It uses a proof tree produced by the deadlock analyzer to define the possible computation space of the design. A preprocessing phase of the starvation tool optimizes the analysis so that the resulting analysis is efficient. Unlike livelock analysis in state machines, the starvation analyzer does not require a priori specification of home states to discern liveness. The critical race analysis tool provides semiautomatic proof of critical races by identifying nondeterministic rendezvous (races) from the proof tree generated by the deadlock analyzer, and then assisting the human operator in identifying which of these constitute critical races. Several design examples are used to demonstrate the capabilities of the two analysis methods. >

Critical races in Ada programs

It is noted that critical races in concurrent Ada programs are an insidious source of system errors, and that the Ada language does not have concurrency features to ease the development of critical race-free programs. The authors illustrate this using the CRF language, which extends the Ada language by the addition of a powerful caller selection mechanism. It is this facility that implements a discriminatory mutual exclusion (dimutex) construct, an important feature for building less critical race-prone programs. The MLog language supports the CRF caller selection mechanisms; thus it is convenient as a rapid-prototyping platform. A design method for systematically converting CRF designs into Ada designs is presented. The method uses a mixture of mechanical and creative transformations that are guaranteed not to introduce critical races. D. Helmbold and D. Luckhams (1985) gas-station example is used to illustrate the various approaches to applying the design method. >

TimeBench: a CAD tool for real-time system design

This paper provides an overview of TimeBench, a prototype CAD tool for designing real-time systems, as well as some experiences gained through building and using it. TimeBench aims to support a true engineering design process for real-time systems in a largely graphical working environment. The environment includes support for design synthesis, analysis, and system generation, with equal emphasis on the design of operational structure and the design of temporal behavior. Its main features include: (1) a hybrid graphical---textual design description notation (MachineCharts, Abstract Controller Machines, and MachineChart Language), (2) design experimentation through an embedded interpreter and behavior visualization tools to animate designs, (3) further design evaluation through a performance modelling tool based on fast approximate analystic methods, and (4) a code generation system than can be tailored to produce code for a desired environment.

Temporal logic-based deadlock analysis for Ada

A temporal logic-based specification language and deadlock analyzer for Ada is described. The deadlock analyzer is intended for use within Timebench, a concurrent system-design environment with support for Ada. The specification language, COL, uses linear-time temporal logic to provide a formal basis for axiomatic reasoning. The deadlock analysis tool uses the reasoning power of COL to demonstrate that Ada designs specified in COL are systemwide deadlock-free: in essence, it uses a specialized theorem prover to deduce the absence of deadlock. The deadlock algorithm is shown to be decidable for finite systems and acceptable otherwise. It is also shown to have a worst-case computational complexity that is exponential with the number of tasks. The analyzer has been implemented in Prolog. Numerous examples are evaluated using the analyzer, including readers and writers, gas station, five dining philosophers, and a layered communications system. The results indicate that analysis time is reasonable for moderate designs in spite of the worst-case complexity of the algorithm. >

An icon-based design method for Prolog

An icon-based design method that combines a module-oriented Prolog design model, graphical software design, and software engineering principles is presented. It is based on a dataflow-driven decomposition that is guided by design principles, followed by evaluation. Its purpose is to enable Prolog applications to be developed in accordance with the general principles of software engineering: modifiability, efficiency, reliability, and understandability. The design model and procedure are described. The design of a Lisp interpreter is considered to illustrate the method.<<ETX>>

Using design fragments to modularize the design of communications in concurrent systems

This paper introduces design fragments as a fundamental component of a design process for strong traceability in the design of concurrent systems. Design fragments represent reusable alternatives for the independent design of the communication requirements in a concurrent system. They are defined with formal relations to segments of communicating state machines, and are applied such that they satisfy the semantics of the communications defined by the specification. This paper introduces the concept of design fragments, the approach to developing and using them, along with an illustrative example.<<ETX>>