Scheduled System Maintenance on May 29th, 2015:
IEEE Xplore will be upgraded between 11:00 AM and 10:00 PM EDT. During this time there may be intermittent impact on performance. We apologize for any inconvenience.
By Topic

Program Comprehension, 1999. Proceedings. Seventh International Workshop on

Date 5-7 May 1999

Filter Results

Displaying Results 1 - 25 of 26
  • Proceedings Seventh International Workshop on Program Comprehension

    Publication Year: 1999
    Save to Project icon | Request Permissions | PDF file iconPDF (179 KB)  
    Freely Available from IEEE
  • Index of authors

    Publication Year: 1999 , Page(s): 226 - 227
    Save to Project icon | Request Permissions | PDF file iconPDF (46 KB)  
    Freely Available from IEEE
  • Comprehending a complex, distributed, object-oriented software system: a report from the field

    Publication Year: 1999 , Page(s): 218 - 225
    Cited by:  Papers (9)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (48 KB)  

    Comprehending complex, distributed, object-oriented software systems is a difficult task which must be approached in a formal disciplined manner if it is to be solved at all. The authors have developed a formal tool supported approach using relational databases to model both the requirement specification and the system implementation of a very large commercial application system. The approach combines forward and reverse engineering link the implementation to the specification, thereby providing a basis for traceability between system artifacts and requirements. The result is a partial comprehension adequate for system maintenance View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Extending software quality assessment techniques to Java systems

    Publication Year: 1999 , Page(s): 49 - 56
    Cited by:  Papers (8)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (88 KB)  

    The paper presents extensions to Bell Canada source code quality assessment suite (DATRIX tm) for handling Java language systems. Such extensions are based on source code object metrics, including Java interface metrics, which are presented and explained in detail. The assessment suite helps to evaluate the quality of medium-large software systems identifying parts of the system which have unusual characteristics. The paper also studies and reports the occurrence of clones in medium-large Java software systems. Clone presence affects quality since it increases a system size and often leads to higher maintenance costs. The clone identification process uses Java specific metrics to determine similarities between methods throughout a system. The results obtained from experiments with software evaluation and clone detection techniques, on over 500 KLOC of Java source code, are presented View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The relationship of slicing and debugging to program understanding

    Publication Year: 1999 , Page(s): 106 - 113
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (88 KB)  

    The paper describes a study that explores the relationship between program slicing and code understanding gained while debugging. The study consisted of an experiment that compared the program understanding abilities of two classes of debuggers: those who slice while debugging and those who do not. For debugging purposes, a slice can be thought of as a minimal subprogram of the original code that contains the program faults. Those who only examine statements within a slice for correctness are considered slicers; all others are considered non-slicers. Using accuracy of reconstruction as a measure of understanding, it was determined that slicers have a better understanding of the code after debugging View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Improving the visibility of graphical program displays: an experimental study

    Publication Year: 1999 , Page(s): 12 - 19
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (112 KB)  

    The paper describes an experimental study, which compares the performance of various layout heuristics used to increase the visibility of graphical representations of computer programs. In particular, a special layout graph is considered which is known as m-column graph, and it is used to display data flow program dependencies. We show experimentally that an incremental layout heuristic approach outperforms the traditional layout techniques such as pair exchanging or greedy insertion of graph vertices. Finally, we conclude by presenting our recommendations with respect to the application of such layout heuristics especially on interactive software systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Improving software comprehension through an automated dependency tracer

    Publication Year: 1999 , Page(s): 58 - 65
    Cited by:  Papers (5)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (96 KB)  

    The paper presents ANALYST, a tool that automates impact analysis by exploiting a framework that implements dependency based software representation models. The preliminary experimental results show that it supports the improvement of software representation models to be used in software comprehension. Moreover, the tool allows the maintainer to perform more accurate and correct changes, decreasing the software degradation effect. Finally, it is shown that the tool can be used as a general platform for experimenting with different impact analysis approaches, and for assessing and comparing their effectiveness with the use of suitable metrics View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Comprehension with[in] virtual environment visualisations

    Publication Year: 1999 , Page(s): 4 - 11
    Cited by:  Papers (8)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (272 KB)  

    For many years, basic visualisation based around simple boxes and lines, has been done in an attempt to be able to ease some of the cognitive overload caused by program comprehension. The problems with such visualisations is that they can very easily become incomprehensible by trying to force large amounts of information into a small space, relying solely on two dimensions for the representations. Three-dimensional visualisations are one approach that is being considered to combat these problems, although there are also many different issues that must be considered for these sorts of visualisations. Especially when those visualisations are of intangible software systems. A solution is to use virtual environments as a base for these three-dimensional visualisations, which allows a sense of context to be maintained and also promotes collaboration between the people trying to comprehend the code View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Slicing concurrent Java programs

    Publication Year: 1999 , Page(s): 126 - 133
    Cited by:  Papers (9)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (260 KB)  

    Although many slicing algorithms have been proposed for object oriented programs, no slicing algorithm has been proposed which can be used to handle the problem of slicing concurrent Java programs correctly. We propose a slicing algorithm for concurrent Java programs. To slice concurrent Java programs, we present a dependence based representation called multithreaded dependence graph, which extends previous dependence graphs to represent concurrent Java programs. We also show how static slices of a concurrent Java program can be computed efficiently based on its multithreaded dependence graph View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Empirical evaluation of hypertextual information access from program text

    Publication Year: 1999 , Page(s): 162 - 169
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1412 KB)  

    HyperSoft is a hypertext based software maintenance support tool. HyperSoft provides various transient hypertextual access structures (THASs), which are formed automatically on the basis of the situation-dependent information needs of software engineers. THASs highlight the relevant parts of the program and enable nonlinear browsing between them. The system also supports various graphical views whose elements have linked to the program text. We represent the empirical results of the effects of using these hypertextual structures in relation to a set of sample information requests. The results indicate significantly better task performance as compared to using a conventional compiler environment View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Understanding COBOL systems using inferred types

    Publication Year: 1999 , Page(s): 74 - 81
    Cited by:  Papers (5)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (120 KB)  

    In a typical COBOL program, the data division consists of 50% of the lines of code. Automatic type inference can help to understand the large collections of variable declarations contained therein, showing how variables are related based on their actual usage. The most problematic aspect of type inference is pollution, the phenomenon that types become too large, and contain variables that intuitively should not belong to the same type. The aim of the paper is to provide empirical evidence for the hypothesis that the use of subtyping is an effective way for dealing with pollution. The main results include a tool set to carry out type inference experiments, a suite of metrics characterizing type inference outcomes, and the conclusion that only one instance of pollution was found in the case study conducted View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The SPARAMAT approach to automatic comprehension of sparse matrix computations

    Publication Year: 1999 , Page(s): 200 - 207
    Cited by:  Papers (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (128 KB)  

    Automatic program comprehension is particularly useful when applied to sparse matrix codes, since it allows one to abstract, e.g. from specific sparse matrix storage formats used in the code. We describe SPARAMAT, a system for speculative automatic program comprehension suitable for sparse matrix codes, and its implementation View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Restructuring parallel programs by transformation of point-to-point interactions into collective communication

    Publication Year: 1999 , Page(s): 84 - 91
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (108 KB)  

    We present an approach for supporting the reengineering of legacy message passing parallel programs based on point-to-point communication primitives. The objective is to obtain structured portable, and possibly more efficient versions of the same programs through the use of collective communication constructs. The restructuring process relies on a technique capable of detecting typical interaction patterns within programs based on point-to-point communications. Successively, the code excerpts corresponding to the detected patterns are automatically replaced with suitable collective primitives View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Parsing C++ despite missing declarations

    Publication Year: 1999 , Page(s): 114 - 125
    Cited by:  Papers (1)  |  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (100 KB)  

    The paper addresses the problem of parsing a C++ software system that is known to compile correctly, but for which some header files are unavailable. A C++ program file typically depends on numerous included header files from the same system, a third party library, or the operating system standard libraries. It is not possible with a conventional parser to analyze C++ source code without obtaining the complete environment where the program is to be compiled. The paper studies the parsing ambiguities resulting from missing header files and proposes a special parser which uses additional rules and type inference in order to determine the missing declarations. This new parser has achieved 100% accuracy on a large system with numerous missing header files View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On managing classes for evolving software

    Publication Year: 1999 , Page(s): 144 - 150
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (72 KB)  

    The evolution of object oriented software involves addition, deletion, and replacement of classes. Maintenance of classes requires detect and resolve inconsistency between classes. The Unified Modeling Language (UML) is becoming the de facto standard modeling language. We present a UML based model of class interrelations for evolving object oriented software. The model is based on notions contract and protocol. A contract can be used by a class designer to express services and requirements of the class, a protocol to register cooperations between classes. Founded on the UML extension mechanisms, we present an infrastructure for class designers to express contracts and register protocols. The infrastructure lays the foundation for class designers, implementers, and maintainers to validate class changes in software evolution. It makes automated validation possible View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Reconstructing ownership architectures to help understand software systems

    Publication Year: 1999 , Page(s): 28 - 37
    Cited by:  Papers (11)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (128 KB)  

    Recent research suggests that large software systems should have a documented system architecture. One form of documentation that may help describe the structure of software systems is the organization of the developers that designed and implemented the software system. We suggest that all ownership architecture that documents the relationship between developers and source code is a valuable aid in understanding large software systems. If this document is not available then we can reconstruct it based on the system implementation and other documentation. We examine Linux as a case study to demonstrate how to reconstruct and use this type of architecture. The reconstructed Linux ownership architecture provides information that complements other types of architectural documentation. It identifies experts for system components, shows non-functional dependencies, and provides estimates of the quality of components. Ownership architectures also allow us to find problems such as under-staffed sub-systems and components that risk abandonment View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Software visualisation using C++ lenses

    Publication Year: 1999 , Page(s): 20 - 26
    Cited by:  Papers (2)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (120 KB)  

    C++ Lens is an innovative visualisation technique and associated tool, that assists maintainers to comprehend C++ source code. The primary role of the C++ Lens technique and tool is to visualise the interface relationships existing between C++ classes and to signify the importance of these relationships. The technique innovatively combines, via the definition of lenses, elements of reverse engineering, code browsing, visualisation, and metrics gathering into a coherent framework for code comprehension. The paper describes the basis of the technique and presents some results of applying the C++ Lens technique and tool to large scale commercial software View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On the role of static analysis during software maintenance

    Publication Year: 1999 , Page(s): 170 - 177
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (112 KB)  

    Since Weiser's study (see CACM, vol.25, no.7, p.446-52), static analysis tools, specifically data flow and slicing tools are considered useful for software maintenance. To investigate this further, we conducted an observational study with professional programmers performing a debugging and an enhancement task View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Evolving object oriented design to improve code traceability

    Publication Year: 1999 , Page(s): 151 - 160
    Cited by:  Papers (7)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (260 KB)  

    Traceability is a key issue to ensure consistency among software artifacts of subsequent phases of the development cycle. However, few works have so far addressed the theme of tracing object oriented design into its implementation and evolving it. The paper presents an approach to checking the compliance of OO design with respect to source code and support its evolution. The process works on design artifacts expressed in the OMT notation and accepts C++ source code. It recovers an “as is” design from the code, compares recovered design with the actual design and helps the user to deal with inconsistencies. The recovery process exploits the edit distance computation and the maximum match algorithm to determine traceability links between design and code. The output is a similarity measure associated to each matched class, plus a set of unmatched classes. A graphic display of the design with different colors associated to different levels of match is provided as a support to update the design and improve its traceability to the code View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An architecture for automated software maintenance

    Publication Year: 1999 , Page(s): 38 - 48
    Cited by:  Papers (6)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (316 KB)  

    We developed an assembly line to implement certain specific changes in a stockbroking system written in COBOL with embedded SQL. The changes were proposed by the maintenance team of the system. Using our architecture, it took a few hours to implement the conditional transformations from the code examples we obtained from the maintenance team. Then we could carry out the tasks completely automated. We report on the transformations, their implementation and the architecture we used. It is the intention of the company that owns COBOL/SQL to use our architecture for similar tasks. This study was carried out in order to give the company that owns the code an indication of the effort it takes, the development process of the components that carry out such tasks, and the process to change software using our architecture View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A case study of applying an eclectic approach to identify objects in code

    Publication Year: 1999 , Page(s): 136 - 143
    Cited by:  Papers (6)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (128 KB)  

    The identification of objects in procedural programs has long been recognised as a key to successful comprehension. As a consequence, several authors have proposed methods and tools that achieve, in general, some level of success, but do not always precisely identify a coherent set of objects. We show that using an eclectic approach, where a domain expert software engineer is encouraged to tailor and combine existing approaches, may overcome the limitation of the single approaches and helps to better address the particular goals of the project at hand and the unique aspects of the subject system. The eclectic approach is illustrated by reporting experiences from a case study of identifying coarse-grained, persistent objects to be used in the migration of a COBOL system to a distributed component system View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An application of fuzzy reasoning to support automated program comprehension

    Publication Year: 1999 , Page(s): 66 - 73
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1384 KB)  

    We are developing a knowledge based program understanding/fault localization system called BUGDOCTOR. We describe a system knowledge source called the Plan Processor that retrieves a set of program plans from a plan library using indices called signatures. We propose use of a fuzzy reasoning component to support the Plan Processor with the task of ranking the retrieved plans in order of similarity to the target code. The most similar plan can then be used for the complex plan/code matching required for automated program understanding. Our approach to plan processing may eliminate the need for exhaustive plan library searches, and could lead to automated program understanders that scale up for use on large software systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Black-box understanding of COTS components

    Publication Year: 1999 , Page(s): 92 - 99
    Cited by:  Papers (2)  |  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (80 KB)  

    Developers have to identify properties of COTS components to properly integrate them with a system under development, but COTS components are typically “black boxes” because their source code is not available. We present an approach that can be used in black-box understanding of COTS components. The major objective is to reduce the effort required to reveal component properties by partially automating interface probing. A developer provides a full or partial description of a component property, together with a search scope where assertions are used to describe component properties. Based on this information, a search engine automatically searches for component inputs on which the component property is revealed using a combination of existing automated test generation methods for black-box testing and for white-box testing. Our initial experience has shown that this approach may be a cost-effective way of revealing properties of components View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Program simplification as a means of approximating undecidable propositions

    Publication Year: 1999 , Page(s): 208 - 217
    Cited by:  Papers (7)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (292 KB)  

    We describe an approach which mixes testing, slicing, transformation and formal verification to investigate speculative hypotheses concerning a program, formulated during program comprehension activity. Our philosophy is that such hypotheses (which are typically undecidable) can, in some sense, be `answered' by a partly automated system which returns neither `true' nor `false' but a program (the `test program') which computes the answer. The motivation for this philosophy is the way in which, as we demonstrate, static analysis and manipulation technology can be applied to ensure that the resulting test program is significantly simpler than the original program, thereby simplifying the process of investigating the original hypothesis View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Recovery of jump table case statements from binary code

    Publication Year: 1999 , Page(s): 192 - 199
    Cited by:  Papers (11)  |  Patents (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (96 KB)  

    One of the fundamental problems with the analysis of binary (executable) code is that of recognizing, in a machine-independent way, the target addresses of n-conditional branches implemented via a jump table. Without these addresses, the decoding of the machine instructions for a given procedure is incomplete, as well as any analysis on that procedure. We present a technique for recovering jump tables and their target addresses in a machine and compiler independent way. The technique is based on slicing and expression substitution. The assembly code of a procedure that contains an indexed jump is transformed into a normal form which allows us to determine where the jump table is located and what information it contains (e.g. offsets from the table or absolute addresses). The technique has been tested on SPARC and Pentium code generated by C, C++, Fortran and Pascal compilers. Our tests show that up to 90% more of the code in a text segment can be found by using this technique View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.