By Topic

Program Comprehension, 2005. IWPC 2005. Proceedings. 13th International Workshop on

Date 15-16 May 2005

Filter Results

Displaying Results 1 - 25 of 48
  • Proceedings. 13th International Workshop on Program Comprehension

    Save to Project icon | Request Permissions | PDF file iconPDF (66 KB)  
    Freely Available from IEEE
  • [Title page]

    Page(s): i - iv
    Save to Project icon | Request Permissions | PDF file iconPDF (111 KB)  
    Freely Available from IEEE
  • Table of contents

    Page(s): v - viii
    Save to Project icon | Request Permissions | PDF file iconPDF (79 KB)  
    Freely Available from IEEE
  • Message from the Chairs

    Page(s): ix
    Save to Project icon | Request Permissions | PDF file iconPDF (66 KB)  
    Freely Available from IEEE
  • Conference Committees

    Page(s): x - xi
    Save to Project icon | Request Permissions | PDF file iconPDF (72 KB)  
    Freely Available from IEEE
  • Comprehension by derivation [software system comprehension]

    Page(s): 3 - 9
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (128 KB)  

    We argue that to comprehend a software system is to have a handle on its requirements, specifications, and design decisions. These kinds of information support the reuse of system code for a variety of purposes and support its ongoing extension, migration, and evolution. Our work at Kestrel Institute has focused on ways to mechanize the development and evolution of software from formal specifications. By-products of such a process include formal records of design decisions and proofs, as well as executable code. In this approach, reuse can take place at non-code levels, including domain theories, specifications, and design knowledge. Evolution takes place by modifying requirements, specifications, or design decisions, and then reusing previous design structures. When restricted to particular application domains, the generation of correct-by-construction code from specifications can be completely automatic. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A qualitative comparison of three aspect mining techniques

    Page(s): 13 - 22
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (144 KB) |  | HTML iconHTML  

    The fact that crosscutting concerns (aspects) cannot be well modularized in object oriented software is an impediment to program comprehension: the implementation of a concern is typically scattered over many locations and tangled with the implementation of other concerns, resulting in a system that is hard to explore and understand. Aspect mining aims to identify crosscutting concerns in a system, thereby improving the system's comprehensibility and enabling migration of existing (object-oriented) programs to aspect-oriented ones. In this paper, we compare three aspect mining techniques that were developed independently by different research teams: fan-in analysis, identifier analysis and dynamic analysis. We apply each technique to the same case (JHotDraw) and mutually compare the individual results of each technique based on the discovered aspects and on the level of detail and quality of those aspects. Strengths, weaknesses and underlying assumptions of each technique are discussed, as well as their complementarity. We conclude with a discussion of possible ways to combine the techniques in order to achieve a better overall aspect-mining technique. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Understanding concerns in software: insights gained from two case studies

    Page(s): 23 - 32
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (280 KB) |  | HTML iconHTML  

    Much of the complexity of software arises from the interactions between disparate concerns. Even in well-designed software, some concerns can not always be encapsulated in a module. Research on separation of concerns seeks to address this problem, but we lack an understanding of how programmers conceptualize the notion of a concern and then identify that concern in code. In this work, we have conducted two exploratory case studies to better understand these issues. The case studies involved programmers identifying concerns and associated code in existing, unfamiliar software: GNU's sort.c and the game Minesweeper. Based on our experiences with these two case studies, we have identified several types of concerns and have detailed a number of factors that impact programmer identification of concerns. Based on these insights, we have created two sets of guidelines: one to help programmers identify relevant concerns and another to help programmers identify code relating to concerns. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Static techniques for concept location in object-oriented code

    Page(s): 33 - 42
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (200 KB) |  | HTML iconHTML  

    Concept location in source code is the process that identifies where a software system implements a specific concept. While it is well accepted that concept location is essential for the maintenance of complex procedural code like code written in C, it is much less obvious whether it is also needed for the maintenance of the object-oriented code. After all, the object-oriented code is structured into classes and well-designed classes already implement concepts, so the issue seems to be reduced to the selection of the appropriate class. The objective of our work is to see if the techniques for concept location are still needed (they are) and whether object-oriented structuring facilitates concept location (it does not). This paper focuses on static concept location techniques that share common prerequisites and are search the source code using regular expression matching, or static program dependencies, or information retrieval. The paper analyses these techniques to see how they compare to each other in terms of their respective strengths and weaknesses. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Presenting micro-theories of program comprehension in pattern form

    Page(s): 45 - 54
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (272 KB) |  | HTML iconHTML  

    We present the notion of cognitive patterns, and provide several examples. A cognitive pattern is the written record of a solution to a recurring cognitive problem typically employed by experienced practitioners. We focus on those relevant to program comprehension, which we have developed through studying the literature and conducting field studies. Collectively the set of patterns constitute a rich theory of program comprehension, which is why we call each one a micro-theory. We expand on one pattern, temporal details, which is also a 'pattern language since it breaks down into sub-patterns'. A key use of cognitive patterns is to suggest useful features for tool designers to implement. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An investigation into professional programmers' mental representations of variables

    Page(s): 55 - 64
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (136 KB) |  | HTML iconHTML  

    Very little is known about professional programmers' mental representations of variables, yet this information is vital in designing effective tools for program comprehension. In order to find out what types of information programmers have about variables and their relations, we conducted a knowledge elicitation study where professional programmers studied programs and the resulting mental representations were elicited using card sorting and interviews. The mental representations were based on fourteen principles that can be organized in four main categories: domain-based, technology-based, execution-based, and strategy-based. Most frequent information types dealt with two execution-based criteria: behavior and utilization. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An investigation of Java abstraction usage for program modifications

    Page(s): 65 - 74
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (144 KB) |  | HTML iconHTML  

    This paper reports upon the results of an investigation concerning the use and type of Java abstractions employed during software maintenance. The source of data consists of eighty-eight program summaries extracted from online developer mailing lists. Specifically, the summaries describing modifications, thirty-six in total, were examined from the perspective of five task types, including adaptive, corrective, emergency, perfective and preventive. Corrective and perfective task types were the two most commonly found. Abstractions are examined per task type and are also presented in three sequential stages as beginning, middle and end of the summaries. The results show that middle (within program level) abstractions dominate each task type, with the higher (system and architecture level) and lower (code and Java virtual machine level) abstractions following respectively. The results detail the type of abstractions used in each task type and summarise the abstractions found for modifications in general with potential applications to support the design of Java software visualisation tools. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Identifying and addressing problems in framework reuse

    Page(s): 77 - 86
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (184 KB) |  | HTML iconHTML  

    Object-oriented frameworks are a powerful form of reuse but they can be difficult to understand and reuse correctly. Over the last decade a large range of candidate documentation techniques have been proposed to address this difficulty. There is little research, however, to identify the specific problems that arise during framework reuse and to evaluate documentation techniques in terms of these problems. This paper reports on a long-term investigation that firstly identifies four fundamental problems of framework reuse: mapping, understanding functionality, understanding interactions and understanding the framework architecture. It then describes two forms of documentation specifically developed to address the mapping, interaction and functionality problems namely a pattern language and a set of micro architectures. An in-depth, qualitative analysis of these two documentation types evaluates the key strengths and weaknesses of their support for framework understanding, whilst confirming the significance of the four problem categories. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • What can programmer questions tell us about frameworks?

    Page(s): 87 - 96
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (168 KB) |  | HTML iconHTML  

    In order to make frameworks easier to use we need to better understand the difficulties that programmers have with them. The questions that programmers ask give clues to the quality of design, documentation, and programmer practice. We describe the method and results of a study on the Java Swing framework. We collected and analyzed a sample of 300 newsgroup questions asked about two Swing components (JButton and JTree), and classified the questions according to the design features of the components. This process revealed key insights that can improve a framework's design, its tutorials, and programmer practice. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Concise and consistent naming [software system identifier naming]

    Page(s): 97 - 106
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (168 KB) |  | HTML iconHTML  

    Approximately 70% of the source code of a software system consists of identifiers. Hence, the names chosen as identifiers are of paramount importance for the readability of computer programs and therewith their comprehensibility. However, virtually every programming language allows programmers to use almost arbitrary sequences of characters as identifiers which far too often results in more or less meaningless or even misleading naming. Coding style guides address this problem but are usually limited to general and hard to enforce rules like "identifiers should be self-describing". This paper renders adequate identifier naming far more precisely. A formal model, based on bijective mappings between concepts and names, provides a solid foundation for the definition of precise rules for concise and consistent naming. The enforcement of these rules is supported by a tool that incrementally builds and maintains a complete identifier dictionary while the system is being developed. The identifier dictionary explains the language used in the software system, aids in consistent naming, and improves productivity of programmers by proposing suitable names depending on the current context. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Textual views of source code to support comprehension

    Page(s): 109 - 112
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (120 KB) |  | HTML iconHTML  

    Source code can be viewed in many ways, with each view facilitating access to different information contained within the code. We explore the role that marked-up textual views can provide in support of software comprehension and maintenance. Text has the advantages of being easily communicated, effectively manipulated with existing tools, and highly scalable. Furthermore, marked-up text models may improve comprehension by expressing information directly within the context of maintainers' focus - the source code they are manipulating. The session intends to explore the expressibility of marked-up text and its applicability in support of program comprehension tasks. Topics will include: the roles these models fulfill, their limitations, their combination, and the exploration of future research directions. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On the comprehension of security risk scenarios

    Page(s): 115 - 124
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (408 KB) |  | HTML iconHTML  

    Methods for security risk analysis are often based on structured brainstorming (e.g. what [F. Redmill et al., (1999)] calls HazOp). A structured brainstorming gathers a group of different system experts and the idea is that they will find more risks as a team than one-by-one. The CORAS modelling language [M. S. Lund et al., (2003)] has been designed to support the brainstorming process and to document security risk scenarios identified during these sessions. The language is graphical, based upon the Unified Modelling Language (UML) [R. E. Walpole et al., (1998)], and is recommended by OMG. This paper reports the results from two empirical experiments concerning the CORAS language. Our results show (1) many security risk analysis terms are used in the daily language and therefore well understood, but the more abstract or less frequently used terms can be a possible source for misunderstandings in a security analysis, and (2) the language's graphical icons make diagram "navigation" faster, but the diagrams are not necessarily understood more correctly than those without graphical icons. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Modelling the information-seeking behaviour of programmers - an empirical approach

    Page(s): 125 - 134
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (184 KB) |  | HTML iconHTML  

    Information seeking has been recognised as a core subtask in software maintenance. This paper reviews, merges, and adapts existing information seeking models for different domains to propose a nonlinear information-seeking model for programmers involved in software maintenance. Talk-aloud data from two empirical studies of industrial programmers carrying out real software maintenance tasks is presented, to illustrate and validate (in part) this model. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A COTS component comprehension process

    Page(s): 135 - 144
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (160 KB) |  | HTML iconHTML  

    A process is proposed to support comprehension of COTS components. In this process, software developers build a COTS comprehension model to support component selection. We integrate the process with a UML component based software development approach. We illustrate our approach using a hotel reservation system. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The CodeSurfer software understanding platform

    Page(s): 147 - 148
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (66 KB) |  | HTML iconHTML  

    CodeSurfer is a tool that provides a wide range of program understanding capabilities by exposing the results of a static-semantic analysis to the user in novel and interesting ways. The tool performs a number of whole-program analyses, including pointer analysis, and creates a system dependence graph for the program. The user can browse these dependences through the GUI in a manner akin to surfing the Web. An open architecture fosters the development of plug-ins that can extend the basic functionality. These include tools for reasoning about the paths through the program, and for software assurance. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • JRipples: a tool for program comprehension during incremental change

    Page(s): 149 - 152
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (152 KB) |  | HTML iconHTML  

    Incremental software change adds new functionality to software. It is the foundation of software evolution, maintenance, iterative development, agile development, and other software processes. Highly interactive tool JRipples provides the programmer with the organizational support that makes the incremental change process easier and more systematic. JRipples supports impact analysis and change propagation, the two most difficult activities of the incremental change. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visualizing the behavior of dynamically modifiable code

    Page(s): 337 - 340
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (280 KB) |  | HTML iconHTML  

    Recent years have seen an increased recognition of some of the advantages offered by dynamically modifiable code, i.e., code that changes during the execution of the program. In its full generality, it can be very difficult to understand the behavior of such self-modifiable code. This paper describes a system that graphically displays the execution behavior of dynamic code, focusing on code modifications and their effect on the structure of the program, i.e., the call graph and control flow graphs of functions. This can help users visualize the structure of runtime code modifications and understand the behavior of dynamically modifiable programs. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • HyperSoft system: tool demonstration and use example

    Page(s): 153 - 156
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (336 KB) |  | HTML iconHTML  

    HyperSoft is an approach for satisfying the information needs of software maintainers. HyperSoft combines the notions of automated program analysis and hypertext techniques. HyperSoft system is the implementation of the approach. It is targeted at supporting the comprehension of large programs and has been developed in cooperation with software industry. HyperSoft produces automatically transient access structures, which deliver to the users the needed information. Access structures are presented to the users via various textual, hypertextual, structural and graphical views. This paper and tool demonstration describe the tool use and applied interaction techniques. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • SEAT: a usable trace analysis tool

    Page(s): 157 - 160
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (248 KB) |  | HTML iconHTML  

    Understanding the dynamics of a program can be made easier if dynamic analysis techniques are used. However, the extraordinary size of typical execution traces makes exploring the content of traces a tedious task. In this paper, we present a tool called SEAT (software exploration and analysis tool) that implements several operations that can help software engineers understand the content of a large execution trace. Perhaps, the most powerful aspect of SEAT is the various filtering techniques it incorporates. In our precious work, we showed that these techniques can reduce significantly the size of traces in order to reveal the main content they convey. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • REGoLive: Web site comprehension with viewpoints

    Page(s): 161 - 164
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (544 KB) |  | HTML iconHTML  

    This paper describes a demonstration of the REGoLive reverse engineering tool. REGoLive supports comprehension of Web sites with three distinct viewpoints: developer-view, server-view, and client-view. Each viewpoint provides unique information about a Web site, which is not contained in other viewpoints. REGoLive is built on top of the Go-Live Web authoring tool, which allows us to expose the developer-view of sites that have been built with GoLive. REGoLive shows a graph visualization of each viewpoint and allows the reverse engineer to navigate mappings between them. We believe that all three viewpoints are necessary to understand a Web site effectively. View full abstract»

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