Mkscan—An interactive scanner generator

Mkscan is a tool for generating and editing scanners. It has been designed with ease of use in mind. The tol is interactive and uses a full screen interface. No attempt is made to provide an all-purpose tool that can generate a recognizer for any regular language. Instead, mkscan has been tailored to suit the lexical structure of common programming languages and command languages. Using mkscan, a scanner for Pascal can be created in under ten minutes–including the time taken to type the list of keywords.     

Automation and Testing of Character-graphic Programs

This paper describes a technique that allows automation and testing of character-graphic programs using existing public-domain tools. Specifically, Tcl, Tk, and Expect are augmented with a terminal emulator in order to build a screen representation in memory. This screen can be queried in a high-level way and the interaction can be further controlled based on the screen representation. One immediate use of this is to build a test suite for automating standards conformance of the interactive programs in POSIX 1003⋅2 (Interactive Shells and Utilities). This technique is portable and inexpensive. All the software described in this paper is free or in the public domain. © 1997 by John Wiley & Sons, Ltd.     

GCI—A tool for developing interactive cad user interfaces

GCI is a Unix-based tool for developing interactive CAD programs. By separating command/ menu definitions from the progam, GCI makes it easier to change and extend the user interface. The language provided by GCI is used to define the syntax of commands, menus, messages, and help text. Generally, GCI supports a static hierarchical structure of commands and menus. However, through a program interface, an application program has the freedom to change environments, commands and menus. This flexibility of run-time control of the user interface is essential for developing highly responsive interfaces in a CAD environment. This paper presents the main concepts and definition language of GCI. It then discusses architectural and implementation issues, and finally presents a typical application's view of using the tool.     

Dave—a validation error detection and documentation system for fortran programs

This paper describes DAVE, a system for analysing Fortran programs. DAVE is capable of detecting the symptoms of a wide variety of errors In programs, as well as assuring the absence of these errors. In addition, DAVE exposes and documents subtle data relations and flows within programs. The central analytic procedure used is a depth first search. DAVE itself is written in Fortran. Its implementation at the University of Colorado and some early experience are described.     

SOFTLIB — a documentation management system

This paper describes a software sysem (SOFTLIB) that has been developed to assist in the management of software documentation generated during systems development projects. It provides facilities to manage large numbers of documents, to file documents when they are complete and to issue them to system developers and maintainers. It also includes an information retrieval facility that allows programming staff to find documents, to examine their contents before issue and to assess the state of the software project documentation. SOFTLIB is explicitly intended to help manage the documentation generated during software development — it is not designed for use by end-users of that software or for managing end-user documentation. The novel characteristic of this system is the approach that is taken to the consistency and completeness of documentation. The documentation associated with a software system is organized in such a way that it may be detected if document sets are complete (that is, if all documentation which should be provided for a software component is available) and if document sets are likely to be inconsistent. This means that if a document has been changed without a comparable change being made to other associated documents, this is detectable by the librarian system. In addition, a subsidiary aim of our work was to investigate the utility of menu systems to complex software tools by building a user interface to SOFTLIB. We conclude that menu systems are far from ideal in such situations because of the range of possible options which must be handled by the system.     

A multi-level analysis of factors affecting software developers’ intention to reuse software assets: An empirical investigation

Reuse of software assets in application development has held promise but faced challenges. In addressing these challenges, research has focused on organizational- and project-level factors while neglecting grass-root level adoption of reusable assets. Our research investigated factors associated with individual software developers’ intention to reuse software assets and integrated them in TAM. Towards that end, 13 project managers were interviewed and 207 software developers were surveyed in India. Results revealed that the technological-level (infrastructure), and individual-level factors (reuse-related experience and self-efficacy) were major determinants. Implications are discussed.     

RATSNO—an experiment in software adaptability

Adaptable programs are one of the benefits of structured programming. The adaptability of a program is the degree to which it can be transformed into another program that performs a similar, but slightly different, function. While it is clear that the aims of structured programming are best satisfied by the use of modern programming languages, a great number of programmers must use languages such as Fortran. To alleviate this situation, a number of preprocessors have been introduced that give Fortran a more structured facade. This paper describes an experiment performed to test the adaptability of programs written in RATFOR, one of these preprocessors. Judging from the results, the use of a good preprocessor can significantly increase the adaptability of Fortran programs.     

ASSIST—a tool to support software inspection

Software inspection is a valuable technique for defect detection. Recent research has considered the development of computer support, with the aim of providing even greater benefits when applying inspection. This has resulted in the development of a number of prototype support systems. These suffer from some fundamental limitations, however. Asynchronous/Synchronous Software Inspection Support Tool (ASSIST) is designed to tackle these limitations and to provide a platform for rigorous investigation of the inspection process. It uses a custom-designed language known as Inspection Process Definition Language to allow support of any inspection process, and provides an open, expandable system allowing multiple document types to be catered for easily. A number of facilities designed to enhance the inspection process are also present.     

EDIT—an interactive network service; design and implementation

EDIT is a time-sharing system which offers interactive services over the NPL network. These services include various kinds of editing, word processing, data movement and file control. The system is implemented on a PDP11/40 and can serve up to 30 users simultaneously, on high-speed displays and other terminals. There is an attached background processor (PDP11/45) which supports graphics and background jobs. This paper describes the design and implementation of EDIT and relates this to the needs of the system and of its users.     

PBASIC — a verifier for BASIC

The increase in the number of available dialects of BASIC has lead to the usual difficulties encountered when transporting software. The proposed American National Standard Minimal BASIC represents a small but almost universal subset of all BASICs. PBASIC is a verifier for ANS Minimal BASIC. The verifier is itself written in PFORT, a portable subset of FORTRAN IV.     

Selection of third party software in Off-The-Shelf-based software development—An interview study with industrial practitioners

The success of software development using third party components highly depends on the ability to select a suitable component for the intended application. The evidence shows that there is limited knowledge about current industrial OTS selection practices. As a result, there is often a gap between theory and practice, and the proposed methods for supporting selection are rarely adopted in the industrial practice. This paper's goal is to investigate the actual industrial practice of component selection in order to provide an initial empirical basis that allows the reconciliation of research and industrial endeavors. The study consisted of semi-structured interviews with 23 employees from 20 different software-intensive companies that mostly develop web information system applications. It provides qualitative information that help to further understand these practices, and emphasize some aspects that have been overlooked by researchers. For instance, although the literature claims that component repositories are important for locating reusable components; these are hardly used in industrial practice. Instead, other resources that have not received considerable attention are used with this aim. Practices and potential market niches for software-intensive companies have been also identified. The results are valuable from both the research and the industrial perspectives as they provide a basis for formulating well-substantiated hypotheses and more effective improvement strategies.     

Bridging the gap between information architecture analysis and software engineering in interactive web application development

Web development teams comprise non-computer experts working on the conceptual modeling of non-functional aspects in software applications. Later on, such conceptual information is processed by analysts and software engineers to face the technical phases of the software project. However, this information transfer is often difficult to automate since the information processed by the different professionals involves different abstraction levels, as well as important cost and effort that need to be considered. The main aim of this research is to minimize these problems by increasing automation and interoperability in the development of interactive web applications. To take up this challenge, we have created and evaluated a tool that aims at bridging the gap between the conceptual definitions of web contents–i.e., the information architecture, and the UML elements for analysis and design required by software engineers, connecting functional and non-functional information to achieve the rest of technical activities during the software development process.     

Software reliability models—A selected annotated bibliography

Many articles on software reliability models have been published in the last two decades. Because of the importance of this area and increasing interest in it, this annotated bibliography of 100 selected publications has been prepared. First, books, edited works and review papers of general interest are summarized and this is followed by separate introductions to various types of models.     

Talk—an interactive system for a small computer

TALK is an interactive file creation and editing system implemented on a very small computer. It provides facilities for FORTRAN syntax checking and an interactive ‘desk-calculator’. Major computing tasks are sent over a high speed link to CDC 6600/6400 computers A number of teleprinters can be controlled by TALK in the usual way, but also the card reader/line printer pair may be used as a terminal. This is useful for creating or printing large files When a user has logged in he can work in one of several modes. These include INPUT, EDIT and CALCULATE modes. It is possible to nest modes, for example, by entering CALCULATE mode while in INPUT mode without losing one's place in the input file An unusual feature of TALK is the ‘inclusion’ facility. This enables a user to specify previously filed text to be included within another file, either as the file is being created or dynamically whenever the file is used. It also gives users the ability to build up macros of commonly used commands. Many system commands are in fact macros with only simple primitives provided as executable code.     

Self-healing systems — survey and synthesis

As modern software-based systems and applications gain in versatility and functionality, the ability to manage inconsistent resources and service disparate user requirements becomes increasingly imperative. Furthermore, as systems increase in complexity, rectification of system faults and recovery from malicious attacks become more difficult, labor-intensive, expensive, and error-prone. These factors have actuated research dealing with the concept of self-healing systems. Self-healing systems attempt to “heal” themselves in the sense of recovering from faults and regaining normative performance levels independently the concept derives from the manner in which a biological system heals a wound. Such systems employ models, whether external or internal, to monitor system behavior and use inputs obtaining therefore to adapt themselves to the run-time environment. Researchers have approached this concept from several different angles this paper surveys research in this field and proposes a strategy of synthesis and classification.     

Portability—prediction and correction

We consider the attainment of portability through the successive refinements of an initial coding attempt. This may be seen as prediction followed by correction. Recent attention has been given to the mechanical selection of software variants stored in a single composite file. We conclude that, under some circumstances, it is also necessary to consider the updating of the file as well as extraction from it.     

Compile—time detection of aliasing in euclid programs

Aliasing of variables occurs when two or more identifiers accessible in the same scope refer to the same storage location. When aliasing is present, the meaning of assignments becomes obscure because assignment to one variable identifier may change the value of others. Some of the more obscure kinds of variable aliasing can be the cause of particularly insidious bugs in computer programs. Axiomatic proof systems, such as that used for the Euclid language, assume that no aliasing is present so that the meaning of assignment is clear. For this reason, Euclid requires that no aliasing be present in Euclid programs and requires the compiler to implement checks to ensure this. This paper discusses the features of Euclid that aid in the detection of aliasing. It enumerates the kinds of aliasing that can be present in Euclid programs and gives efficient one-pass algorithms for compile-time detection of potential aliases. Aliasing is related to interference between concurrent processes, and a similar algorithm for detection of inter-process interference in Concurrent Euclid programs is presented.     

Make — a program for maintaining computer programs

Good programmers break their projects into a number of pieces, each to be processed or compiled by a different chain of programs. After a set of changes is made, the series of actions that must be taken can be quite complex, and costly errors are frequently made. This paper describes a program that can keep track of the relationships between parts of a program, and issue the commands needed to make the parts consistent after changes are made. Make has been in use on UNIX

1 UNIX is a trademark of Bell Laboratories.

systems since 1975. The underlying idea is quite simple and can be adapted to many other environments.     

Usage-based reading—an experiment to guide reviewers with use cases

Reading methods for software inspections are used for aiding reviewers to focus on special aspects in a software artefact. Many experiments were conducted for checklist-based reading and scenario-based reading concluding that the focus is important for software reviewers. This paper describes and evaluates a reading technique called usage-based reading (UBR). UBR utilises prioritised use cases to guide reviewers through an inspection. More importantly, UBR drives the reviewers to focus on the software parts that are most important for a user. An experiment was conducted on 27 third year Bachelor's software engineering students, where one group used use cases sorted in a prioritised order and the control group used randomly ordered use cases. The main result is that reviewers in the group with prioritised use cases are significantly more efficient and effective in detecting the most critical faults from a user's point of view. Consequently, UBR has the potential to become an important reading technique. Future extensions to the reading technique are suggested and experiences gained from the experiment to support replications are provided.