bluuebunny/crossref_metadata_2025_split huggingface dataset:
Measurement of the maintenance process from a demand‐based perspective
Authors: Abran Alain , Nguyenkim Hong 
Published: November 2006

AbstractWhile various figures have been published on the workload distribution of maintenance activities, this information is at best indicative of management perceptions, most of it originating from surveys, and almost none based on actual data. The reason for such a lack of published data is very simple: the industry does not measure or collect maintenance‐type data in a timely and accurate fashion. This article presents empirical data from a two‐year measurement effort in the maintenance environment of a Canadian financial institution. The findings reported here are based on a daily data‐collection process including 2152 work requests, which required 11 332 days to complete.Based on the supply/demand paradigm, maintenance data have been collected and analysed to investigate the basis of productivity analyses through such concepts as the product group, the product mix and the product mix changes on the demand side, as well as resource allocation by product classification and quarterly and yearly distribution changes. This paper includes a discussion on the measurement program implemented, and illustrates how insights into the maintenance process are gained through various measurements. The paper also presents hard data on the demand side and on the supply side of the maintenance process, as well as an analysis of the data collected. The findings reported are part of a larger measurement program introduced to manage the maintenance area in the same way as any other business unit.
Software maintenance characteristics and effective management
Authors: Chapin Ned 
Published: November 2006

AbstractThis statistical study examines management effectiveness and its relation to software maintenance. The findings include that low‐level managers in software maintenance who see their organizations as well managed also see their organizations as having a constellation of software maintenance characteristics. Compared to equivalent managers in other organizations, that perception includes doing less corrective maintenance and less new development, but doing more enhancement work on systems. It includes doing software maintenance with staff having a lower average experience level, on programs which commonly are bigger. It includes a lower maintenance backlog per maintenance person. The general picture is that effective management in the organization is more associated with relatively trouble‐free systems, more often being, by choice, enhanced, rather than it is associated with meeting new and changed organizational needs by developing new systems.
Abstracting a specification from code
Authors: Ward Martin 
Published: November 2006

AbstractMuch of the work on developing program transformation systems has concentrated on systems to assist in program development. However, the four separate surveys carried out between 1977 and 1990 (Foster and Kiekuth, 1990; Lientz and Swanson, 1980; Morton, 1988; Nosek and Palvia, 1990), summarized in Foster (1991), show that between 40% and 60% of all commercial software effort is devoted to software maintenance rather than the development of new systems. In this paper we describe a joint project between the University of Durham and CSM Ltd to develop a method and tool for reverse‐engineering and software maintenance based on program transformation theory. We present an example which illustrates how such a tool can extract a high‐level abstract specification from the low‐level source code of a program by a process of formal program transformation based on a theory of program equivalence (Ward, 1989a). All the code‐level reverse‐engineering of the example program was carried out on the prototype tool with the resulting code pasted directly into the paper.
Abstraction refinement: A model of software evolution
Authors: Keller Benjamin J. , Nance Richard E. 
Published: November 2006

AbstractA model of the software evolution process, called the Abstraction Refinement Model, is described. The model has three components: descriptions of the software system, a pre‐order of relative correctness between system descriptions, and transformations between the system descriptions. Using a non‐deterministic language as the collection of system descriptions, the collection of equivalence classes under the abstraction order forms a distributive join‐semilattice. This algebraic structure enables the partitioning of the language into narrow‐spectrum sub‐languages on which the transformations are defined.The algebraic structure of the model is interpreted to represent software evolution as a sequence of transformations on system descriptions. Both development and maintenance are characterized by forward and reverse transformations, with development being primarily forward‐engineering and maintenance balanced between forward‐ and reverse‐engineering.This interpretation is instructive regarding maintenance. Three levels of methodological sophistication are shown by the three representations of maintenance possible in the model. These approaches underscore the need for a maintenance methodology which must account for the completeness of the system documentation. Methodologies should then include reverse‐engineering to contend with the information loss problem from development. A result is that only two types of reverse‐engineering paths are possible in the model.
Data linkage maps
Authors: Neil Martin , Bache Richard 
Published: November 2006

AbstractMost work in software metrics has been aimed at measuring the quality or cost of software. This paper gives an example of how metrics may be used to give information about how the software system is organized, specifically the data linkage between procedures in the source code. The data linkage measures capture how closely procedures are bound together by data flowing between them. The paper shows how data linkage within a program can be represented in a diagrammatic form. This approach makes use of multivariate statistics and is applied to two examples. Results are then compared with the authors' intuitions of how the example programs are organized. This approach could be used as an automatic aid to maintainers.
Resolving the software maintenance paradox
Authors: Blum Bruce I. 
Published: November 2006

AbstractThis paper explores the apparent paradox that, although performance improves with experience, the maintenance of a software system becomes more difficult as experience with it accumulates. It is asserted that this phenomenon is a side effect of the environment used to maintain the software. A decade of experience with a large and complex clinical information system is summarized to demonstrate that software maintenance may be inherently less difficult than original development. It is shown that a highly integrated, million‐line, operational system, used in life‐threatening situations, has been maintained effectively by a staff of six. During the past five years, the size of the system increased by 167%. In addition to maintaining a growing number of programs, the staff produced new programs at a rate of 0.64 programs per effort‐day. Moreover, the case study also demonstrates that this level of performance can be transported to other sites. The paper concludes with some observations regarding changes to the software process that will resolve the paradox.
An empirical study of software maintenance tasks
Authors: Jørgensen Magne 
Published: November 2006

AbstractAn empirical study of software maintenance tasks was carried out in a large Norwegian organization in the period 1992–93. More than one hundred randomly selected maintenance tasks were studied through interviews with the maintainers performing the tasks immediately before they started the tasks and immediately after they had completed the tasks. The collected data is used to develop distributions and to test 33 hypotheses about software maintenance. The findings from the study indicate, for example, thatApplication system documentation plays only a minor role as maintenance information source.The maintenance productivity, measured in LOC/effort, is predicted by the size of the task and type of change in the source code, but seems rather independent of language level, maintainer experience, application age and application size.There is an economy of scale for software maintenance tasks.The type of programming language does not correlate with proportion of unexpected maintenance problems, task complexity or task size.The proportion of corrective maintenance decreases with increasing age of the application.
Software reconnaissance: Mapping program features to code
Authors: Wilde Norman , Scully Michael C. 
Published: November 2006

AbstractMaintainers of old code often need to discover where particular program features are implemented. This paper presents a method, called ‘software reconnaissance’ for answering this question through an analysis of the execution of different test cases. The method is quite easy to implement, requiring only a test coverage monitor, some simple tools, and a surprisingly small number of test cases.A statistical case study is presented that shows the kind of results that can be obtained on a typical medium‐sized program. The method seems to be effective in identifying a small number of code components that are unique to a particular program feature, though it may not find all components that make up the feature's delocalized plan. A small protocol case study shows that professional programmers can learn to use the method quickly and can use the information that it produces.Software reconnaissance may be a simple but useful addition to the maintainer's tool kit in that it provides starting points for understanding a large program and a way of recovering some requirements traceability information from old code. For the researcher, it also provides a novel functionality ‘view’ of software that maps features to program components at different levels of precision.
Maintenance management: From product to process
Authors: Middleton Peter 
Published: November 2006

AbstractThis paper is concerned with just‐in‐time (JIT) manufacturing techniques and how they can be applied to the management of software maintenance. Traditional maintenance methods focus on the change to be made or the defect to be fixed. Their aim is to get the product working as quickly as possible. This paper argues that this approach of pushing work through the maintenance system is flawed. The experience of the manufacturing industries which have global competitors, is that focusing only on results does not win. An alternative is to concentrate on the process of software maintenance. This paper reports on initial experiments with two teams of programmers using JIT techniques for maintaining software. The purpose was to see if JIT could produce benefits when applied to this knowledge‐intensive and unpredictable task. If there is a software maintenance process, then JIT may be a way to optimize the functioning of this process. JIT requires that fault fixes or changes to the software are pulled, rather than pushed, through the maintenance process. A functioning JIT process gives immediate information on the quality of the process because programmers return any work which is not correct.The conclusion is that JIT approaches can work and do improve the quality of the maintenance done. The key impediments to using JIT in maintenance are the changes it requires in the way people work and the requirement for a different focus in the management of software maintenance.
An analysis of Pascal programs in compiler writing
Authors: Shimasaki Masaaki , Fukaya Shigeru , Ikeda Katsuo , Kiyono Takeshi 
Published: November 2006

AbstractA method and results of static and dynamic analysis of Pascal programs are described. In order to investigate characteristics of large systems programs developed by the stepwise refinement programming approach and written in Pascal, several Pascal compilers written in Pascal were analysed from both static and dynamic points of view. As a main conclusion, procedures play an important role in the stepwise refinement approach and implementors of a compiler and designers of high level language machines for Pascal‐like languages should pay careful attention to this point. The set data structure is one of the characteristics of the Pascal language and statistics of set operations are also described.
Programming by successive refinement of data abstractions
Authors: Morris James B. 
Published: November 2006

AbstractThe Model Programming Language implements a form of data abstraction that has been used in a large programming project, the Demos Operating System. The use of the abstraction mechanism suggests a particular programming style that has evolved over an extensive period of gaining experience with the language. The programming style and Model's approach to data abstraction are both documented here using an example designed to illustrate several of the more important issues. The goal of the paper is to demonstrate a programming style and an approach to data abstraction in a programming language that has proved useful in a significant systems programming application.
High speed data acquisition: Running a realtime process and a time‐shared system (UNIX) concurrently
Authors: Harland David M. 
Published: November 2006

AbstractA technique is outlined by which a normal time‐shared operating system may be modified to permit concurrent processing of a realtime data sampling operation and the typical time‐insensitive operations of the time‐shared system.Guidance is given regarding the implementation of such a proposal and it is discussed in relation to the UNIX operating system.It is pointed out that concurrent processing of a multi‐user time‐shared system and a single‐user time‐dependent sampling routine offers a more efficient use of the computer processor, when realtime sampling must be undertaken, while still offering a service to other users. Such a scheme may be an alternative to implementing a full‐scale realtime operating system for the exclusive use of the sampling operations.
Domain architecture and the ICL 2900 series
Authors: Izatt W. T. 
Published: November 2006

AbstractThe resilience of large operating systems has been of concern since their inception. Out of this concern has arisen a general approach to protection, here described as the Domain Concept. In this paper, after summarizing the concept and some interpretations of it, the architecture of the large operating system VME/B on the ICL 2900 series is described and examined to discover how near to that concept is its approach. The consequence of a domain architecture, that such a machine should be suitable for the implementation of subsystems, is investigated with emphasis on subsystems written by a user for his own private purposes.
Stabdump—a dump interpreter program to assist debugging
Authors: McGregor D. R. , Malone J. R. 
Published: November 2006

AbstractProgram development can be greatly speeded by a dump analysis program which makes the state of a program more visible to the programmer. A single comprehensive analysis presenting as much of the relevant material in as concise a manner as possible has proved superior in use to the alternative of interactive analysis one item‐at‐a‐time. The methods adopted in the STAB utility to achieve comprehensive and concise output are described. The system and compiler modifications necessary to support this type of system are discussed.
UNIX with satellite processors
Authors: Barak Amnon B. , Shapir Amos 
Published: November 2006

AbstractThe steps necessary to extend the UNIXUNIX is a trademark of Bell Laboratories.
time sharing system to a network which includes a central processor and a set of satellite processors is described. Software interfaces permit a program in the satellite processor to behave as if it were running in the central processor. Tasks are executed in parallel in several processors resulting in improved reliability and response time. The economics of such systems becomes more feasible with the reduction of the cost of CPUs and memories and the increasing demand for dedicated local computers.
Pattern analysis as a tool for inventing algorithms
Authors: Hart Richard 
Published: November 2006

AbstractA method for inventing algorithms and several examples are presented. The Julian conversion is useful for all date calculations and for switching to daylight saving time. The algorithm rotates the calendar by 2 months and performs a few straightforward calculations on the new month‐day‐year to produce the Julian date (and back again).The butterfly sort is based on the work on Woodrum. The algorithm repeatedly delivers two linked lists to a merge machine that produces a single linked list for further use. The length of the two lists going into the merge machine never differs by more than one. This accounts for the theoretical minimal number of comparisons5.The algorithm uses patterns within a simple binary counter to schedule the delivery of these lists. This accounts for the minimal number of steps between each comparison3.
A portable trace for the Pascal heap
Authors: Schach S. R. 
Published: November 2006

AbstractDebugging aids for high‐level languages supporting structured data types should provide diagnostic information in a form terminologically as close as possible to that of the original source code. In addition, it is desirable that such software be portable.The package HEAPTRACE satisfies both the above criteria. It is a precompiler for Pascal programs which enables the user to trace the heap, selectively dumping dynamically‐created records in a high‐level format. It is portable as it is written entirely in Pascal; furthermore, since it is implemented as additions and modifications to a well‐known compiler, its principles may easily be built into any Pascal compiler or diagnostics system.However, there is a small price to pay for achieving portability in that three possibly desirable features cannot be satisfactorily implemented in a machine‐independent manner.
A critical comparison of several programming language implementations
Authors: Boom H. J. , de Jong E. 
Published: November 2006

AbstractThe implementations of Algol 60, FORTRAN, Pascal and Algol 68 provided on the CDC Cyber 73 of the Stichting Academisch Rekencentrum Amsterdam are compared on both qualitative and quantitative aspects. This paper concentrates on those aspects which are likely to be of interest to language designers and implementers, and to users of other computer systems.
Checking cyclic pointers
Authors: Radford P. 
Published: November 2006

AbstractVariables which are incremented modulo‐M are a feature of many resource control schemes, where the resources are allocated and released in strict sequence. If resources pass through several phases of use, again in strict sequence, then several variables may be used to keep track of the resources.Because of the modulo‐M arithmetic checking the consistency of a set of variables may be thought sufficiently difficult to warrant the exclusion of checking. There is a simple technique for checking consistency however and this note describes it.
Multiprogramming and memory contention
Authors: Smith Alan Jay 
Published: November 2006

AbstractWe study memory contention during multiprogramming when programs are free to compete for page frames. A random walk between the possible partitions of memory over the set of active programs is used to model memory contention and calculate throughput. Our model of contention takes into account program characteristics by using miss ratio curves, and also considers memory size and page fetch latency. With the aid of numerous trace‐driven simulations, we are able to verify our model, finding good agreement both in the observed distribution of memory among competing programs and in CPU utilization. We find that for high ratios of secondary to primary memory access time and under conditions of high memory contention, small programs with compact working sets are able to run with far less than expected interference from larger, more diffuse programs. In the case of multiprogramming the same program several times, we find that observed partition distributions are not necessarily even and that higher than expected levels of CPU use are observed. Lower ratios of access time are found to yield different results; programs compete on a more even basis and partition memory relatively more evenly than with higher ratios.
An assessment of modula
Authors: Holden J. , Wand I. C. 
Published: November 2006

AbstractWirth has recently published a new programming language called Modula which he suggests is suitable for the programming of process control systems, computerized laboratory equipment and input/output device drivers. The authors have written a compiler for Modula running on a PDP‐11 and generating object code for the same machine. Their experience in writing device drivers for a number of PDP‐11 devices is reported, including simple mains frequency clocks, disks, CAMAC and a graphics processor. Some difficulties arose during the writing of these programs; these are investigated and solutions proposed, either within the existing language or by minor modifications to the language. The study shows the extent to which Modula meets the requirements for a general purpose real‐time systems‐implementations programming language; areas of deficiency are noted.
A portable file directory system
Authors: Hanson David R. 
Published: November 2006

AbstractA portable file directory system that provides a machine‐independent method for specifying files is described. The portable directory system, or PDS, facilitates uniform usage of portable software by supplying a standard for file specification. The PDS supports a hierarchical directory structure, similar to that in UNIX and Multics, and a set of primitives for manipulating the structure and preparing files for input/output. While the PDS participates in file specification, it does not participate in the actual i/o; it has no impact on i/o efficiency. The implementation, which is easily extended to include additional capabilities, is described. Experience in using the PDS as a part of command interpreters and preprocessors is also discussed.
A framework for modelling graphic interactions
Authors: Gangopadhyay Dipayan 
Published: November 2006

AbstractIn the present‐day graphics field, a proper methodology for designing input constructs of a general purpose graphics system is needed. In this direction, this paper proposes a framework where the graphics interaction programming is formulated as event‐driven procedures. The end‐user actions on the input tools are represented as events and the programreactions to these events as action‐processes. The constructs for programming in this framework are implemented as a part of a graphics package SODDI. The resultant programming facilities are compared with the other existing proposals, based on the conceptual differences of the respective frameworks as well as on the experiences in using the constructs. The data‐structures used for implementing these constructs are also presented.
Uses of the SIMULA process concept
Authors: Palme Jacob 
Published: November 2006

AbstractThe class concept of the SIMULA programming language is well known as the father of the concept of abstract data types. A SIMULA class can however also act as a process. This paper illustrates by some examples for existing programs how the process aspect of the class concept can be used to structure programs in neat ways. All the examples are taken from real production programs in heavy usage today, but the examples have been simplified in this paper to illustrate the main ideas.