bluuebunny/crossref_metadata_2025_split huggingface dataset:
Context‐dependent flow‐sensitive interprocedural dataflow analysis
Authors: Johmann Kurt R. , Liu Sying‐Syang , Yau Stephen S. 
Published: November 2006

AbstractInterprocedural dataflow analysis is useful in compiler optimization, automatic vectorization and parallelization, dataflow anomaly detection, and software maintenance applications such as program revalidation, and software tools that make a program more understandable by showing data dependencies. These applications require the solution of dataflow problems such as reaching definitions, live variables, available expressions, and definition‐use chains. When solving these problems interprocedurally, the context of each call must be taken into account. In this paper, a method to solve this kind of dataflow problem is presented. This method consists of special dataflow equations that are solved for a program flowgraph. In deference to calling context, separate sets, called entry and body sets, are maintained at each node in the flowgraph. The entry set contains calling‐context effects that enter a procedure. The body set contains effects that result from statements in the procedure. By isolating calling‐context effects in the entry set, a call's nonkilled calling context is preserved by means of a simple intersection operation done at the return node for that call. The main advantages of this method are its precision and low complexity, and the fact that the presence of recursion does not affect the accuracy of the result.
An examination of software maintenance practices in a U.S. government organization
Authors: Brown Alan W. , Christie Alan M. , Dart Susan A. 
Published: November 2006

AbstractIn an effort to find out more about the effectiveness of the tools, procedures, and techniques that project personnel use in their work, the Computer‐Aided Software Engineering (CASE) Environments project at the Software Engineering Institute interviewed personnel in eight software maintenance projects within a U.S. Government organization. These interviews highlighted problems that we believe are typical of many software maintenance organizations and are the subject of this paper. While the interviews discovered a need for maintenance tools to support such areas as reverse‐engineering and regression testing, these problems often had their roots in deeper issues. Such issues were a lack of design for maintenance, ineffective communication and low status of maintenance work. This paper addresses these deeper issues and suggests some approaches for their resolution.
Program view generation and change analysis using attributed dependency graphs
Authors: Al‐Zoubi Ratib , Prakash Atul 
Published: November 2006

AbstractSoftware maintenance is usually the most expensive phase of the software life‐cycle. Program understanding and impact‐of‐change analysis are two of the major activities during this phase. In this paper, we describe attributed program dependency graphs (APDGs), a model to store information derived from the program source code and ease construction of tools for software maintenance. We show how the model can be used for interactive view generation and doing two kinds of impact‐of‐change analysis—incremental and comparison‐oriented. Incremental change analysis uses APDGs and a Rule Base to provide a way for the user to analysis the effect of proposed well‐defined changes. Comparison‐oriented change analysis allows a user to generate structural semantic differences between two versions of a subsystem after an arbitrary sequence of changes. We also introduce SCAN, a prototype collection of loosely integrated tools based on the APDG model and describe our experiences with the system.
Interview with E. Burton Swanson
Authors: Swanson E. Burton , Chapin Ned 
Published: November 2006

AbstractE. Burton Swanson summarizes and explains his typology of software maintenance (corrective, adaptive, and perfective), and describes his research on maintenance. His two major projects have been the large DPMA study done in 1977 with Bennet P. Lientz, and the in‐depth intensive study of twelve sites done a bit over a decade later with Cynthia M. Beath. Professor Swanson includes some of his views of the current situation and future in software maintenance.
Assessing modularization and code scavenging techniques
Authors: Canfora G. , Cimitile A. , Visaggio G. 
Published: November 2006

AbstractThe destiny of legacy software is a relevant economic problem. Many companies are experiencing the friction that legacy systems oppose to the change and growth of their business. Nevertheless, these systems cannot be simply discarded and replaced with new ones developed according to the new organization requirements. Existing systems record a great deal of knowledge and expertise used to set up solutions to real problems in different application domains and it is imperative that this knowledge must not be lost, partly because it may not be recorded anywhere else than in the code.This paper discusses the problems related to the modularization of legacy systems, with the emphasis being placed on the automation of code scavenging. It is argued that a balance must be struck between the modularization of legacy code, and the production of reusable, easy‐to‐evolve modules. The paper provides a framework for examining system modularization methods and identifies a set of attributes that define their quality. An overview of modularization techniques is presented, and an evaluation is made to assess their strength and identify and understand their major limitations. Finally, an attempt is made to identify techniques and tools that are nature enough to be transferred from research laboratories to industry.
Simulating a small machine for teaching purposes
Authors: Goble P. N. 
Published: November 2006

AbstractA need exists within universities, polytechnics and other educational establishments, for computers which are specifically designed for teaching purposes, particularly in the promotion of understanding how computers can be organized to process programs. Economically, it often makes more sense to design a teaching machine and then simulate it on an existing installation than to acquire a separate purpose‐built computer. This paper describes a simulation program that has been devised, and is currently in operation on the ICL 1907 at the University of Southampton, and comments on its power and use in the teaching situation.
An on‐line retail collection data system
Authors: Banton G. A. 
Published: November 2006

AbstractThis paper comprises a description of the evolutionary processes and the solution to the problem of a large data gathering system. The report defines the approaches and the use of an ‘intelligent’ terminal network, the file constructs and the main cycle programs designed for the system. Illustrations show the evolution from a mark sensing approach, with a slow 24 hour reconciliation, to an ‘on‐line’ application catering for ‘peaking’ of arrivals of milkmen and processing the return data as soon as receivedThe system is unique in its approach to a large dairy combine where costs, due to government control of price of products, have to be tightly controlled to provide adequate working margins.
Modularity the key to system growth potential
Authors: Taliaferro W. M. 
Published: November 2006

AbstractGeneral Electric's Apollo Systems has developed several information systems over the last eight years in support of the Apollo project. The expertise gained in these development efforts has shown the efficiency of a modularized approach to retrieval system designSystems analysts and programmers who design and build these systems should follow the normal systems engineering approach of requirements definition, system design, system implementation, test and verification and operational installation. Short‐cutting any one of these phases leads to greater effort in one of the later phases, usually with a longer over‐all schedule or greater developmental costProject management, too, is a major factor in the success of such systems. The tracking of critical milestones in the schedule, consistent and up‐to‐date documentation, and comprehensive test and verification plans are necessary to a controlled approach to systems implementationFinally, the benefits of such an approach are reduced cost and implementation time, along with simplification of system maintenance, standardized software, adaptability to new environments, and a potential for continued growth to meet users' ever‐expanding needs.
The evolution of a graphics system for linked computers
Authors: Kilgour A. C. 
Published: November 2006

AbstractThe development of a comprehensive two‐dimensional graphics package for an ICL 4130 with a high‐speed data link to a DEC PDP‐7 with Type 340 refreshed C.R.T. display and light pen is traced from its origin as a package of ALGOL procedures for graphical output. The design criteria imposed by the requirements for light‐pen tracking and identification of picture parts are described, and decisions which affected the subsequent development of the sysetm are identified and commented upon. The various types of display file editing which may be performed are described, and a facility mentioned for saving display files on the backing store of the PDP‐7. The idea of a ‘fixed‐function satellite’ is introduced and its potential usefulness in other operating environments discussed.
The design and implementation of the GINO 3D graphics software package
Authors: Woodsford P. A. 
Published: November 2006

AbstractThe design and implementation of a general purpose graphics software package (GINO) is described. GINO provides facilities for 3D graphics (co‐ordinate transformation, clipping, intensity modulation) but is organized so that 2D facilities form a clean subset. It is device independent, permitting use of refresh CRT displays, storage tube displays and plotters. A characteristic feature is the use of small satellite computers attached to a large multiaccess computer (ATLAS 2)GINO takes the form of a subroutine library accessible from FORTRAN and other languages, and the case for this level of graphics software is argued. The reasons for not using a mandatory graphical data structure are also discussed. GINO is not biased towards any particular style of interaction, but two techniques are described; one based on the light pen and the other on teletype command languagesEfficiency of implementation is achieved without loss of flexibility by use of a systems programming language (SAL).
MAPLIB–A data bank of FORTRAN functions describing material properties
Authors: Schumann U. 
Published: November 2006

AbstractMAPLIB is a program system which is able to incorporate the values of the properties of many materials in a form suitable for computer‐aided design. Thus, MAPLIB is a data bank whose customers are not men but computer programs with their much higher scanning rate. Therefore in MAPLIB the data are not stored in tables as usual but in algorithms implemented as FORTRAN functionsSuch a program system should fulfil a number of conditions related to standardization, flexibility, security, effectivity, transparency and compatibility. In this paper these conditions are discussed in some generality and it is shown how they are implemented in MAPLIB.
Programming and compiling strategies for paging systems
Authors: Weinberg Gerald M. 
Published: November 2006

AbstractDesigners of paging systems have tended to believe that programmers can influence system performance, but usually for the worse, rather than for the better. Their efforts to find operating system solutions to poorly styled programs may have discouraged efforts to produce paging‐oriented compilers, to educate programmers in techniques to use under paging, and to open communication channels between the programmer and the paging system—all of which now promise to give increased satisfaction with paging systems.
Intraprogram documentation
Authors: Flores Ivan 
Published: November 2006

AbstractThree kinds of documentation are examined: summary documentation describes the intent and nature of the program; detail documentation gives all the information the user needs to put the program to work; intraprogram documentation is information written into the program to inform the user or programmer. The need for intraprogram documentation occurs at four different times: in the initial design period; during debugging; as the program and system evolve; when it is necessary to adapt the program to other systemsThere are several means for providing intraprogram documentation. There are comments which can be placed in the header, on each line, at the beginning and end of a subroutine. Also noted is the important use of space for making the comments easier to read and for separating chunks of the program. Special symbols serve the same purpose. Examples are provided to bring home these points.
Workload characterization for timesharing system selection
Authors: Nolan Lawrence E. , Strauss Jon C. 
Published: November 2006

AbstractThe problem of selecting a general‐purpose timesharing system satisfying performance criteria for user‐oriented tasks is examined and a new approach is developed. This approach characterizes the user workload by a set of terminal user level functions and results in a representative script.A response time definition is developed and employed to measure the Xerox Sigma 7/UTS timesharing system and user community at McDonnell Douglas Automation Company.
The myth of multiprogramming
Authors: Schneck Paul B. 
Published: November 2006

AbstractA common myth surrounding multiprogramming is that it it a necessary mode of operation to deal with the high levels of I/O activity found on most computers. This paper shows that the high level of I/O activity is to a great extent a direct result of multiprogramming. Monoprogramming is proposed as a method of achieving high performance which yields advantages in turnaround time, efficiency and equipment configuration.
A general purpose task queueing mechanism for small machines
Authors: Lang T. , Fox D. A. 
Published: November 2006

AbstractA general purpose mechanism for the queueing of tasks is an important component in an ‘intelligent satellite’ system interfacing a community of users to a range of computing facilities. The queueing mechanism should provide spooling, warm and cold restarts, the ability to pool common resources (e.g. a number of line printers), a means of servicing the queues on a priority basis, and a flexible control mechanism for the system operators. The implementation of such a system for a small (i.e. 16‐bit) computer system is described.
Writing software in ALGOL
Authors: Brown P. J. 
Published: November 2006

AbstractFor many years the Burroughs Corporation has been writing software in ALGOL. Those of us who have no direct access to Burroughs hardware have always regarded this with interest, perhaps with envy. Nevertheless most of us have been just a little sceptical, as witnessed by the fact that, until recently, few have followed or imitated Burroughs' example. Outsiders have their doubts about efficiency and wonder about such questions as:Is it really ALGOL?Is the technique oriented to a particular type of hardware?Are there some machine‐language ‘fiddles’?This paper is simply a description of a personal software experience. Recently I had an opportunity to spend some time as a user of a Burroughs B6700, and to write some software for it in ALGOL. This article combines a tutorial introduction with a personal evaluation.
New format for flowcharts
Authors: Chapin Ned 
Published: November 2006

AbstractThis paper proposes a new chart format as an alternative for the flow diagram variety of flowchart. This new chart format is more informative, more compact and easier to use and draw than the ANS format, and facilitates modularization in design and programming. The new chart format supports restrictions on control transfers, and clearly identifies the control structures used in structured programming. The new chart format also permits showing multiple levels of detail unambiguously in a single flowchart, and enables HIPO charts and system charts to be usefully augmented.
The pfort verifier
Authors: Ryder B. G. 
Published: November 2006

AbstractThe PFORT Verifier is a program which checks a FORTRAN program (i.e. a main program and a set of subprograms) for adherence to a large, carefully defined, portable subset of American National Standard FORTRAN called PFORT. Unlike many FORTRAN implementations, the Verifier diagnoses errors in interprogram‐unit communication through argument lists and COMMON. The Verifier is itself written in PFORT and has been installed on a variety of computers. This paper describes the development of PFORT and the Verifier. A detailed definition of PFORT noting its differences from ANS FORTRAN is included.
Parallel processing in fortran with floating‐point hardware
Authors: Nelson James M. , Cohn Charles E. 
Published: November 2006

AbstractWith some types of floating‐point hardware, the central processor is free to perform other tasks while a floating‐point operation completes. The FORTRAN complier for the SEL‐840MP computer was modified to execute subscripting calculations in parallel with floating‐point operations where possible. This is done by operating on the triad table for an expression before scanning it to generate code. Skip pointers are inserted into the table to change the order in which entries are processed.
A portable diagnostic facility for SNOBOL4
Authors: Griswold Ralph E. 
Published: November 2006

AbstractIn programming systems based on abstract machine modelling concepts, the underlying structure of the abstract machine can be made available to the software implemented on it. The result is an unusual facility for diagnosis and exploration of software structure. Such a facility has been added to the macro implemention of SNOBOL4. This paper describes the nature of the facility, illustrates its use, and presents some results of using it for language implementation and development.
The translation and interpretation of stab‐12
Authors: Colin A. J. T. , Shorey K. , Teasdale W. 
Published: November 2006

AbstractThis paper describes two of the abstract machines used to support the STAB‐1 language, and discusses some problems of implementing the language on two different computers, the DEC PDP‐11 and CTL's Modular‐1, Interpretation of the abstract machine code and direct translation is considered for both computers.
Experience with a conversational parser generating system
Authors: Cohen Jacques 
Published: November 2006

AbstractThe author describes some of his experience gained by working in the area of syntax‐directed compilers and parser generating systems during the past ten years. His most recent work in this area was designing and supervising the implementation of a conversational parser generator which has been operational for about two years. The paper describes this generator, its implementation, usage and the characteristics which make it practical to use. The author's main conclusion is that althouth it is relatively easy to implement nuclei of parser generating systems which are of educational value, the implementation of a practical system requires a major programming effort.
A general‐purpose software measurement tool
Authors: Ferrari Domenico , Liu Mark 
Published: November 2006

AbstractA software measurement tool designed for the users of PRIME, an interactive system being developed, is presented. The tool, called SMT, allows its user to instrument a program, modify a pre‐existing instrumentation and specify how the collected data are to be reduced by typing in a few simple commands. The user can also write his own measurement routines, which specify the actions to be taken at event detection time, and submit them to the SMT; after checking their correctness, the SMT deals with them as with its built‐in, standard measurement routines. The design goals of a general‐purpose tool like the SMT are discussed, and the prototype version of the tool, which has been implemented, is described from the two distinct viewpoints of a user and of a measurement‐tool designer. An example of the application of the prototype to a measurement problem is illustrated, the reasons why not all of the design goals have been achieved in the implementation of the prototype are reviewed, and some of the foreseeable extensions of the SMT are described.
Development of an advanced satellite system
Authors: Fox D. A. , Lang T. 
Published: November 2006

AbstractA basic satellite system consists of a minicomputer, with card reader and line printer, emulating the Remote Job Entry (RJE) workstation of a mainframe manufacturer. The addition of a disk stroe increases the range of facilities which can be offered by such a system. Apart from a number of subsidiary advantages, this leads to a system which can interface a community of computer users to its mainframe computing facilities, and hence to a user image which is stable over some long period of time. The paper outlines how an advanced satellite system was simply assembled from four basic components. These components were written in different languages by different institutions, but the use of a standard message passing programming interface provided a sound framework for the detection and elimination of errors.
RATFOR—a preprocessor for a rational fortran
Authors: Kernighan Brian W. 
Published: November 2006

AbstractAlthough Fortran is not a pleasant language to use, it does have the advantages of universality and (usually) relative efficiency. The RATFOR language attempts to conceal the main deficiencies of Fortran while retaining its desirable qualities, by providing decent control flow statements and some ‘syntactic sugar’. RATFOR is implemented as a preprocessor which translates this language into FortranOnce the control flow and cosmetic deficiencies of Fortran are hidden, the resulting language is remarkably pleasant to use. RATFOR programs are markedly easier to write, and to read, and thus easier to debug, maintain and modify than their Fortran equivalentsIt is readily possible to write RATFOR programs which are portable to other environments. RATFOR is written in itself in this way, so it is also portable; versions of RATFOR are now running on computers of six different manufacturersThis paper discusses design criteria for a Fortran preprocessor, the RATFOR language and its implementation, and user experience.
Portability—prediction and correction
Authors: Hague Stephen J. , Ford Brian 
Published: November 2006

AbstractWe 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.
Quick compiler construction using uniform code generators
Authors: Lancaster Ronald L. , Schneider Victor B. 
Published: November 2006

AbstractThis paper describes our experience in using a common set of code generating subroutines as the basis for compilers of ALGOL W, ALGOL 60 and subsets of PL/I and COBOL. The advantages of using a common set of primitives for implementing more than one compiler include: (1) greatly reduced effort to implement additional languages; (2) simplified maintenance of the generated compilers; (3) standardized diagnostic messages for all compilers implemented using this system; and (4) simplified documentation of the compilers.
A user‐oriented approach to control languages
Authors: Brunt R. F. , Tuffs D. E. 
Published: November 2006

AbstractThis paper describes the design approach adopted for SCL which is the control language of System B, the operating system of ICL's new 2900 Series of computers. The design emphasis of SCL is ‘usability’ and the paper sets out to show that SCL provides what users require.The authors both work in the Systems Programming Division of ICL where the majority of their recent work has centred around the design of job management in System B and SCL in particular.