Program Comprehension

With their abstract vocabulary and overly long sentences, patent claims, like several other genres of legal discourse, are notoriously difficult to read and comprehend. The enormous number of both native and non-native users reading patent claims on a daily basis raises the demand for means that make them easier and faster to understand. An obvious way to satisfy this demand is to paraphrase the original material, i.e., to rewrite it in a more appropriate style, or-even better-to summarize it in the language of preference of the reader such that the reader can rapidly grasp its essence. PATExpert is a patent processing service which incorporates, among other technologies, paraphrasing and multilingual summarization of patent claims. With the goal to offer the user the most suitable options and to evaluate alternative techniques that are based on different contextual and linguistic criteria, both paraphrasing and summarization implement "surface-oriented" strategies and "deep" strategies. The surface strategies make use of shallow linguistic criteria such as punctuation and syntactic and lexical markers. The deep strategies operate on deep-syntactic structures of the claims, using a full fledged text generator for synthesis of the paraphrase or summary, respectively.

Translation between natural language and source code can help software development by enabling developers to comprehend, ideate, search, and write computer programs in natural language. Despite growing interest from the industry and the research community, this task is often difficult due to the lack of large standard datasets suitable for training deep neural models, standard noise removal methods, and evaluation benchmarks. This leaves researchers to collect new small-scale datasets, resulting in inconsistencies across published works. In this study, we present CoDesc-a large parallel dataset composed of 4.2 million Java methods and natural language descriptions. With extensive analysis, we identify and remove prevailing noise patterns from the dataset. We demonstrate the proficiency of CoDesc in two complementary tasks for code-description pairs: code summarization and code search. We show that the dataset helps improve code search by up to 22% and achieves the new state-of-the-art in code summarization. Furthermore, we show CoDesc's effectiveness in pre-training-finetuning setup, opening possibilities in building pretrained language models for Java. To facilitate future research, we release the dataset, a data processing tool, and a benchmark at https://github.com/csebuetnlp/CoDesc.

This study aimed to make a characterization about how information visualization has been applied on software comprehension with relation to techniques and tools proposed by literature. Systematic Mapping was adopted as the method to guide the investigation process. The findings, although not being definitive, points direction over important questions such as what kind of artifacts and life-cycle phase have been more considered. It was also investigated how these studies have been evaluated, how they evolved in the main digital libraries over the last decade, and what points deserves further attention, through new research.

Software complexity measurement has been an agelong quandary in software engineering as the effort used to develop, comprehend, or retain the software depends on so many complicated factors. Measuring and controlling of complexity will have an important influence to improve productivity, quality and maintenance of software. So far, most of the researches have tried to identify and measure the complexity in design and code phase. However, when we have the code or design for software, it is too late to control complexity and leads inaccuracy publishing in the whole system. In this paper, we propose a new dimension scheme, in the first phase i.e. Requirement phase of software development which is based on software requirement specifications. Keyword – Code based complexity measures, Cognitive complexity measures and new scheme for complexity measure.

Software debugging is a time-consuming and challenging process. Supporting debugging has been a focus of the software engineering field since its inception with numerous empirical studies, theories, and tools to support developers in this task. Performance bugs and performance debugging is a sub-genre of debugging that has received less attention. In this paper we contribute an empirical case study of performance bug diagnosis in the WiredTiger project, the default database engine behind MongoDB. We perform an in-depth analysis of 44 Jira tickets documenting WiredTiger performance-related issues. We investigate how developers diagnose performance bugs: what information they collect, what tools they use, and what processes they follow. Our findings show that developers spend the majority of their performance debugging time chasing outlier events, such as latency spikes and throughput drops. Yet, they are not properly supported by existing performance debugging tools in this task. We also observe that developers often use tools without knowing in advance whether the obtained information will be relevant to debugging the problem. Therefore, we believe developers can benefit from tools that can be used for unstructured exploration of performance data, rather than for answering specific questions. CCS CONCEPTS • Software and its engineering → Software performance; Software development methods; Programming teams;

Software debugging is a time-consuming and challenging process. Supporting debugging has been a focus of the software engineering field since its inception with numerous empirical studies, theories, and tools to support developers in this task. Performance bugs and performance debugging is a sub-genre of debugging that has received less attention. In this paper we contribute an empirical case study of performance bug diagnosis in the WiredTiger project, the default database engine behind MongoDB. We perform an in-depth analysis of 44 Jira tickets documenting WiredTiger performance-related issues. We investigate how developers diagnose performance bugs: what information they collect, what tools they use, and what processes they follow. Our findings show that developers spend the majority of their performance debugging time chasing outlier events, such as latency spikes and throughput drops. Yet, they are not properly supported by existing performance debugging tools in this task. We also observe that developers often use tools without knowing in advance whether the obtained information will be relevant to debugging the problem. Therefore, we believe developers can benefit from tools that can be used for unstructured exploration of performance data, rather than for answering specific questions. CCS CONCEPTS • Software and its engineering → Software performance; Software development methods; Programming teams;

Introduction. The comprehension of computer programs is claimed to be a decisive faculty and even skill of any successful
exercising professional duties of program engineers, for example, prototype analysis, decision making and discussion about
algorithms and structures, development of detailed documentation, test development and test analysis. Exercising of the
duties demands from the engineer a special competence to judge about a program behavior basing on the consideration
of its source and sometimes digital codes, screenshots, execution protocols. The skill and opportunity to make trial runs
can supplement but not replace the competence. Manifesting itself on particular programs it is not a presentation of an
extensive and deep familiarity with the programs, but results from the experience with a lot of programs and is obscured
by another competence, the competence of the developer.
This paper is aimed to precise the interpretation of the notion “program comprehension”, to research the opportunities of
a purposeful and enhanced teaching the program comprehension, to develop methods and tools for the assessment of
the program comprehension teaching in the higher school. The aim is relevant because of current university curricula allot
considerable lecture and laboratory time for teaching programming, including program comprehension. But this time is
constantly not enough in view of a growing intensity of innovations in the area of the program engineering. The problem
of a control over processes of the program comprehension fostering in a computer class is a key problem of achieving the
aim having been set.
Materials and methods. The research is based on the university syllabi, the author’s lecture notes, protocols of experimental
and sample runs of the developed programs, Internet resources, such as site of the ACM and others. The following research
methods were used: terminological analysis and elaboration of a vocabulary demanded in the research and discourse
within the paper; modelling and simulation, including a theoretical conceptual model representation of the program
comprehension, a computer program simulation of the monitoring and control over the comprehension progress; an UMLpresentation and a trial implementation of the proposed interface for the program comprehension monitoring and control.
Research results. Redefinition of conceptual cognitive models of program comprehension is proposed. The program
comprehension is postulated to be a state of the cognitive knowledge base that represents an actual affordance of giving
correct answers to questions about an eventual program behavior. This model highlights a special kind of teaching to be
called “didactic parsing” that is targeted to generate at the audience a comprehension of programs being parsed. Dynamics
of question and answers during the didactic parsing is used for assessing the education success and, finally, for a control of
the teaching tempo. A user interface for learning computer systems (counters, controls and policies) are proposed to assist in
monitoring and control of the didactic parsing. Sample implementation of the interface is built in JL (Joint Lesson) computer
system. A graph model and a corresponding simulation program are developed that capture relevant dynamic features of
control over the didactic parsing and are applied for the further investigation and demonstration of general didactic parsing
effects as well as an aid for planning and control of program comprehension teaching during particular lectures.
Conclusion. The research results provide creation of an environment, methods and tools enabling to positively impact the
processes of program comprehension attainment. In particular, they permit to control the program comprehension level at
a particular audience, adjust style of teaching to be most applicable to it, refine time plans of lectures in the area of program
engineering.

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.

Software complexity measurement has been an agelong quandary in software engineering as the effort used to develop, comprehend, or retain the software depends on so many complicated factors. Measuring and controlling of complexity will have an important influence to improve productivity, quality and maintenance of software. So far, most of the researches have tried to identify and measure the complexity in design and code phase. However, when we have the code or design for software, it is too late to control complexity and leads inaccuracy publishing in the whole system. In this paper, we propose a new dimension scheme, in the first phase i.e. Requirement phase of software development which is based on software requirement specifications. Keyword – Code based complexity measures, Cognitive complexity measures and new scheme for complexity measure.

Translation between natural language and source code can help software development by enabling developers to comprehend, ideate, search, and write computer programs in natural language. Despite growing interest from the industry and the research community, this task is often difficult due to the lack of large standard datasets suitable for training deep neural models, standard noise removal methods, and evaluation benchmarks. This leaves researchers to collect new small-scale datasets, resulting in inconsistencies across published works. In this study, we present CoDesc-a large parallel dataset composed of 4.2 million Java methods and natural language descriptions. With extensive analysis, we identify and remove prevailing noise patterns from the dataset. We demonstrate the proficiency of CoDesc in two complementary tasks for code-description pairs: code summarization and code search. We show that the dataset helps improve code search by up to 22% and achieves the new state-of-the-art in code summarization. Furthermore, we show CoDesc's effectiveness in pre-training-finetuning setup, opening possibilities in building pretrained language models for Java. To facilitate future research, we release the dataset, a data processing tool, and a benchmark at https://github.com/csebuetnlp/CoDesc.

Code clones convey important information about a software system's design and implementation. Several tools have been proposed to detect code clones. However, mostly the focus so far has been on fragments of duplicated code. In our studies, we observed that certain configurations of duplicated code fragments may signify some higher level patterns of similarities (usually, the result of cloning design solutions). Such higher level similarities often represented some domain or design concepts, comprising much ...

The communication between the sensor-controllers and the buffering service is achieved using TCP [4]. A failure of the sensor-controller to send signals to the buffering service would be interpreted as the failure of the buffering service. When such a failure occurs, the sensor-controller sends signals to another buffering service. The secondary buffering service is configured to monitor the primary. When the primary is alive the secondary remains dormant, but when the primary dies, the secondary becomes active. The primary has the highest priority to handle signals, hence if the primary is restarted again, it becomes active and the secondary shifts to the passive mode. Thus, the communication protocol between the sensor-controllers and the buffering service is provided with sufficient intelligence to determine failure of transmission of the signals. Currently, we are discovering means to improve the implementation so as to achieve better performance and more robustness.

In studying about programming languages, the important part is to understand the language itself. Learners need to be able to comprehend a program that is completed with syntax, semantic and program flow. Most learners especially the novices face a lot of problems when trying to learn a program. Many studies have been conducted to observe the process on how learners understand the program source code. Usually, the study of program comprehension focuses on the combination of two important characteristics: theories and tools. The theories that provide how to improve program comprehension and tools that can implement the theories. These two characteristics will change the way programmers understand the program codes. Many researchers review some of the key theories of program comprehension and discusses on how these theories are related to tools that support it. Thus, the aim of this study is to explore the evolution of the three predominant approaches of program comprehension in the aspect of cognitive theory which are: bottom-up, top-down and the integrated approach. This study also considers the important of cognitive model to make the effective learning process. Therefore, this paper can provide the intuitive environment for the process of learning especially for novice learners.

During software development, design rules and contracts in the source code are often encoded through regularities, such as API usage protocols, coding idioms and naming conventions. The structural regularities that govern a program can aid in comprehension and maintenance of the application, but are often implicit or undocumented. Tool support for extracting these regularities from the source code can provide developers useful insights. But building such tool support is not trivial, in particular, because the informal nature of regularities results in frequent deviations and exceptions to these regularities. We propose an automated approach, based on association rule mining, to discover the structural regularities that govern the source code of a software system. We chose this technique because of its resilience to exceptions. In general, tool support for mining regularities tends to discover a huge amount of rules, making interpretation of the results hard and time-consuming. To ease the interpretation, we reduce the results to a minimal canonical form, and group them to obtain a more rational description of the discovered regularities. As an initial feasibility study of our approach, we applied it on two open-source systems, namely IntensiVE (Smalltalk) and FreeCol (Java).

The communication between the sensor-controllers and the buffering service is achieved using TCP [4]. A failure of the sensor-controller to send signals to the buffering service would be interpreted as the failure of the buffering service. When such a failure occurs, the sensor-controller sends signals to another buffering service. The secondary buffering service is configured to monitor the primary. When the primary is alive the secondary remains dormant, but when the primary dies, the secondary becomes active. The primary has the highest priority to handle signals, hence if the primary is restarted again, it becomes active and the secondary shifts to the passive mode. Thus, the communication protocol between the sensor-controllers and the buffering service is provided with sufficient intelligence to determine failure of transmission of the signals. Currently, we are discovering means to improve the implementation so as to achieve better performance and more robustness.

In this paper, we present the results of one aspect of a multinational, multi-institutional study of computer programming students. Specifically, this paper reports on an exploration of relationships between novice programmers' map-drawing styles (landmark, route or survey) and success in a first programming course at tertiary level. Relationships were found between map-drawing style and success of students in introductory programming'courses, but there were mediating factors that resulted in some mixed ...

In object-oriented programming, quality assurance is commonly provided through writing unit tests, to exercise the operations of each class. If unit tests are created and maintained manually, this can be a time-consuming and laborious task. For this reason, automatic methods are often used to generate tests that seek to cover all paths of the tested code. Search may be guided by criteria that are opaque to the programmer, resulting in test sequences that are long and confusing. This has a negative impact on test maintenance. Once tests have been created, the job is not done: programmers need to reason about the tests throughout the lifecycle, as the tested software units evolve. Maintenance includes diagnosing failing tests (whether due to a software fault or an invalid test) and preserving test oracles (ensuring that checked assertions are still relevant). Programmers also need to understand the tests created for code that they did not write themselves, in order to understand the i...

Software development in C and C++ is widely used in the various industries including Information Technology, Telecommunication and Transportation since the 80-ies. Over this four decade, companies have built up a huge software legacy. In many cases these programs, implementing complex features (such as OS kernels, databases) become inherently complicated and consist of millions lines of code. During the many years long development, not only the size of the software increases, but a large number (i.e. hundreds) of programmers get involved. Mainly due to these two factors the maintenance of software becomes more and more time consuming and costly. To attack the above mentioned complexity issue, companies apply various source code cross-referencers to help in the navigation and visualization of the legacy code. In this article we present a visualization methodology that helps programmers to understand the functional dependencies of artifacts in the C++ code in the form similar to UML c...

The emergence of the long-tail in the market of software applications is shifting the role of end-users from mere consumers to becoming developers of applications addressing their unique, personal, and transient needs. On the Web, a popular form of such applications is called mashup, built out of the lightweight composition of Web APIs (reusable software components delivered as a service through the Web). To enable end-users to build mashups, there is a key problem that must be overcome: End-users lack programming knowledge as well as the interest to learn how to master the complex set of Web technologies required to develop mashups. End-User Development (EUD) is an emerging research field dealing with this type of problems. Its main goal is to design tools and techniques facilitating the development of software applications by nonprogrammers. In this dissertation, we designed and implemented NaturalMash, an EUD system that empowers end-users to develop mashups. NaturalMash adopts a novel hybrid end-user programming technique combining natural language programming with a what-you-see-is-what-you-get interface in a live programming environment. We followed an iterative user-centered design process, in which three formative evaluations drove the incremental design of our system. At the end of the process, we conducted a summative usability evaluation, whose results suggest that the system is highly usable by non-programmers. Also, we proposed a novel benchmarking framework to evaluate mashup tools against each other. Using the framework, we conducted a comparative evaluation of 28 state-of-the-art mashup tools (NaturalMash included) against their expressive power. According to the results, our proposed system has a moderate yet competitive level of expressiveness. All in all, NaturalMash contributes a novel design featuring a unique combination of end-user programming techniques, a suitable metaphor, and the ability to enable an optimal learning experience. Our extensive evaluation results indicate that NaturalMash is located at a sweet spot along the classical trade-off between expressiveness and usability/learnability. v vi My PhD has been a pleasant and fruitful journey which brought many life-lasting knowledge, experiences, lessons, memories, friendships, and of course, a pile of code and documents including this dissertation. As I am writing this, I am miles away from those who made this journey possible. So I am taking this opportunity to profusely thank them in writing. Foremost, I would like to express my greatest gratitude and appreciation to Prof. Cesare Pautasso, from whom I learned many things. Being always available, he patiently guided me through ups and downs of my PhD, and believed in me when I was lost. It was a pleasure and a privilege to do my PhD under your supervision. I am sincerely grateful to Daniele Bonetta, Marcin Nowak, Dr. Achille Peternier, Masiar Babazadeh, and Vasileios Triglianos for being friends, giving continuous constructive feedback on my work, proofreading my papers, and participating in my user studies. I wish you luck in your lives and hope to see you again. I would like to thank Mauro Prevostini for giving me the opportunity to conduct a usability test on high school students, Dr. Monica Landoni for her valuable input into the design of the formative evaluation of my work, and Prof. Antonella De Angeli for hosting me in University of Trento, Italy, to properly conduct a user study of my system. I am thankful to my best friends, Ehsan, Morteza, Lea, Marco, Andrea, and Silvia, who made the beautiful and wonderful city of Lugano socially pleasant for me. Your memory lingers on. I profusely thank my parents, Akram and Hassan, and my brothers, Farid and Amir, without whom I wouldn't be where I am today. All I ever need is you by my side, so live forever. Last but not least, I wish to thank my love of life, Negin, for her loving care and support. I am so lucky to have you in my life. vii viii Contents Contents ix List of Figures xiii List of Tables xvii xii Contents Bibliography 127

Program comprehension during software maintenance is a difficult task, hence the need to support it by recovering the as-built architecture of the system to be maintained. In this paper, we propose a method to recover runtime architecture models of object-oriented systems. The method combines static and dynamic analysis to recover an Object Graph (OG) and uses two techniques to manage the complexity of this graph. CCS Concepts •Software and its engineering → Object oriented architectures;

A large body of the literature of automated program repair develops approaches where patches are generated to be validated against an oracle (e.g., a test suite). Because such an oracle can be imperfect, the generated patches, although validated by the oracle, may actually be incorrect. While the state of the art explore research directions that require dynamic information or that rely on manually-crafted heuristics, we study the benefit of learning code representations in order to learn deep features that may encode the properties of patch correctness. Our empirical work mainly investigates different representation learning approaches for code changes to derive embeddings that are amenable to similarity computations. We report on findings based on embeddings produced by pre-trained and retrained neural networks. Experimental results demonstrate the potential of embeddings to empower learning algorithms in reasoning about patch correctness: a machine learning predictor with BERT transformer-based embeddings associated with logistic regression yielded an AUC value of about 0.8 in the prediction of patch correctness on a deduplicated dataset of 1000 labeled patches. Our investigations show that learned representations can lead to reasonable performance when comparing against the state-of-the-art, PATCH-SIM, which relies on dynamic information. These representations may further be complementary to features that were carefully (manually) engineered in the literature. CCS CONCEPTS • Software and its engineering → Software testing and debugging.

Thanks to the object-composition group, the community behind DCI, that helped me in the understanding of the DCI paradigm and trygve language, specially thanks to Matthew Browne, Andreas Söderlund, Trygve Mikkjel Heyerdahl Reenskaug, and Rune Funch Søltoft. Thanks to James O. Coplien for his collaboration in the first part of this investigation and for playing an important role that favored the direction of my line of study to something that I like. Thanks to Mehdi Mirakhorli to accept being my advisor and support the realization of this thesis. Thanks to Mehdi's research group, specially Palak Sharma, Raghuram Gopalakrishnan, and Danielle Gonzales. Thanks to Ibrahim Mujhid for helping with the java versions, and to my friend and professional colleague Alexis Sarghel to review the questions and to set the server where our web application was deployed to run the experiment. Thanks to José Vargas, a friend and former colleague and IT professional, to Hernán Wilkinson, co-founder of 10Pines, and Darío Korec from Axoft Argentina to help in the recruitment for the experiment. I am grateful for the funding received through the Argentine Presidential Fellowship in Science and Technology and the Argentina Fulbright Commission that made possible the completion of my master degree. I thank the Software Engineering department's Graduate Scholarship Committee at RIT for selecting me to receive an RIT Graduate Scholarship to support my graduate studies.

Comprehension of computer programs is daunting, due in part to clutter in the software developer's visual environment and the need for frequent visual context changes. Previous research has shown that nonspeech sound can be useful in understanding the runtime behavior of a program. We explore the viability and advantages of using nonspeech sound in an ecological framework to help understand the static structure of software. We describe a novel concept for auditory display of program elements in which sounds indicate characteristics and relationships among a Java program's classes, interfaces, and methods. An empirical study employing this concept was used to evaluate 24 sighted software professionals and students performing maintenance-oriented tasks using a 2×2 crossover. Viability is strong for differentiation and characterization of software entities, less so for identification. The results suggest that sonification can be advantageous under certain conditions, though the...

The graphical representations of software (code visualization in particular) may provide both professional programmers and students learning only the basics with support in program comprehension. Among the numerous proposed approaches, our research applies the city metaphor for the visualisation of such code elements as classes, functions, or attributes by the tool CodeMetropolis. It uses the game engine of Minecraft for the graphics, and is able to visualize various properties of the code based on structural metrics. In this work, we present our approach to integrate our visualization tool into the Eclipse IDE environment. Previously, only standalone usage was possible, but with this new version the users can invoke the visualization directly from the IDE, and all the analysis is performed in the background. The new version of the tool now includes an Eclipse plug-in and a Minecraft modification in addition to the analysis and visualization modules which have also been extended with some new features. Possible use cases and a detailed scenario are presented.

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.

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.

Impact analysis is a specialized process of program comprehension that investigates the nature and extent of a planned software change. Traditionally, impact analysis involves inspecting dependencies among the software components of a fixed granularity; these components constitute a dependency graph. In this paper, we argue that a single granularity is insufficient and leads to imprecise analysis. We explain how the precision can be improved by variable granularity, where the programmers choose among the granularity of classes, the granularity of class members, and the granularity of code fragments. We assess the resulting precision in a case study on open-source software.

A variety of readers, with a variety of goals, will find this 2005 book useful. While it is clearly not a textbook, particular chapters could be used in a classroom setting to expose students to current streams of research in software maintenance, as well as to different perspectives on basic maintenance issues. Practitioners will find practical information on particular maintenance problems they might be facing, including the migration of a large legacy system in general (Chapters 5, 13 and 8-11), or to the Web in particular (Chapters 6, 7 and 11), assessment of maintenance and organizational structure (Chapters 3, 4 and 14), and approaches for changing how an organization carries out software development and maintenance (Chapters 2, 12, 13 and 15), as well as on maintenance management (Chapter 1). While some of these chapters provide a level of detail sufficient to allow the reader to apply the techniques and methods described, most are not meant as recipes, or detailed how-tos of techniques. Instead, the chapters provide the necessary overview, augmented by extensive lists of references.

According to a recent observational study, developers spend an average of 48% of their development time on debugging tasks. Approaches such as equivalence checking and fault localization support developers during debugging tasks by providing information that enables developers to more quickly identify and deal with unintended changes in program behavior. The accuracy and runtime performance of these approaches have seen continuous improvements throughout the years. However, the outputs of existing tools are often difficult to understand for developers due to a lack of context information and result explanations. Our goal is to improve upon this issue by developing a new equivalence checking approach that (i) is at least as accurate as existing approaches but (ii) provides more detailed descriptions of identified behavioral / semantic differences and (iii) presents these results in a way that is useful for developers, thus aiding developer understanding of equivalence checking results and corresponding software changes.

In programming education, the instructor tries to find out the learners who needs help by grasping the learners' development of understanding using tests that require knowledge. However, in reality, not many learners will acquire the skill of writing source codes. This kind of current situation implies that programming ability of learners cannot be measured by tests that require knowledge. This paper focuses on not only the knowledge items required for programming but also the programming thinking (computational thinking), which is the ability to combine the constituent elements of the program. In this paper, we propose a method to estimate the learner's understanding from the learner's process to solve the code puzzles that require programming thinking as well as knowledge. We developed the interface to realize the proposed method. The experimental result with the interface showed that the proposed method could estimate with the accuracy of 80% or more.

It is difficult for a student to learn how to program and to build an understanding of the rationale which underpins the development of a program's componentparts. Conventional tools and approaches for explaining this essentially dynamic process are limited and typically static in nature. This paper presents AnnAnn, an animated code annotator, which can be used for self study and to present code development to large groups. The technical and educational benefits of this approach are examined.

Dynamic program analysis tools based on code instrumentation serve many important software engineering tasks such as profiling, debugging, testing, program comprehension, and reverse engineering. Unfortunately, constructing new analysis tools is unduly difficult, because existing frameworks offer little or no support to the programmer beyond the incidental task of instrumentation. We observe that existing dynamic analysis tools re-address recurring requirements in their essential task: maintaining state which captures some property of the analysed program. This paper presents a general architecture for dynamic program analysis tools which treats the maintenance of analysis state in a modular fashion, consisting of mappers decomposing input events spatially, and updaters aggregating them over time. We show that this architecture captures the requirements of a wide variety of existing analysis tools.

Calling context profiling is an important technique for analyzing the performance of object-oriented software with complex inter-procedural control flow. The Calling Context Tree (CCT) is a common data structure that stores dynamic metrics, such as CPU time, separately for each calling context. As CCTs may comprise millions of nodes, there is a need for a condensed visualization that eases the localization of performance bottlenecks. In this article, we discuss Calling Context Ring Charts (CCRCs), a compact visualization for CCTs, where callee methods are represented in ring segments surrounding the caller's ring segment. In order to reveal hot methods, their callers, and callees, the ring segments can be sized according to a chosen dynamic metric. We describe two case studies where CCRCs help us to detect and fix performance problems in applications. A performance evaluation also confirms that our implementation can efficiently handle large CCTs.

This paper presents a methodology for Mining Association Rules from Code (MARC), aiming at capturing program structure, facilitating system understanding and supporting software management. MARC groups program entities (paragraphs or statements) based on similarities, such as variable use, data types and procedure calls. It comprises three stages: code parsing/analysis, association rule mining and rule grouping. Code is parsed to populate a database with records and respective attributes. Association rules are then extracted from this database and subsequently processed to abstract programs into groups containing interrelated entities. Entities are then grouped together if their attributes participate to common rules. This abstraction is performed at the program level or even the paragraph level, in contrast to other approaches that work at the system level. Groups can then be visualised as collections of interrelated entities. The methodology was evaluated using real-life COBOL programs. Results showed that the methodology facilitates program comprehension by using source code only, where domain knowledge and documentation are either unavailable or unreliable.

This paper presents au empirical study of a programming by demonstration language for a geographic information system (GIS). The long-term goal of the project is to enable non-technical end users to exercise the capabilities of a GIS without having to learn the technical concepts that are embedded in most traditional GIS interfaces (Traynor & Williams, 1995). The programming by demonstration language is an extension of the Pursuit language introduced by Modugno for file management in the Macintosh Finder (Modugno, Corbett & Myers, 1996). The extensions permit the display of textual information in tables and of cartographic information on a map. The purpose of the preliminary study reported here was to determine whether programmers could read, edit, and create programs in the programming by demonstration language. Subjects' performance on the program comprehension tasks and the editing of simple programs was error free. Errors in the editing of more complex programs and in the program creation tasks indicate that some of the language constructs may need to be redesigned. Subjects' opinions of the programming by demonstration language were generally positive, as indicated by post-test questionnaires. We conclude that programming by demonstration is a promising approach for a GIS interface.

Background Well-functioning patient feedback systems can contribute to improved quality of healthcare and ultimately make health systems more accountable. We used realist evaluation to understand the functioning of patient feedback systems at frontline health facilities in Bangladesh. Methods We collected and analysed data in two stages using: document review; secondary analysis of data from publicly-available web-portals; in-depth interviews with patients, health workers and managers; non-participant observations of feedback environments; and stakeholder workshops. Stage 1 focused on identifying and articulating the initial program theory of patient feedback systems. In Stage 2, we iteratively tested and refined this initial theory, through analysing data and grounding emerging findings within substantive theories and empirical literature, to arrive at a refined program theory. Results Multiple patient feedback systems operate in Bangladesh, essentially comprising stages of collect...

The complexity of the systems that software engineers build has continuously grown since the inception of the field. What has not changed is the engineers' mental capacity to operate on about seven distinct pieces of information at a time. The widespread use of UML has led to more abstract software design activities, however the same cannot be said for reverse engineering activities. The introduction of abstraction to reverse engineering will allow the engineer to move farther away from the details of the system, increasing his ability to see the role that domain level concepts play in the system. In this thesis, we present a technique that facilitates filtering of classes from existing systems at the source level based on their relationship to concepts in the domain via a classification method using machine learning. We showed that concepts can be identified using a machine learning classifier based on source level metrics. We developed an Eclipse plugin to assist with the proc...

This study aimed to make a characterization about how information visualization has been applied on software comprehension with relation to techniques and tools proposed by literature. Systematic Mapping was adopted as the method to guide the investigation process. The findings, although not being definitive, points direction over important questions such as what kind of artifacts and life-cycle phase have been more considered. It was also investigated how these studies have been evaluated, how they evolved in the main digital libraries over the last decade, and what points deserves further attention, through new research.

Decision makers spend significant time and effort interpreting information derived from large multidimensional databases; data are usually represented by several dashboard diagrams. The Complexity Design (CoDe) methodology provides a technique modeling graphical reports on data extracted by a data warehouse, where the charts composing the dashboard diagrams are integrated with a visual representation of the logical relationships among them. The generated visualizations (CoDe Graphs) are automatically obtained by connecting dashboard diagrams through graphical conceptual links. After analyzing the state of the art regarding the evaluation of graphical representation comprehensibility, we propose a classification of those evaluation approaches and evaluate the comprehensibility of CoDe Graphs concerning dashboard reports through a controlled experiment, involving 47 participants. Results show that CoDe Graphs reduce participants effort while improving effectiveness and efficiency in comprehension tasks.