Alexander A. Stepanov

Algorithm-oriented generic libraries

We outline an approach to construction of software libraries in which generic algorithms (algorithmic abstractions) play a more central role than in conventional software library technology or in the object‐oriented programming paradigm. Our approach is to consider algorithms first, decide what types and access operations they need for efficient execution, and regard the types and operations as formal parameters that can be instantiated in many different ways, as long as the actual parameters satisfy the assumptions on which the correctness and efficiency of the algorithms are based. The means by which instantiation is carried out is language dependent; in the C + + examples in this paper, we instantiate generic algorithms by constructing classes that define the needed types and access operations. By use of such compile‐time techniques and careful attention to algorithmic issues, it is possible to construct software components of broad utility with no sacrifice of efficiency.

A library of generic algorithms in Ada

It is well-known that data abstractions are crucial to good software engineering practice. We argue that algorithmic abstractions, or generic algorithms, are perhaps even more important for software reusability. Generic algorithms are parameterized procedural schemata that are completely independent of the underlying data representation and are derived from concrete, efficient algorithms. We discuss this notion with illustrations from the structure of an Ada library of reusable software components we are presently developing.

Effect of uncertainty on continuous path planning for an autonomous vehicle

This paper describes one approach to the problem of path planning for an autonomous vehicle (an automaton) moving in two-dimensional space filled with obstacles. The approach is based on continuous processing of incoming local information about the environment. A continuous computational model for the environment and for the vehicle operation is presented. Information about the environment (the scene) is assumed to be incomplete except that at any moment the vehicle knows the coordinates of its target as well as its own coordinates. The vehicle is presented as a point; obstacles can be of any shape, with continuous borderline and finite size. Algorithms guaranteeing reaching the target (if the target is reachable), and tests for target reachability are presented. The efficiency of the algorithms is evaluated in terms of perimeters of obstacles met by the vehicle. It is shown that with the exception of some rather unusual initial positions of the vehicle relative to the obstacles, one of the presented algorithms guarantees an optimal path.

Tecton: A Language for Manipulating Generic Objects

abstract constructs define new classes of objects. The abstract construct is roughly the inverse of the refine construct. The instantiate, e, -, and infotm serve to include more knowledge about a class of objects, while ~SUZQ.~ is used to represent a class of objects in terms of another class. The instantiate construct records the information that a class of objects can be refined to another class; or, stated another way, a class of objects can be abstracted to another class. The latter could be obtained from the former by reversinq the arguments to instantiate. The use of these constructs is illustrated on structures (see below), a class of objects definable in Tecton, in 151. (Except that abstract was not discussed and refine was called enrich in that paper.) In the next section, we will give examples of some of these constructs; their use is also illustrated in the discussion of the communication network example. We discuss four different types of objects in Tecton which we have found useful in describing different kinds of activities of a complex software system: structures, entities, events, and environ- ments. Some of these types of objects have appeared previously in

Operators and algebraic structures

Operators in functional languages such as APL and FFP are a useful programming concept. However, this concept cannot be fully exploited in these languages because of certain constraints. It is proposed that an operator should be associated with a structure having the algebraic properties on which the operators behavior depends. This is illustrated by introducing a language that provides mechanisms for defining structures and operators on them. Using this language, it is possible to describe algorithms abstractly, thus emphasizing the algebraic properties on which the algorithms depend. The role that formal representation of mathematical knowledge can play in the development of programs is illustrated through an example. An approach for associating complexity measures with a structure and operators is also suggested. This approach is useful in analyzing the complexity of algorithms in an abstract setting.

DataMesh parallel storage servers

The DataMesh hardware architecture is that of an array of disk nodes, with each disk having an embedded 20 MIPS single-chip processor and 8-32MB of RAM. The nodes are linked by a fast, reliable small-area network, and programmed so that the ensemble appears as a single storage server. The first hardware prototype is operational now (software is still being developed); we hope to have the second, full-performance prototype about a year from now.

Singly Linked Lists Package

This package provides 66 subprograms (including those that are generic formal parameters) for manipulating a singly-linked-list representation of sequences, in which the elements are of any type (supplied by a generic parameter). The purposes of these subprograms may be classified into the following three categories: 1. Construction and modification of sequences 2. Examining sequences 3. Computing with sequences In this section we give a brief overview of these categories, leaving the details and examples of usage to the individual subprogram descriptions.

Double Ended Lists Package

This package creates a data type called Del and provides 47 subprograms for manipulating values of this type. Basically Dels are finite sequences and the operations provided are similar to to those of Singly Linked Lists (Chapter 6), but some operations such as concatenation are more efficient (constant time rather than linear in the length of the arguments). In addition, more security against certain kinds of semantic errors is provided, since the package user does not have direct access to pointer values. For example, with Singly Linked Lists it is possible using the Set Next operation to create a circular list, causing other operations to loop indefinitely, but this is not possible with Dels.

System Allocated Singly Linked Package

This is the simplest of the three low-level data abstraction packages provided. It provides records containing datum and link fields, allocated using the standard heap allocation and deallocation procedures.

Linked List Algorithms Package

This is a generic algorithms package that provides 31 algorithms for manipulating a linked list representation of sequences. Only a singly-linked representation is assumed, but many of the algorithms can also reasonably be used with other representations such as circular or non-circular doubly-linked representations. As can be seen from the subprogram implementations in the previous chapter, even for a singly-linked representation these algorithms can be instantiated in various ways to produce a substantially larger collection of useful operations.