Program Comprehension

One of the main challenges faced by today's developers is keeping up with the staggering amount of source code that needs to be read and understood. In order to help developers with this problem and reduce the costs associated with it, one solution is to use simple textual descriptions of source code entities that developers can grasp easily, while capturing the code semantics precisely. We propose an approach to automatically determine such descriptions, based on automated text summarization technology.

System evolution depends greatly on the ability of a maintainer to locate source code that is specific to feature implementation. Existing feature location techniques require either exercising several features of the system, or rely heavily on domain experts to guide the feature location process. In this paper, we present a novel approach for feature location that combines static and dynamic analysis techniques. An execution trace is generated by exercising the feature under study (dynamic analysis). A component dependency graph (static analysis) is used to rank the components invoked in the trace according to their relevance to the feature. Our ranking technique is based on the impact of a component modification on the rest of the system. The proposed approach is automatic to a large extent relieving users from any decision that would otherwise require extensive domain knowledge of the system. A case study is presented to support and evaluate the applicability of our approach.

In this paper a new maintenance scenario is outlined based on refactoring techniques. Specifically, refactoring techniques are classified according to two opposed program properties: understanding and efficiency. Understanding oriented refactoring disassembles the program preparing it for maintenance, whereas those oriented to efficiency rearrange it for running. Also, we show the challenges raised from this new perspective on maintenance. At present, this ongoing research is being carried out in the functional

Developing software is a complex mental activity, requiring extensive technical knowledge and abstraction capabilities. The tangible part of development is the use of tools to read, inspect, edit, and manipulate source code, usually through an IDE (integrated development environment). Common claims about software development include that program comprehension takes up half of the time of a developer, or that certain UI (user interface) paradigms of IDEs offer insufficient support to developers. Such claims are often based on anecdotal evidence, throwing up the question of whether they can be corroborated on more solid grounds.

The area of program comprehension comprises a vast body of literature, with numerous conflicting models having been proposed. Models are typically grounded in experimental studies mostly involving experienced programmers. The question of how to relate this material to the teaching and learning of programming for novices has proven challenging for many researchers. In this critical review from a computer science

This study explored the quality of obstetric care in public-sector facilities and the constraints to programming comprehensive essential obstetric care (EOC) services in rural areas of Khulna and Sylhet divisions, relatively high-and low-performing areas of Bangladesh respectively. Quality was explored by physically inspecting all public-sector EOC facilities and the constraints through in-depth interviews with public-sector programme managers and service providers. Distribution of the functional EOC facilities satisfied the United Nation's minimum criteria of at least one comprehensive EOC and four basic EOC facilities for every 500,000 people in Khulna but not in Sylhet region. Human-resource constraints were the major barrier for maternal health. Sanctioned posts for nurses were inadequate in rural areas of both the divisions; however, deployment and retention of trained human resources were more problematic in rural areas of Sylhet. Other problems also plagued care, including unavailability of blood in rural settings and lack of use of evidence-based techniques. The overall quality of care was better in the EOC facilities of Khulna division than in Sylhet. 'Context' of care was also different in these two areas: the population in Sylhet is less literate, more conservative, and faces more geographical and sociocultural barriers in accessing services. As a consequence of both care delivered and the context, more normal vaginal and caesarian-section deliveries were carried out in the public-sector EOC facilities in the Khulna region, with the exception of the medical college hospitals. To improve maternal healthcare, there is a need for a human-resource plan that increases the number of posts in rural areas and ensures availability. All categories of maternal healthcare providers also need training on evidence-based techniques. While the centralized push system of management has its strengths, special strategies for improving the response in the low-performing areas is urgently warranted.

One of the main challenges faced by today's developers is keeping up with the staggering amount of source code that needs to be read and understood. In order to help developers with this problem and reduce the costs associated with it, one solution is to use simple textual descriptions of source code entities that developers can grasp easily, while capturing the code semantics precisely. We propose an approach to automatically determine such descriptions, based on automated text summarization technology.

This study examines the effect of individual differences on the program comprehension strategies of users working with an unfamiliar programming system. Participants of varying programming expertise were given a battery of psychological tests, a brief introduction to a statistical programming environment, and a 20-minute debugging task. Our data show that while there were distinct comprehension strategies that were related to programming experience, no strategy had an advantage in debugging performance. Rather, individuals with stronger domain knowledge for specific bugs tended to succeed.

This paper reports on an empirical study of the cognitive processes involved in program comprehension. Verbal protocols were gathered from professional programmers as they were engaged in a program-understanding task. Based on analysis of these protocols, several types of interesting cognitive events were identified. These include asking questions and conjecturing facts about the code. We describe these event types and use them to derive a computational model of the programmers' mental processes.

In my PhD thesis I argued that we need to make our software analysis tools work beyond individual software systems at the level of software ecosystems.

I gave two reasons for this: (1) by analyzing a system in context we can better understand it and (2) analyzing software ecosystems in themselves can provide insight that otherwise would not be possible.

By the early 1990s the need for reengineering legacy systems was already acute, but recently the demand has increased significantly with the shift toward web-based user interfaces. The demand by all business sectors to adapt their information systems to the Web has created a tremendous need for methods, tools, and infrastructures to evolve and exploit existing applications efficiently and cost-effectively. Reverse engineering has been heralded as one of the most promising technologies to combat this legacy systems problem. This paper presents a roadmap for reverse engineering research for the first decade of the new millennium, building on the program comprehension theories of the 1980s and the reverse engineering technology of the 1990s.

The understanding of the behavioural aspects of a software system is an important enabler for many reverse engineering activities. The behaviour of software is typically represented in the form of execution traces. Traces, however, can be overwhelmingly large. To reduce their size, sampling techniques, especially the ones based on random sampling, have been extensively used. Random sampling, however, may result in samples that are not representative of the original trace. In this paper, we propose a trace sampling technique that not only reduces the size of a trace but also results in a sample that is representative of the original trace by ensuring that the desired characteristics of an execution are distributed similarly in both the sampled and the original trace. Hence, the insights gained from analyzing the sample trace could be extrapolated to the original execution trace. Our approach is based on stratified sampling instead of random sampling and uses the concept of execution phases as strata. We define an execution phase as a part of a trace that represents a specific task of the traced system. We also present an approach for the automatic detection of execution phases from a trace. Finally, we show the effectiveness of our sampling technique through two case studies.

This paper presents a cognitive framework for describing behaviors involved in program composition, comprehension, debugging, modification, and the acquisition of new programming concepts, skills, and knowledge. An information processing model is presented which includes a long-term store of semantic and syntactic knowledge, and a working memory in which problem solutions are constructed. New experimental evidence is presented to support the model of syntactic/semantic interaction.

Previous studies on program comprehension were carried out largely in the context of procedural languages. Our purpose is to develop and evaluate a cognitive model of object-oriented (OO) program understanding. Our model is based on the van Dijk and Kintsch's model of text understanding (1983). One key aspect of this theoretical approach is the distinction between two kinds of representation the reader might construct from a text: the textbase and the situation model. On the basis of results of an experiment we have conducted, we evaluate the cognitive validity of this distinction in OO program understanding. We examine how the construction of these two representations is differentially affected by the programmer's expertise and how they evolve differentially over time.

THE ADHERENCE OF OPEN SOURCE JAVA PROGRAMMERS TO STANDARD CODING PRACTICES Mahmoud O. Elish Department of Computer Science George Mason University Fairfax VA 22030-4400 USA [email protected] Jeff Offutt† Information and Software Engineering George Mason University Fairfax VA 22030-4400 USA www.ise.gmu.edu/~ofut/ [email protected] ABSTRACT The use of agreed-upon coding practices is believed to enhance program comprehension, which directly affects reuse and maintainability. ...

The paper presents an overview of the role of concepts in program comprehension. It discusses concept location, in which the implementation of a specific concept is located in the code. This process is very common and precedes a large proportion of code changes. The paper also discusses the process of learning about the domain from the code, which is a prerequisite of code reengineering. The paper notes the similarities and overlaps between program comprehension and human learning.

Users are often at best an afterthought among software developerseven when they themselves are the users! Usability of programming languages and tools is all too often equated with raw functionality or casually dismissed as a matter of mere syntactic sugar. In one sense the usability issues for programming languages and tools are nothing special. Whether its a UML modeling tool or a Web 2.0 ERP system, on the other side of the screen is a human eye and hand coordinated by a human brain. The same broad principles and specific techniques of sound interaction design apply.

Recent research in the field of object-oriented software engineering has been focusing on the usage of software metrics for the assessment of a product's quality. Software design coupling metrics include some of the most widely applicable metrics used in the modern software industry. Although static coupling metrics are used for analyzing the structural aspects of the object-oriented software systems, their inability to capture the behavioral aspects is well known and hence has given way to the evolution of their runtime counterparts i.e. the dynamic coupling metrics. Most of the dynamic coupling metrics proposed until now have not yet been empirically validated due to the high evaluation cost involved in the runtime metric data collection, hence limiting their practical application. This paper, as a part of our ongoing research on empirical validation of the dynamic coupling metrics, presents an empirical investigation into the static and dynamic CBO (Coupling Between Objects) metrics using some open source real world java applications. A set of criteria for the selection of sample benchmark applications required for the dynamic metrics validation has also been devised. A scenario based approach in combination with the appropriate statistical techniques has been used in an attempt to correlate the static and dynamic coupling metrics.

Informative identifiers are made up of full (natural language) words and (meaningful) abbreviations. Readers of programs typically have little trouble understanding the purpose of identifiers composed of full words. In addition, those familiar with the code can (most often) determine the meaning of abbreviations used in identifiers. However, when faced with unfamiliar code, abbreviations often carry little useful information. Furthermore, tools that focus on the natural language used in the code have a hard time in the presence of abbreviations. One approach to providing meaning to programmers and tools is to translate (expand) abbreviations into full words. This paper presents a methodology for expanding identifiers and evaluates the process on a code based of just over 35 million lines of code. For example, using phrase extraction, fs exists is expanded to file status exists illustrating how the expansion process can facilitate comprehension. On average, 16 percent of the identifiers in a program are expanded. Finally, as an example application, the approach is used to improve the syntactic identification of violations to Deißenböck and Pizka's rules for concise and consistent identifier construction.

Given the importance of identifier names and the value of naming conventions to program comprehension, we speculated in previous work whether a connection exists between the quality of identifier names and software quality. We found that flawed identifiers in Java classes were associated with source code found to be of low quality by static analysis. This paper extends that work in three directions. First, we show that the association also holds at the finer granularity level of Java methods. This in turn makes it possible to, ...

One reason debugging is the most time-consuming part of software development is because developers struggle to map their questions about a program's behavior onto debugging tools' limited support for analyzing code. Interrogative debugging is a new debugging paradigm that allows developers to ask questions directly about their programs' output, helping them to more efficiently and accurately determine what parts of the system to understand. An interrogative debugging prototype called the Whyline is described, which has been shown to reduce debugging time by a factor of eight. Several extensions and generalizations to it are proposed, including plans for evaluating their effectiveness.

JavaScript is the main scripting language for Web browsers, and it is essential to modern Web applications. Programmers have started using it for writing complex applications, but there is still little tool support available during development. We present a static program analysis infrastructure that can infer detailed and sound type information for JavaScript programs using abstract interpretation. The analysis is designed to support the full language as defined in the ECMAScript standard, including its peculiar object model and all built-in functions. The analysis results can be used to detect common programming errors -or rather, prove their absence, and for producing type information for program comprehension. Preliminary experiments conducted on real-life JavaScript code indicate that the approach is promising regarding analysis precision on small and medium size programs, which constitute the majority of JavaScript applications. With potential for further improvement, we propose the analysis as a foundation for building tools that can aid JavaScript programmers.

Dans cet article, nous aborderons certains aspects du fonctionnement de la perception auditive de l'espace en tant qu'éléments opératoires utilisables dans la création sonore et musicale. Nous analyserons les techniques de mise en espace du son en environnement CSound utilisées dans Sideral 1. Dans ce cadre, nous étudierons la programmation modulaire dans cet environnement en s'intéressant à des techniques de connexion d'unités fonctionnelles autonomes et d'acheminements multiples dans un même instrument. Nous observerons la mise en espace du son par paramétrage d'angle en utilisant l'opcode locsig et par paramétrage linéaire utilisant l'opcode space.

In the software engineering literature, many works claim that the use of design patterns improves the comprehensibility of programs and, more generally, their maintainability. Yet, little work attempted to study the impact of design patterns on the developers' tasks of program comprehension and modification. We design and perform an experiment to collect data on the impact of the Visitor pattern on comprehension and modification tasks with class diagrams. We use an eye-tracker to register saccades and ...

Developers may introduce anti-patterns in their software systems because of time pressure, lack of understanding, communication, and-or skills. Anti-patterns impede development and maintenance activities by making the source code more difficult to understand. Detecting anti-patterns in a whole software system may be infeasible because of the required parsing time and of the subsequent needed manual validation. Detecting anti-patterns on subsets of a system could reduce costs, effort, and resources. Researchers have proposed approaches to detect occurrences of anti-patterns but these approaches have currently some limitations: they require extensive knowledge of anti-patterns, they have limited precision and recall, and they cannot be applied on subsets of systems. To overcome these limitations, we introduce SVMDetect, a novel approach to detect anti-patterns, based on a machine learning technique-support vector machines. Indeed, through an empirical study involving three subject systems and four anti-patterns, we showed that the accuracy of SVMDetect is greater than of DETEX when detecting anti-patterns occurrences on a set of classes. Concerning, the whole system, SVMDetect is able to find more anti-patterns occurrences than DETEX.

Conditioned slicing can be applied to reverse engineering problems which involve the extraction of executable fragments of code in the context of some criteria of interest. This paper introduces ConSUS, a conditioner for the Wide Spectrum Language, WSL. The symbolic executor of Con-SUS prunes the symbolic execution paths, and its predicate reasoning system uses the FermaT simplify transformation in place of a more conventional theorem prover. We show that this combination of pruning and simplificationas-reasoner leads to a more scalable approach to conditioning.

An approach to recommend a ranked list of developers to assist in performing software changes given a textual change request is presented. The approach employs a two-fold strategy. First, a technique based on information retrieval is put at work to locate the relevant units of source code, e.g., files, classes, and methods, to a given change request. These units of source code are then fed to a technique that recommends developers based on their source code change expertise, experience, and contributions, as derived from the analysis of the previous commits. The commits are obtained from a software system's version control repositories (e.g., Subversion).

Scenario diagrams are useful for helping software developers to understand the interactions among the components of a software system. In this paper, we present a semiautomatic approach to extracting scenarios from the implementation of a software system.

By the early 1990s the need for reengineering legacy systems was already acute, but recently the demand has increased sig- nificantly with the shift toward web-based user interfaces. The demand by all business sectors to adapt their informa- tion systems to the Web has created a tremendous need for methods, tools, and infrastructures to evolve and exploit ex- isting applications

1 Program comprehension is a key prerequisite for the maintainance and analysis of legacy software systems. Knowing about the presence of design patterns or antipatterns in a software system can significantly improve the program comprehension.Unfortunately, in many cases the usage of certain patterns is seldom explicitly described in the software documentation, while antipatterns are never described as such in the documentation. Since manual inspection of the code of large software systems is difficult, automatic or semi-automatic procedures for discovering patterns and antipatterns from source code can be very helpful.

An approach is presented to automatically determine a class's stereotype. The stereotype is based on the frequency and distribution of method stereotypes in the class. Method stereotypes are automatically determined using a defined taxonomy given in previous work. The stereotypes, boundary, control and entity are used as a basis but refined based on an empirical investigation of 21 systems. A number of heuristics, derived from empirical evidence, are used to determine a class's stereotype. For example, the prominence of certain types of methods can indicate a class's main role. The approach is applied to five open source systems and evaluated. The results show that 95% of the classes are stereotyped by the approach. Additionally, developers (via manual inspection) agreed with the approach's results.

to Television GHBLD DEVELOPMENT, 1981, 52, 151-157 2 studies tested the hypothesis that TV program comprehensibihty is a major determmant of preschoolers' attenbon to television The first study found that 3-and 5-year-olds' visual attention to "Sesame Street" was enhanced m the presence of dialogue m which the referent was concretely present either visually or auditorily The second study experimentally vaned comprehensibihty by randomly editing scenes withm "Sesame Street" bits, by subsbtutmg foreign language dialogue, or by subsbtutmg the original dialogue backward, utterance for utterance, thus retaming hp synch Relabve to undistorted "Sesame Street" bits, the foreign dialogue and backward dialogue bits produced substanbally lower visual attenbon m 2-, 3 5-, and 5-year-old children The randomly edited bits provided only small decrements m attenbon, but these bits were rated by adults to be significantly more understandable than bits with distorted dialogue The findings are mconsistent with the popular concepbon of young children's television viewing as being primarily determmed by superficial producbon features [Clttld DmOopmeiU, 1981,52, 151-1S7

The scope of software visualization tools which exist for the navigation, analysis and presentation of software information varies widely. One class of tools, which we refer to as Software exploration tools, provides graphical representations of static software structures linked to textual views of the program source code and documentation. This paper describes a hierarchy of cognitive issues which should be considered during the design of a software exploration tool. The hierarchy of cognitive design elements is derived through the ...

Early experiments have suggested that program auralization can convey information about program structure [8]. Languages like Pascal contain classes of construct that are similar in nature allowing hierarchical classification of their features. This taxonomy can be reflected in the design of musical signatures which are used within the CAITLIN program auralization system. Experiments using these hierarchical leitmotifs indicate whether or not their similarities can be put to good use in communicating information about program structure and state.

The authors have explored ways to enhance users' comprehension of complex applications using music and special sound effects to present application program events that are difficult to visually detect. A prototype system, InfoSound, allows developers to create and store musical sequences and special sound effects, to associate stored musical sequences and sound effects to application events, and to have real-time, continuous auditory control of sounds during application execution. InfoSound has been used to create auditory interfaces for two applications: a telephone network service simulation and a parallel computation simulation. The auditory interfaces in these applications helped users detect rapid, multiple event sequences that were difficult to visually detect using text and graphical interfaces. The paper describes the architecture of InfoSound, use of the system, and lessons the authors have learnt

The Boston HAPPENS Program is a collaborative network of care consisting of multiservice outreach agencies; community health centers; and hospitals for HIV-positive, homeless, and hard-to-reach youth. In four years of data collection, the program served more than 2,000 youth, including 54 HIV-positive youth. The youth were 19.9 ؎ 2.9 years old; 64 percent female; 45 percent youth of color; 11 percent gay/lesbian, bisexual, or undecided; and 13 percent homeless or runaway. Homeless youth were much more likely to have been involved with a mental health system (47% vs. 12%, P < 0.001), the criminal justice system (20% vs. 2%, P < 0.001), high-risk sexual behaviors (21% vs. 3%, P < 0.001), and substance abuse (25% vs. 6%, P < 0.001) than were other youth served by the program. Comprehensive networks of care offering a continuum of services and a variety of entry routes and types of care sites are needed to connect under-served youth to health care. Outreach and human immunodeficiency virus (HIV) counseling and testing services can offer important portals of entry into health services for at-risk youth. Support services such as outreach, case management, and mental health services are needed to complement medical services by all youth at-risk for contracting HIV. Support services are necessary for the initiation and retention of youth in care so that early case identification and complex treatment regimens can be initiated and tailored to the individual.

This paper presents ongoing work on using data mining to discover knowledge about software systems thus facilitating program comprehension. We discuss how this work fits in the context of tool supported maintenance and comprehension and report on applying a new methodology on C++ programs. The overall framework can provide practical insights and guide the maintainer through the specifics of systems, assuming little familiarity with these. The contribution of this work is two-fold: it provides a model and associated method to extract data from C++ source code which is subsequently to be mined, and evaluates a proposed framework for clustering such data to obtain useful knowledge. The methodology is evaluated on three open source applications, results are assessed and conclusions are presented. This paper concludes with directions for future work.

This paper describes an analysis scheme which was developed to probe the comprehension of computer programming languages by students learning to program. The scheme operates on free-form program summaries, i.e. textual descriptions of a program which are produced in response to minimal instructions by the researcher/experimenter. The scheme has been applied to descriptions of programs written in various languages, and it is felt that the scheme has the potential to be applied to languages of markedly different types (e.g. procedural, objectoriented, event-driven). The paper first discusses the basis for the scheme, before describing the scheme in detail. It then presents examples of the scheme's application, and concludes with a discussion of some open issues. r

Automatic program comprehension applications, which try to extract programming knowledge from program code, share many fea- tures of human program comprehension models. However, the human trait of learning seems to be missing among the shared features. We present an approach to integrate machine learning techniques into auto- matic program comprehension, and present an example implementation in the context of automatic analysis of roles of variables.