Showing papers in "Journal of Systems and Software in 1983"

TL;DR: A high-level approach to debugging is presented that offers an alternative to the traditional techniques and a set of tools that has been constructed to effect this approach are outlined.

TL;DR: This paper attempts to distill the large number of individual aphorisms on good software engineering into a small set of basic principles which form a reasonably independent and complete set.

TL;DR: A technique, software fault tree analysis, is described for the safety analysis of software that interfaces with hardware faultTree analysis to allow the safety of the entire system to be maximized.

TL;DR: A broader analysis of metric sensitivity to the structuring rules was conducted, and the conclusions reached differ greatly from those previously advocated in the literature; i.e., the metrics under consideration are shown to be relatively insensitive to program structure.

TL;DR: It is demonstrated that fine-grained incremental compilation is a relevant technique when implementing powerful debuggers an incremental programming environments and an incremental compiler for pascal has been implemented in the DICE system.

TL;DR: 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 is introduced.

TL;DR: This thesis discusses the HOS functional model, USE.IT, which provides for an integrated and automated development process of a system and the implications of their use.

TL;DR: A prototype, knowledge-based model of the fault localization process for program debugging, which includes the integration of prototypic and causal reasoning about faults and a recognition-based mechanism for program abstraction is developed.

TL;DR: The evolution of a debugger for C programs on the Blit, a multiprocessing bitmap terminal, is described and an opinion about the most fruitful direction for further application of graphics is offered.

TL;DR: A metric for the size of a data processing system is introduced which is a function of the number of files, flows, and processes of the system and the validity and reliability of this metric are demonstrated.

TL;DR: 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.

TL;DR: A discussion of modeling concepts and their applications is presented, including a case study showing the use of modeling in the debugging of an actual software system and remarks on research in progress.

TL;DR: In this article, the authors present a system for automatic verification of commerical application specifications called SOFSPEC, which is based on the entity/relationship model and encompasses four entities and six relationships with a varying number of attributes.

TL;DR: The design considerations behind a project to build a hardware assisted high-level debugger are discussed, which refers to debugging in terms of abstractions supported by the operating system and programming languages, as well as user defined abstractions built on top of these.

TL;DR: This paper discusses integration engineering approaches including a software-first strategy, simulation approaches, and an incremental release strategy as well as a project example.

TL;DR: A new approach to systems programming languages where a bridge is made between structure and pattern-directed invocation is described, along with the semantics of a support structure for message receiving and sending necessary for pattern- directed invocation of routines.

TL;DR: This paper critically analyzes some of the methods in use for reorganizing a program to improve its paging performance and proposes a new approach that is experimentally shown to produce better results.

TL;DR: A technique for software system behavior specification appropriate for use in designing systems with concurrency, based upon a generalized ability to define events, or significant occurrences in a software system, and then indicate whatever constraints the designer might wish to see imposed upon the ordering or simultaneity of those events.

TL;DR: Extended Petri nets are used to model the flow of messages and data during protection enforcement within MULTISAFE, a multimodule system architecture for secure database management.

TL;DR: This paper presents, from a tutorial point of view, a methodology of software development that can minimize the number of errors in a system when the system is being developed.

TL;DR: An integrated production system covering the phases specification, design, programming, documentation, test and integration-as well as project and configuration management is described, built upon a unified development methodology supported by interactive tools.

TL;DR: This approach integrates the facilities of a traditional debugger into a programming environment by providing access to runtime information through normal database query operations.

TL;DR: A multiphase security design methodology reflecting the current approach to data base design is presented, and a multilevel logical security system architecture is examined.

TL;DR: This paper describes a method for modeling and analyzing program execution on a stream-oriented, recursive data flow architecture based on a maximum path length technique, which results in an approximation of the time required to execute the program given adequate resources.

TL;DR: A notation is introduced that allows a designer to express a continuum of design ideas, from the specifications statement down to the final design statement, and an attempt has been made to minimize the concepts involved in the notation.

TL;DR: A significant increase in weapon system software productivity is needed to reduce the current spiraling maintenance costs and to allow for the orderly introduction of new high technology computers during the 1980's.

TL;DR: This paper presents a number of language extensions that permit the programmer to specify the degree of access control for each abstract object that a program can manipulate that permit access correctness to be completely determined at compile time.