Development Of Reliable Software Research Articles

A high level language-based computing environment to support production and execution of reliable programs

The authors present an environment which involves a debugging tool to aid in the detection and removal at logic errors. The debugging tool is supported by a special architecture, named SPRING, which was originally developed for reliable execution of Ada or Pascal programs. Following an overview of the system backed up by SPRING, the details of SPRING architecture are described, and the implementation of high level debugging on the SPRING architecture is discussed. In conclusion, the trial could be seen as a step toward providing an advanced programming environment for the development of reliable software.

Cost-effective reliable software engineering and development : Arumalla V. Reddi. Microelectron. Reliab.24, 677 (1984)

Cost-effective reliable software engineering and development : Arumalla V. Reddi. Microelectron. Reliab.24, 677 (1984)

Cost-effective reliable software engineering and development

In recent years the development of superfast computer systems with very high speeds and throughputs is growing rapidly with the tremendous advances in computer hardware technology. At the same time the software costs are becoming more dominant in the total system costs. Considering these aspects some of the most important considerations in the development and maintenance of computer software in cost-effective reliable software engineering and development are discussed. For the success of software managers, effective management and software engineering and development techniques have been presented to reduce the software life-cycle costs and to improve the efficiency of reliable software management in practice. An extensive survey of cost-effective reliable software engineering and development techniques, and the foundation upon which to establish the development and maintenance environment for future software systems are also provided.

On real-time features available in high-level languages and yet to be implemented

The requirements to be fulfilled by languages and systems in hard real-time environments are summarized. Subsequently, a comparison of the most prominent languages, viz. Ada, HAL/S, LTR, Pearl, as well as the real-time extensions of Fortran and PL/1, reveals how existing languages meet these demands and which features still need to be incorporated to enable the development of reliable software.

Reliability Issues in a Development of a Dedicated Real Time System

The development of reliable software for a telex exchange is described and conclusions are drawn concerning design methods, development tools and hardware features to improve reliability.

Implementing specification freedoms

The process of converting formal specifications into valid implementations is central in the development of reliable software. As formal specification languages are enriched with constructs to enhance their expressive capabilities and as they increasingly afford specificational freedoms by requiring only a description of intended behavior rather than a prescription of particular algorithms, the gap between specification and implementation widens so that converting specifications into implementations becomes even more difficult. A major problem lies in the mapping of high-level specification constructs into an implementation that effects the desired behavior. In this paper, we consider the issues involved in eliminating occurrences of high-level specification-oriented constructs during this process. Mapping issues are discussed in the context of our development methodology, in which implementations are derived via the application of correctness-preserving transformations applied to a specification language whose high-level expressive capabilities are modeled after natural language. After the general discussion, we demonstrate the techniques on a real system whose specification is written in this language.

Application of a Methodology for the Development and Validation of Reliable Process Control Software

This paper discusses the necessity of a good methodology for the development of reliable software, especialy with respect to the final software validation and testing activities. A formal specification development and validation methodology is proposed. This methodology has been applied to the development and validation of a pilot software, incorporating typical features of critical software for nuclear power plant safety protection. The main features of the approach indude the use of a formal specification language and the independent development of two sets of specifications. Analyses on the specifications consists of three-parts: validation against the functional requirements consistency and integrity of the specifications, and dual specification comparison based on a high-level symbolic execution technique. Dual design, implementation, and testing are performed. Automated tools to facilitate the validation and testing activities are developed to support the methodology. These includes the symbolic executor and test data generator/dual program monitor system. The experiences of applying the methodology to the pilot software are discussed, and the impact on the quality of the software is assessed.

On reliable software development for microprocessors: Inder M. Soi and K. K. Aggarwal. Microelectron. Reliab.20, 273 (1980)

On reliable software development for microprocessors: Inder M. Soi and K. K. Aggarwal. Microelectron. Reliab.20, 273 (1980)

S4: Aspects of Development and Verification of Reliable Process Computer Software

Any development of a reliable program should be based on a sound functional requirements specification which includes quantitatively the reliability figures that have to be met. At an early stage of the design process one should decide on how to verify and how to program together. In some cases an exhaustive systematic test is feasible. Testing is facilitated by appropriate program construction. Programs can include reasonableness checks; by special monitoring techniques one can decide on-line whether something has been tested or not. Probabilistic techniques include the use of reliability growth models during debugging, statistical tests of the debugged program and diverse programming.

On reliable software development for microprocessors

Microprocessor software is no longer microsized. It requires the same degree of methodology as is used for developing software for large mainframes. Software development for microprocessors involves much more than just writing the machine language instructions to perform some functions. This paper describes a systematic approach for microprocessor software development based on the concepts borrowed from large systems. The suggested methodology can go a long way to promise reliable software for microprocessor based systems. The approach lays emphasis on an ordered sequence of stages, well-supported development tools, good programming practices and management backing — all integrated into a systematic method. The methodology also suggests the use of an educational plan for new staff.

Microprocessors and software design tools

Software development aids available to the programmer are introduced. Application programs can be broken down into almost independent software modules. Each module can be independently developed and its interface with other modules defined. Microprocessor development systems, software components and future software are discussed. It seems that changes in computer system architecture are inevitable as LSI technology spreads computing, but this will also lead to better, more reliable software development tools.

A facility for defining and manipulating generalized data structures

A data structure definition facility (DSDF) is described that provides definitions for several primitive data types, homogeneous and heterogeneous arrays, cells, stacks, queues, trees, and general lists. Each nonprimitive data structure consists of two separate entities—a head and a body. The head contains the entry point(s) to the body of the structure; by treating the head like a cell, the DSDF operations are capable of creating and manipulating very general data structures. A template structure is described that permits data structures to share templates. The primary objectives of the DSDF are: (1) to develop a definition facility that permits the programmer to explicitly define and manipulate generalized data structures in a consistent manner, (2) to detect mistakes and prevent the programmer from creating (either inadvertently or intentionally) undesirable (or illegal) data structures, (3) to provide a syntactic construction mechanism that separates the implementation of a data structure from its use in the program in which it is defined, and (4) to facilitate the development of reliable software.

Efficient implementation and optimization of run-time checking in PASCAL

Complete run-time checking of programs is an essential tool for the development of reliable software. A number of features of the programming language PASCAL (arrays, subranges, pointers, record variants (discriminated type unions), formal procedures, etc.) can require some checking at run-time as well as during compilation. The problem of efficiently implementing such checking is considered. Language modifications to simplify such checking are suggested. The possibility of optimizing such checking is discussed.

Efficient implementation and optimization of run-time checking in PASCAL

Complete run-time checking of programs is an essential tool for the development of reliable software. A number of features of the programming language PASCAL (arrays, subranges, pointers, record variants (discriminated type unions), formal procedures, etc.) can require some checking at run-time as well as during compilation. The problem of efficiently implementing such checking is considered. Language modifications to simplify such checking are suggested. The possibility of optimizing such checking is discussed.

Efficient implementation and optimization of run-time checking in PASCAL

Complete run-time checking of programs is an essential tool for the development of reliable software. A number of features of the programming language PASCAL (arrays, subranges, pointers, record variants (discriminated type unions), formal procedures, etc.) can require some checking at run-time as well as during compilation. The problem of efficiently implementing such checking is considered. Language modifications to simplify such checking are suggested. The possibility of optimizing such checking is discussed.

On attaining reliable software for a secure operating system

This paper presents a general methodology for the design, implementation, and proof of large software systems, each described as a hierarchy of abstract machines. The design and implementation occur in five stages as described in this paper. Formal proof may take place at each stage. We expect the methodology to simplify the proof effort in such a way as to make proof a feasible tool in the development of reliable software. In addition to the anticipated advantages in proof, we feel that the methodology improves a designer's ability to formulate and organize the issues involved in the design of large systems, with additional benefits in system reliability. These advantages remain even if proof is not attempted. We are currently applying this methodology to the design and proof of a secure operating system. Each level in the system acts as a manager of all objects of a particular type (e .g ., directories, segments, linkage sections), and enforces all of the protection rules involved in the manipulation of these objects. In this paper we illustrate the methodology by examining three of the system levels, including specifications, for a simplified version of these levels. We also demonstrate some proofs of security-related properties and of correctness of implementation.

Managing the development of reliable software

This paper discusses the serious need for improved management methods and software development technology to support the production of truly reliable software and presents experience gained on TRW's Site Defense Program in addressing that need. The basic theme is simply this: We have attempted to achieve a better understanding of how to specify, design, build and validate reliable software; we have translated that understanding into an integrated and exceptionally disciplined software development methodology; we have used, evaluated and refined the methodology enough to recognize and report substantial early success and continuing progress toward that goal.