bluuebunny/crossref_metadata_2025_split huggingface dataset:
The maintenance problem of application software: An empirical analysis
Authors: Alkhatib Ghazi 
Published: November 2006

AbstractThis paper presents findings from the analysis of data contained in reports and documents maintained by an MIS department of a major pharmaceutical and nutritional manufacturer. To guide data collection, the paper develops a conceptual framework consisting of a descriptive scheme and an explanation model. The descriptive scheme classifies maintenance activities into four categories: adaptive, corrective, perfective, and ongoing support. The explanation model identifies meta‐factors that affect maintenance activity. The meta‐factors are age, size, programming language, processing environment, structured programming, modularization, analysis and design methodologies, end‐user involvement, documentation generation, and maintenance management. The paper analyses three business functions with high, middle, and low average time per repair maintenance project (ATM) measured in person‐hours over a period of one year. Each function has several systems, and each system consists of modules. The analysis of available data for all functions maintained shows that maintenance (both repair and update) consumed 49% of data processing (DP) resources. For the three functions, the majority of these resources are devoted to perfective maintenance and corrective maintenance. Guided by the explanation model, several variables belonging to the meta‐factors are identified. The following variables have the most significant influence over maintenance: real‐time processing, database processing, end‐user ongoing support, module size, number of runs and runtime per module, and number of reports and number of copies per function.
A framework for software maintenance: A foundation for scientific inquiry
Authors: Haworth Dwight A. , Sharpe Shane , Hale David P. 
Published: November 2006

AbstractThis manuscript develops a framework for software maintenance. The development is based on an approach called ‘grounded theory’, which is an iterative process of theory formation and empirical assessment. The framework's purpose is to unite past theoretical concepts and scientifically observed facts. The result is a four‐component model consisting of programmers, source code, maintenance requirement, and organizational influences. The interaction of these four components provides 16 distinct areas of software maintenance inquiry. The manuscript concludes by providing sample uses and implications for the use of the framework.
Document quality indicators: A framework for assessing documentation adequacy
Authors: Arthur James D. , Stevens K. Todd 
Published: November 2006

AbstractThis paper presents the results of an ongoing investigation that focuses on assessing the adequacy of project documentation through an identified taxonomic structure relating numerous documentation characteristics. Previous research in this area has been limited to the study of isolated characteristics of documentation and English prose, without considering the collective contributions of such characteristics. The research described in this paper takes those characteristics, adds others, and establishes a well‐defined approach to assessing the ‘adequacy’ of software documentation. The identification of document quality indicators (DQIs) provide the basis for the assessment procedure. DQIs are hierarchically defined in terms of document qualities, factors that refine qualities and quantifiers that provide for the measurement of factors.
On the re‐engineering of transaction systems
Authors: Kozaczynski Wojtek , Wilde Norman 
Published: November 2006

AbstractThis paper provides a framework for considering the problems of re‐engineering transaction processing systems. Such systems are key components of most modern business operations, and their continued enhancement is crucial for competitiveness.The paper grew out of a study of software re‐engineering problems and practices carried out by Andersen Consulting at several major companies in the telecommunications industry. It describes some of the practical difficulties found in re‐engineering transaction systems, especially the problems caused by the need for an incremental approach and the difficulties of re‐engineering in parallel with the continuing evolution of the operational system.This paper presents a model of the maintenance and re‐engineering processes showing the main activities that are needed and the data flows among them. Existing tools for re‐engineering are then analysed against this model to identify gaps and potential for further tool development. Finally, there is a brief discussion of the very stringent personnel needs of software re‐engineering projects.
MACS: Maintenance assistance capability for software
Authors: Georges Mari 
Published: November 2006

AbstractMACS1 has for its objective the definition and implementation of a software maintenance assistance system. A basic premise is that all maintenance activities require understanding of the application under maintenance, and hence the maintainer could profit by expression of the application's design (the facts) and the rationale behind it (the reasons). Furthermore, MACS proposes to aid the maintainer in approaching the problem at hand, in formulating and applying a strategy, and in fully exploiting the possibilities of the MACS tools themselves. Using knowledge representation and expert system techniques, the MACS project is developing a tool‐set that will provide the means to analyse existing systems and to capture information about new applications, for maintenance purposes.
Reverse‐engineering cobol via formal methods
Authors: Lano K. , Breuer P. T. , Haughton H. 
Published: November 2006

AbstractWe describe methods and software tools which aid in reverse‐engineering COBOL application programs back to specifications (and in validating them against specifications). The aim is to create object‐based abstractions from the implementation to capture design and functionality. The central process which the tools support is ‘transformation from formalism to formalism’, first from COBOL to the intermediate language Uniform, then from Uniform to a functional description language, and then to the specification language Z. In the process, dataflow diagrams, entity‐relationship diagrams and call‐graphs, and other types of information, are extracted from the code.
pRETS: A parallel reverse‐engineering toolset for FORTRAN
Authors: Harrison Warren , Gens Cynthia , Gifford Bruce 
Published: November 2006

AbstractThe widespread acceptance of parallel and distributed processing will result in migration of millions of lines of sequential code to parallel environments over the next decade. Unlike movement across sequential environments, significant structure and code changes must be made in order to benefit from the increased processing power of parallel computing. Nowhere is this problem more obvious than in the scientific computing community. The sequential nature of FORTRAN has limited its ability to utilize the performance achievable from parallel and/or distributed systems.Strand, a concurrent logic programming language based on Edinburgh Prolog, is intended to exploit concurrency in both parallel and distributed environments, while offering portability across a variety of platforms and topologies. Strand minimizes reprogramming of existing software by providing a Foreign Language Interface (FLI) which allows inclusion of C and/or FORTRAN code in Strand programs. This paper describes a set of tools called the pRETS (parallel Reverse engineering ToolSet) which supports the semi‐automated conversion of FORTRAN programs into Strand Foreign Language Kernels.
A reverse‐engineering approach to subsystem structure identification
Authors: Müller Hausi A. , Orgun Mehmet A. , Tilley Scott R. , Uhl James S. 
Published: November 2006

AbstractReverse‐engineering is the process of extracting system abstractions and design information out of existing software systems. This process involves the identification of software artefacts in a particular subject system, the exploration of how these artefacts interact with one another, and their aggregation to form more abstract system representations that facilitate program understanding.This paper describes our approach to creating higher‐level abstract representations of a subject system, which involves the identification of related components and dependencies, the construction of layered subsystem structures, and the computation of exact interfaces among subsystems. We show how top‐down decompositions of a subject system can be (re)constructed via bottom‐up subsystem composition. This process involves identifying groups of building blocks (e.g., variables, procedures, modules, and subsystems) using composition operations based on software engineering principles such as low coupling and high cohesion. The result is an architecture of layered subsystem structures.The structures are manipulated and recorded using the Rigi system, which consists of a distributed graph editor and a parsing system with a central repository. The editor provides graph filters and clustering operations to build and explore subsystem hierarchies interactively. The paper concludes with a detailed, step‐by‐step analysis of a 30‐module software system using Rigi.
Software configuration management issues in the maintenance of existing systems
Authors: Capretz Miriam A. M. , Munro Malcolm 
Published: November 2006

AbstractThe application of the Software Configuration Management (SCM) discipline during the maintenance process of an existing poorly documented software system is vital to bring it under control. Incremental documentation, the activity of building up the software documentation whilst it is examined during the maintenance process, has a key role in such a process. The COMFORM (COnfiguration Management FORmalization for Maintenance) system provides a framework for aiding the maintenance process through the application of the SCM discipline. In this way reliable documentation of an existing software system is obtained incrementally whilst maintaining it. Our goal in the design of the COMFORM system is to define a method for the maintenance process through the use of forms representing each phase of a software maintenance model. This approach allows traceability among the software representations throughout the software maintenance process. In this paper we describe the foregoing steps of the COMFORM system's method towards its formalization.
An early impact analysis technique for software maintenance
Authors: Turver Richard J. , Munro Malcolm 
Published: November 2006

AbstractThe accurate estimation of the resources required to implement a change in software is a difficult task. A method for doing this should include the analysis of the impact of the change on the existing system. A number of techniques for analysing the impact of a change on the source code have been described in the literature. While these techniques provide a good example of how to apply ripple effect analysis to source code, a weakness in these approaches is that they can be difficult to apply in the risk assessment phase of a project. This is because the source code is often not very well understood at this phase, and change proposals are written at a much higher level of abstraction than the code. It is therefore often the case that in practice subjective impact analysis methods are used for risk assessment and project investment appraisal. The underestimated resources for dealing with the ripple effects of a change can result in project schedules becoming so tight that only the minimal quality is achieved. This paper surveys existing ripple analysis techniques and then presents a new technique for the early detection of ripple effects based on a simple graph‐theoretic model of documentation and the themes within the documentation.The objective is to investigate the basis of a technique for analysing and measuring the impact of a change on the entire system that includes not only the source code but the specification and design documentation of a system, and an early phase in the maintenance process.
An investigation into software maintenance—Perception and practices
Authors: Layzell Paul J. , Macaulay Linda A. 
Published: November 2006

AbstractThis paper presents the results of a survey conducted on the perceptions and practices in software maintenance in five major companies in the United Kingdom. It is clear from the study that software maintenance is undergoing a significant transformation, in particular, in terms of its image, its relationship with users and in the nature of software maintenance tools required.The image of the software maintenance task appears to be changing from one which is dull, passive and isolated to one which is reactive, responsive and vital to the business. Maintenance departments are becoming more accountable to user departments and are developing a market orientation. The study found little use of existing software maintenance tools and identified a need for support technology which will facilitate communication between users, developers and maintenance staff.The paper presents the background to the investigation, the procedures followed and a summary of current practice. An analysis of the material highlights the main problems and trends identified within software maintenance practice and its implications upon organizational structure.
A design for information systems which can adapt to changing organizational requirements
Authors: Sillince J. A. A. 
Published: November 2006

AbstractSystems requirements change, which necessitates expensive and error‐prone maintenance. Such change is unavoidable, because requirements are intellectually and politically fluid. A five‐stage method is suggested for developing systems which adapt to their host organization. Business rules are established during a negotiation stage, which consists either of making contracts if agents have resources to exchange and compatible goals, or of argumentation when such conditions do not apply. Business rules, specification, preconditions and postconditions, and program control flow are discussed, and transition rules specified for moving from one stage to the next. The environment enables users and maintenance programmers to renegotiate business rules at any time and to regenerate program control flow automatically.
The economic impact of software reuse on maintenance
Authors: Schach Stephen R. 
Published: November 2006

AbstractSoftware reuse has traditionally been put forward as a mechanism for reducing the cost of developing a product. This paper shows that the overall economic impact of reuse on maintenance is greater than its impact on development. A specific reuse example is worked in detail to illustrate the impact of reuse on the various types of maintenance that are performed on a software product. On average, the cost savings during maintenance as a consequence of reuse are nearly twice the corresponding savings during development. The results are generalized to show that, for an arbitrary product, the cost savings during maintenance as a consequence of software reuse exceed the cost savings during development as a consequence of reuse when more than about 51% of the software budget is devoted to maintenance, and increase rapidly as the proportion of the budget devoted to maintenance becomes large.
Inverse‐engineering a simple real‐time program
Authors: Younger E. J. , Ward M. P. 
Published: November 2006

AbstractReverse‐engineering of interrupt‐driven, real‐time programs with timing constraints is a particularly challenging research area, because the functional behaviour of a program, and the non‐functional timing requirements, are implicit and can be very difficult to discover. However, in this paper we present a significant advance in this area, which is achieved by modelling real‐time programs with interrupts in the wide spectrum language, WSL. A small example program is modelled in this way, and formal program transformations are used to derive various timing constraints and to ‘inverse‐engineer’ a formal specification of the program. (We use the term ‘inverse‐engineering’ to mean ‘reverse‐engineering achieved by formal program transformations’.)
Downsizing large application programs
Authors: Sneed Harry M. , Nyary Erika 
Published: November 2006

AbstractThere is a great demand in industry to migrate from the mainframe to distributed client/server type systems. The following paper proposes three methods of splitting up oversized host application programs with the goal of offloading them on to workstation computers. The three approaches are by procedural connection, functional decomposition, and abstract data typing. The author describes his experience in applying each of the methods and explains what other measures are necessary to downsize a program.
An object finder for program structure understanding in software maintenance
Authors: Ogando Roger M. , Yau Stephen S. , Liu Sying S. , Wilde Norman 
Published: November 2006

AbstractThe maintenance or re‐engineering of a program usually begins with considerable effort in understanding the program structure. In this paper, an interactive tool for understanding the structure of non‐object‐oriented programs, known as the Object Finder, is presented. The structure of a program is defined in terms of the groupings of routines and data into modules within the program and the hierarchical relationships among the modules. The Object Finder incorporates two complementary approaches, one being top‐down and the other bottom‐up, to assist the software engineer in understanding the structure of a program based on the object‐like features found in the program. In the top‐down approach, the user obtains an overall understanding of the entire program as a collection of hierarchically organized objects. In the bottom‐up approach, the user obtains a view of the information which is closely related to the components under examination.In both approaches, two methods are used to identify the objects in a program written in a non‐object‐oriented programming language. These methods identify sets of objects based on the data bindings and on the type bindings found in a program. An object is considered as a collection of routines, types, and/or data items of the program. The Object Finder combines the top‐down and bottom‐up approaches while using human input to guide the object identification process. Two examples of using this Object Finder are also presented to demonstrate the capabilities of the approaches to assist the software engineer in attaining a high‐level understanding of the program structure.
Life‐cycle approach to strategic re‐engineering of software
Authors: Jarzabek Stan 
Published: November 2006

AbstractSoftware systems must be constantly upgraded to be in tune with an evolving business environment. Owing to the inefficiency of current maintenance methods, many of the old programs do not meet companies' strategic needs. Can we re‐engineer those programs or must they be rewritten from scratch? Common goals for re‐engineering software have been to improve maintainability of programs and to convert programs into a newer computer, database or language. In this paper, we describe a framework for strategic re‐engineering in which programs are substantially redesigned in order to meet companies' strategic goals. Strategic re‐engineering is much like redevelopment, accelerated by reuse of information that is extracted from existing, still viable from the business point of view, progams. We discuss the impact of companies' strategic plans on software re‐engineering and describe life‐cycle phases of strategic re‐engineering with CASE.
Measuring the readability and maintainability of hyperdocuments
Authors: Hatzimanikatis A. E. , Tsalidis C. T. , Christodoulakis D. 
Published: November 2006

AbstractThe problem of poorly written hyperdocuments has already been identified. Furthermore, there is no complete definition of hyperdocument quality and the methodology and tools that will help in analysing and assessing the quality of hyperdocuments are missing. The ability to measure attributes of hyperdocuments is indispensable for the fields of hyperdocument authoring and hypertext engineering. Useful paradigms can be drawn from the practices used in the software engineering and software measurement fields.In this paper we define a hyperdocument quality model, based on the ideas of the well‐known Factor‐Criteria‐Metric hierarchical model. The important factors of readability and maintainability are defined, as well as the corresponding criteria. Finally, structure metrics, that can be computed on the hypertext graph, are presented. Most of these metrics are derived from well‐known software metrics.Experimentation is a key issue for the application of measurement, and flexible tools for the automatic collection of measures are needed to support it. Athena, a tool that was originally developed for software measurement and later tailored to meet hypertext measurement needs, is used for hyperdocument measurement.
A new algorithm for the calculation of transitive dependences
Authors: Livadas Panos E. , Croll Stephen 
Published: November 2006

AbstractProgram slicing can be used to aid in a variety of software maintenance activities including code understanding, code testing, debugging, and program re‐engineering. Program slicing (as well as other program analysis functions including ripple analysis) can be efficiently performed on an internal program representation called a system dependence graph (SDG). This paper will describe a new method for calculating transitive dependencies in the presence of recursion. This method requires neither the (explicit) calculation of the GMOD and GREF sets nor the construction of a linkage grammar and the corresponding subordinate characteristic graphs of the linkage grammar's nonterminals. Additionally, a beneficial side effect of this method is that it provides us with a new method for performing interprocedural, flow‐sensitive data flow analysis.Finally, this paper will illustrate the versatility of the SDG as an internal program representation by briefly describing a tool that we have developed that permits slicing, dicing, ripple analysis, and other static analysis functions to be performed on programs written in a subset of ANSI C (e.g., C without gotos and pointers).
Measurement of functional reuse in maintenance
Authors: Abran Alain , Desharnais Jean‐Marc 
Published: November 2006

AbstractThis paper is concerned with the identification and measurement of reuse within projects in which functional enhancements have been added to existing software applications. The proposed approach is based on the measurement of reuse from a functional perspective rather than from a technical perspective. Two key concepts are introduced: a reuse indicator and a predictor ratio. The reuse indicator is derived from an analysis of the function types as currently defined in Function Points Analysis. The predictor ratio is derived from an understanding of the avoided‐cost concept and of how it can be captured using historical databases of function points from previous development projects. This paper indicates how, in functional enhancement projects, the predictor ratio can be combined into the reuse indicator to derive an alternative size measure which takes into account functions reused and not redeveloped. The paper also demonstrates how these ratios can then be integrated in a maintenance productivity model to analyse the benefits of reuse by taking into account the avoided cost of functions reused. A case study based on an industrial data set is provided to illustrate the measurement of functional reuse in an enhancement project and its impact in maintenance productivity analysis.