Softing software engineering system

An integrated production system covering the phases specification, design, programming, documentation, test and integration—as well as project and configuration management is described. The system is built upon a unified development methodology supported by interactive tools. It encompasses a quality assurance procedure based on the automatic control of all intermediate products. It also provides a development database for project planning and control. The system is presently under development in Budapest, Hungary. Three of the planned seven subsystems are already operating in West Germany.     

The softest program test system

This paper reviews the current status of both research and commercial testing systems, and addresses the features necessary for a commercial test system. These include test case specification, test data generation, testbed generation, program instrumentation, automatic test execution and validation, as well as dynamic analysis of control and data flow. Of particular value is the linking of the details of the test to the program specification by means of an assertion language. These and other features are then described within the contest of , an integrated system for testing Assembler, , and / 1 programs in a simulated test environment. This system is now being used to validate programs in a test laboratory.     

A functional programming approach to the specification and verification of concurrent systems

Networks of communicating processes can be viewed as networks of stream transformers and programmed in a lazy functional language. Thus the correctness of concurrent systems can be reduced to the correctness of functional programs. In this paper such correctness is proved formally in the-calculus extended with recursion equations for functional programs. The-calculus is chosen since it allows the definition of properties by least fixed points (induction) as well as by greatest fixed points (coinduction), and since greatest fixed points are useful for formalising properties, such as fairness, of infinitely proceeding programs. Moreover, non-deterministic processes are represented as incompletely specified deterministic processes, that is, as properties of stream transformers. This method is illustrated by proving the correctness of the alternating bit protocol.     

An approach to testing specifications

An approach to testing the consistency of specifications is explored, which is applicable to the design validation of communication protocols and other cases of step-wise refinement. In this approach, a testing module compares a trace of interactions obtained from an execution of the refined specification (e.g., the protocol specification) with the reference specification (e.g., the communication service specification). Nondeterminism in reference specifications presents certain problems. Using an extended finite state transition model for the specifications, a strategy for limiting the amount of nondeterminacy is presented. An automated method for constructing a testing module for a given reference specification is discussed. Experience with the application of this testing approach to the design of a transport protocol and a distributed mutual exclusion algorithm is described.     

The external structure: Experience with an automated module interconnection language

To study the problems of modifiable software, the Software Technology project has investigated approaches and methodologies that could improve modifiability. To test our approaches tools based on data abstraction—a design and programming language and a module interconnection language—were built and used. The incorporation of the module interconnection language into design altered the traditional model of system building. Introducing novices to our approach led to the formalization of new models of program design, development, and evaluation.     

Development and application of a white box approach to integration testing

Program testing techniques can be classified in many ways. One classification is that of “black box” vs. “white box” testing. In black box testing, test data are selected according to the purpose of the program independent of the manner in which the program is actually coded. White box testing, on the other hand, makes use of the properties of the source code to guide the testing process. A white box testing strategy, which involves integrating a previously validated module into a software system is described. It is shown that, when doing the integration testing, it is not enough to treat the module as a “black box,” for otherwise certain integration errors may go undetected. For example, an error in the calling program may cause an error in the module's input which only results in an error in the module's output along certain paths through the module. These errors can be classified as Integration Domain Errors, and Integration Computation Errors. The results indicate that such errors can be detected by the module by retesting a set of paths whose cardinality depends only on the dimensionality of the module's input for integration domain errors, and on the dimensionality of the module's inputs and outputs for integration computation errors. In both cases the number of paths that need be retested do not depend on the module's path complexity. An example of the strategy as applied to the path testing of a COBOL program is presented.     

High-level debugging of distributed systems: The behavioral abstraction approach

Most extant debugging aids force their users to think about errors in programs from a low-level, unit-at-a-time perspective. Such a perspective is inadequate for debugging large complex systems, particularly distributed systems. In this paper, we present a high-level approach to debugging that offers an alternative to the traditional techniques. We describe a language, edl, developed to support this high-level approach to debugging and outline a set of tools that has been constructed to effect this approach. The paper includes an example illustrating the approach and discusses a number of problems encountered while developing these debugging tools.     

Arts—an automated requirements traceability system

Management of the hundreds or thousands of requirements associated with a large aerospace system is a tedious, error-prone process. Automated Requirements Traceability System (ARTS) has been developed to automate this process. ARTS is a bookkeeping program that operates on a data base consisting of system requirements and their attributes. It provides upward and downward traceability in a hierarchical structure, as well as data base management and output operations on any requirement-related attributes selected by the user. ARTS is currently implemented on the UNIVAC 1110, DEC VAX-11/780, and IBM computers.     

A pragmatic approach to resolution-based theorem proving

Resolution theory offers a simple, complete method for proving theorems but is generally considered impractical. The theorems we are interested in proving arise in the analysis of programs and usually involve quantification. We have developed a system for proving these theorems using resolution, but have embedded in it a simplifier as the central component. The simplifier is an integrated collection of algorithms for normalizing arithmetic, relational, and logical expressions. The knowledge in the simplifier is encoded in procedures, rather than as axioms or rules. We use the simplifier to prove certain theorems, reduce the clutter in theorems, and reduce the cost of unification, Inherent in the normal form algorithms is the notion of strengthening (e.g., inferringa =b froma b ANDb a). We have incorporated the notion into the unification algorithm as well. The design of the system permits its use along a spectrum from pure resolution to resolution with interpretation of the arithmetic and relational operators. Strengthening is a heuristic that permits the movement along this spectrum. We call the approachi-resolution.i-resolution does not preserve completeness; it does define a means for approaching completeness efficiently and systematically. It thus attempts to provide a pragmatic approach to mechanical theorem proving.     

Generalized path expressions: A high-level debugging mechanism

This paper introduces a modified version of path expressions called Path Rules which can be used as a debugging mechanism to monitor the dynamic behavior of a computation. Path rules have been implemented in a remote symbolic debugger running on the Three Rivers Computer Corporation PERQ computer under the Accent operating system.     

A methodology to model the information structure of an organization

The Integrated Computer Aided Manufacturing (ICAM) program of the U.S. Air Force identified a need to better communicate and analyze manufacturing for the people involved in improving productivity. To satisfy that need, the ICAM program developed the IDEF (ICAM Definition) method to address particular characteristics of manufacturing. This IDEF method is equally applicable in analyzing other types of organizations. IDEF comprises three modeling methodologies: function model methodology (IDEF₀), information model methodology (IDEF₁) and dynamics model methodology (IDEF₂). This paper reports on the Information model methodology only. This methodology is used to construct an information model that helps in understanding the structure of information needed to support the functions of an organization.     

Software project management audits

This paper shows how project audits can be used to uncover project strengths and weaknesses. Three audits are described and findings of the audit teams are summarized. Audits helped identify organizational problems, lacking management discipline, and software testing approaches useful to other projects. The issue of product sales versus disciplined project management was faced in all three audits. How this issue was handled is discussed and related to the success or lack of it for each project.     

Software project development cost estimation

This paper reports the results of an empirical investigation of the relationships between effort expended, time scales, and project size for software project development. The observed relationships were compared with those predicted by Lawrence Putnam's Rayleigh curve model and Barry Boehm's COCOMO model. The results suggested that although the form of the basic empirical relationships were consistent with the cost models, the COCOMO model was a poor estimator of cost for the current data set and the data did not follow the Rayleigh curve suggested by Putnam. However, the results did suggest that it was possible to develop cost models tailored to a particular environment and to improve the precision of the models as they are used during the development cycle by including additional information such as the known effort for the early development phases. The paper finishes by discussing some of the problems involved in developing useful cost models.     

Targets-Drives-Means: A declarative approach to dynamic behavior specification with higher usability

Small humanoid robots are becoming more affordable and are now used in fields such as human–robot interaction, ethics, psychology, or education. For non-roboticists, the standard paradigm for robot visual programming is based on the selection of behavioral blocks, followed by their connection using communication links. These programs provide efficient user support during the development of complex series of movements and sequential behaviors. However, implementing dynamic control remains challenging because the data flow between components to enforce control loops, object permanence, the memories of object positions, odometry, and finite state machines has to be organized by the users. In this study, we develop a new programming paradigm, Targets-Drives-Means, which is suitable for the specification of dynamic robotic tasks. In this proposed approach, programming is based on the declarative association of reusable dynamic components. A central memory organizes the information flows automatically and issues related to dynamic control are solved by processes that remain hidden from the end users. The proposed approach has advantages during the implementation of dynamic behaviors, but it requires that users stop conceiving robotic tasks as the execution of a sequence of actions. Instead, users are required to organize their programs as collections of behaviors that run in parallel and compete for activation. This might be considered non-intuitive but we also report the positive outcomes of a usability experiment, which evaluated the accessibility of the proposed approach.     

A computer algebra approach to verification and deduction in many-valued knowledge systems

 A theoretical result [10] that relates tautological consequence in many-valued logics to the ideal membership problem in algebra is revisited. The intended use of the approach in this article and its implementation is the verification of consistency and the automated extraction of knowledge in rule-based knowledge systems. Programs are written in the CoCoA language. Four RBS are studied to illustrate the implementation.