Bo Ingvar Sandén

An entity-life modeling approach to the design of concurrent software

Using the idea of Entity-Life Modeling for task decomposition, the design of a prototypical elevator control system is explored and compared to an earlier JSD solution.

Entity-life modeling and structured analysis in real-time software design—a comparison

While structure analysis is sometimes used as a first step towards a real-time software design with concurrent tasks, a more appropriate task structure can often be based directly on concurrent patterns in the problem environment.

The case for electric design of real-time software

G. Booch (see ibid., vol.SE-12, no.2, p.211-21, Feb. 1986) has analyzed a problem involving the software of a set of free-floating buoys. The correspondence points out that Boochs analysis fails to address one important system issue, namely the fact that the software must support two concurrent activities, and shows that an analysis according to the M.A. Jackson method will reveal this difficulty at an early design stage. On the other hand, the Jackson approach does not deal with some configuration issues, which are handled in Boochs analysis. This shows that one method is sometimes not enough to address all important, systemwide aspects of a problem. Rather than arguing about which one design method is best, the author recommends taking an electric view and using any combination of approaches that yields important results in a given situation. >

Systems programming with JSP: example—a VDU controller

The generation of an embedded microprogram controlling a video display unit demonstrates how Jackson Structured Programming can be used effectively for both systems programming and microprocessor applications.

Designing control systems with entity-life modeling

Abstract This article proposes entity-life modeling as a way to design concurrent control system software. Multiple threads of control in the software are modeled on threads of events in the problem environment, and software objects are modeled on objects in the problem. The threads of events can often be seen as the lives of entities that compete for access to shared resources. This situation is directly captured in the software by means of threads of control competing for exclusive access to objects. Entity-life modeling is illustrated by means of a flexible manufacturing system designed in Ada.

Practical use of Ada 95's concurrency features

Ada 83 has numerous shortcomings for concurrent systems: it requires additional tasks, adding overhead and increasing interrupt latency, and it has difficulty handling asynchronous transfer of control. Ada 95 offers features that address these shortcomings and simplify concurrent implementation: protected units, interrupt handlers, priority entry queuing, dynamic task priorities, and asynchronous select statements. Using their Flexible Manufacturing System, the authors demonstrate how these features improve Ada and promote efficiency.

Design of Concurrent Software Based on Problem Concurrency

Two main approaches to the design of concurrent real-time software exist. One approach looks at how input data is transformed into output. The transformations essentially become the tasks. The other approach models the concurrency of the software on concurrency inherent in the problem. One example of this approach, entity-life modeling, starts by partitioning the events in the problem into concurrent threads, where each thread consists of a sequence of events with a minimum interval between each. Such a thread model is minimal if there is a time when all the threads occur simultaneously. A thread can often be seen as the “life” of some entity in the problem. Essentially, each thread gives rise to a task in the software. As an example, three different thread models of a flexible manufacturing system (FMS) are given. The FMS is essentially about resource contention. This can be made explicit by choosing a thread model where the entities contend for simultaneous, exclusive access to multiple resources.

A Five Year Perspective on Software Engineering Graduate Programs at George Mason University

This paper describes the experience obtained at George Mason University while developing a Master of Science program in software engineering. To date, the program has graduated over 45 students, with a current production rate of 10 to 15 a year. The paper also describes experience with a certificate program in software engineering, which is a software engineering specialization taken by Masters students in related disciplines, and the software engineering specialization within the PhD program in Information Technology. We discuss our courses, students, the successes that we have had, and the problems that we have faced.

Ada design of a neural network

A neural network is a computer program structured as a simplified model of a brain. It contains nodes (analogous to neurons) and connections between nodes (analogous to synapses). Neural networks can solve difficult pattern-matching problems. A node sums the inputs it receives from other nodes and passes the result through a transfer function to produce its output. A modifiable weight is associated with each connection. A network is trained on a given training set of inputs. During training, the weights are successively adjusted to produce the desired output.Classical design and implementation of neural networks are based on arrays that hold the node values and connection weights. The control structure consists of nested loops through these arrays. This paper suggests instead an object-based design where the nodes are modeled as objects to be operated on. This design models the conceptual network more closely and makes the software more understandable and maintainable. A generic Ada package representing a neural network is presented in some detail.

Correction to 'The case for electric design of real-time software'

The title of this paper (see ibid., vol.15, p.360-2 (1989)) was printed incorrectly. It should have read: the case for the eclectic design of real-time software. >