On dynamic feature location

Most of today's industries, from engineering to agriculture to health, are run on software. In such a context, ensuring software quality play an important role in most of current working environment and have a direct impact in any scientific and technical discipline. Software maintenance and testing have the crucial goal to find or discover possible software bugs (or defects) as early as possible, enabling software quality assurance. However, software maintenance and testing are very expensive and time-consuming activities for developers. For this reason, in the last years, several researchers in the field of Software Engineering (SE) devoted their effort in conceiving tools for boosting developers productivity during such development, maintenance and testing tasks. In this talk, I will first discuss some empirical work we performed to understand the main socio-technical challenges developers face when joining a new software project. I will discuss how to address them with the use of appropriate recommender systems aimed at supporting developers during program comprehension and maintenance tasks. Then, I'll show how Summarization Techniques are an ideal technology for supporting developers when performing testing and debugging activities. Finally, I will summarize the main research advances, the current open challenges/problems and possible future directions to exploit for boosting developers productivity.

Dynamic program analysis is extremely successful both in code debugging and in malicious code attacks. Fuzzing, concolic, and monkey testing are instances of the more general problem of analysing programs by dynamically executing their code with selected inputs. While static program analysis has a beautiful and well established theoretical foundation in abstract interpretation, dynamic analysis still lacks such a foundation. In this paper, we introduce a formal model for understanding the notion of precision in dynamic program analysis. It is known that in sound-by-construction static program analysis the precision amounts to completeness. In dynamic analysis, which is inherently unsound, precision boils down to a notion of coverage of execution traces with respect to what the observer (attacker or debugger) can effectively observe about the computation. We introduce a topological characterisation of the notion of coverage relatively to a given (fixed) observation for dynamic program analysis and we show how this coverage can be changed by semantic preserving code transformations. Once again, as well as in the case of static program analysis and abstract interpretation, also for dynamic analysis we can morph the precision of the analysis by transforming the code. In this context, we validate our model on well established code obfuscation and watermarking techniques. We confirm the efficiency of existing methods for preventing control-flow-graph extraction and data exploit by dynamic analysis, including a validation of the potency of fully homomorphic data encodings in code obfuscation.

Feature location, an important task in program comprehension, occurs when the developer identifies the source code entity or entities responsible for implementing a functionality. Researchers have applied static analysis techniques to multiple software maintenance tasks, including feature localization. Static analysis techniques operate on a document corpus. Configuration and preprocessing decisions are required to build a suitable source code corpus for a static analysis technique. Currently, there is little guidance in the software engineering literature for making such configuration decisions. This paper focuses on two preprocessing methods for source code corpora, identifier splitting and stop word lists. We experiment on three open source Java test suites, i.e. Mylyn 1.0.1, Rhino 1.5R5, and Rhino 1.6R5. Our results indicate that identifier splitting and stop word list decisions do not significantly affect the performance of the LDA based feature location technique.

Aim of the Thesis This thesis aims to contribute to a theoretical understanding of learning computer programming. It is important to understand the nature of learning programming for two reasons. First, the increasing role of the microcomputer as an everyday tool demands that users possess an elementary understanding of the nature of software that drives it. Such an understanding should promote more intelligent and more confident use of the microcomputer as a problem solving tool. Second, many beginning programmers experience difficulty in grasping the fundamental concepts of programming and acquiring a basic level of programming skill. Because the number of nonprofessional programmers is constantly growing, the needs of this group must be addressed so that initial learning difficulties they experience do not become a permanent barrier to their continuing interaction with computers. Scope of the Thesis The thesis studies two factors that appear most salient in affecting the outcome of learning programming. First, it studies the use of analogy as a means of achieving meaningful learning. Second, it studies the use of spreading activation as a basis for forming correct and functional knowledge structures. Although it is well-established that analogies are a useful tool of instruction because they assist learning by relating new information to prior knowledge, it is also intuitively known that some analogies are more effective at facilitating explanation than others. In this light, this research empirically tests the validity of the Theory of the Structure of Explanatory Analogies (derived from Gentner [1982]), which predicts the relative explanatory power of competing analogies based on a structural characterization of analogy. Spreading activation is associated with presenting stimuli that make use of the knowledge learners acquire in the course of learning. Knowledge structures are activated in the sense that the stimuli initiate a process that establishes connections between concepts in human memory. The spreading activation construct proposes that the strength of connections established between nodes in memory varies directly with the frequency of activation of knowledge structures during learning. Activation creates functional and correct knowledge structures because it provides a means of testing the correctness of the knowledge structures by applying them to problems in the real world. Research Method The research was conducted using a laboratory experiment that comprised two phases. The first phase was a program comprehension phase in which subjects learned the syntax and semantics of a subset of the programming language BASIC. The second phase was a program composition phase that required subjects to compose short programs to solve given problems. Two factors, analogy and activation, were manipulated in a 3 x 2 factorial design. The analogy factor was operationalized according to the prescriptions of the Theory of the Structure of Explanatory Analogies. The activation factor was operationalized by varying the frequency with which subjects were required to answer questions on what they had learned. The experiment controlled for differences in mathematics ability and age. The dependent variables were score obtained on the program comprehension and composition tasks and the time taken to perform the tasks. Subjects who participated in the research were 15- to 17-year-olds without prior exposure to computer programming. Conclusions of the Thesis Four major results were obtained. First, the Theory of the Structure of Explanatory Analogies is confirmed with respect to program comprehension. Subjects who learned programming using an instruction set containing a good analogy (that is, an analogy that the theory predicts has high explanatory power) performed significantly better than subjects who learned programming using an instruction set containing a weak analogy (that is, an analogy that the theory predicts has low explanatory power) and subjects who learned programming without an analogy. Second, the Theory of the Structure of Explanatory Analogies is also confirmed with respect to program composition. Subjects who studied programming with a good analogy performed significantly better than those who studied with a weak analogy or without an analogy when composing programs. Third, the validity of the spreading activation construct is marginally supported when learning is measured in terms of the score obtained on program comprehension. Fourth, a. post hoc data analysis suggests that the weak analogy harms the learning of syntax and the good analogy assists the learning of semantics. In addition, frequent activation enhances the learning of syntax but not semantics.

Formal Concept Analysis (FCA) is a theoretical framework which structures a set of objects described by properties. In order to migrate software product variants which are considered similar into a product line, it is essential to identify the common and the optional features between the software product variants. In this paper, we present an approach for feature location in a collection of software product variants based on FCA. In order to validate our approach we applied it on a case study based on ArgoUML. The results of this evaluation showed that all of the features were identified.

In industry, software projects might span over decades, with many engineers joining or leaving the company over time. In these circumstances, no single engineer has all of the knowledge when maintenance tasks such as Traceability Link Recovery (TLR), Bug Localization (BL), and Feature Location (FL) are performed. Thus, collaboration has the potential to boost the quality of maintenance tasks since the solution advanced by one engineer might be enhanced with contributions from other engineers. However, assembling a team of software engineers to collaborate may not be as intuitive as we might think. In the context of a worldwide industrial supplier of railway solutions, this work evaluates how the quality of TLR, BL, and FL is affected by the criteria for selecting engineers for collaboration. The criteria for collaboration are based on engineers’ profile information to select the set of search queries that are involved in the maintenance task. Collaboration is achieved by applying automatic query reformulation, and the location relies on an evolutionary algorithm. Our work uncovers how software engineers who might be seen as not being relevant in the collaboration can lead to significantly better results. A focus group confirmed the relevance of the findings.

Spatial cognition and program development have both been examined using contrasting models. We suggest that sex-based differences in one's perception of risk is the key to relating these models. Specifically, the survey map approach to navigation and the top-down development/comprehension strategy use similar and related high risk cognitive skills that males show a preference towards. Conversely, the route-based approach to navigation and the bottom-up development/comprehension strategy use similar and related low risk cognitive skills that women show a preference towards. On the assumption that programmers are consistent in their risk-taking behaviours, we believe that they, as much as possible, tend to use the same strategy when performing program development and comprehension. In an experimental setting, we compare programmer's performance on spatial cognition and program comprehension tasks. The correlations that we found suggest that programmers use equivalently risky strategies for program comprehension and spatial cognition. Thus, there is evidence that similar cognitive skills are used for spatial cognition and program comprehension/development, and that the similarities are a consequence of sex-based differences in risk-taking behaviour

Software maintainers are often challenged with source code changes to improve software systems, or eliminate defects, in unfamiliar programs. To undertake these tasks a sufficient understanding of the system (or at least a small part of it) is required. One of the most time consuming tasks of this process is locating which parts of the code are responsible for some key functionality or feature. Feature (or concept) location techniques address this problem. This paper introduces Conclave, an environment for software analysis, and in particular the Conclave-Mapper tool that provides a feature location facility. This tool explores natural language terms used in programs (e.g. function and variable names), and using textual analysis and a collection of Natural Language Processing techniques, computes synonymous sets of terms. These sets are used to score relatedness between program elements, and search queries or problem domain concepts, producing sorted ranks of program elements that address the search criteria, or concepts. An empirical study is also discussed to evaluate the underlying feature location technique.

The literature reports that source code lexicon plays a paramount role in program comprehension, especially when software documentation is scarce, outdated or simply not available. In source code, a significant proportion of vocabulary can be either acronyms and-or abbreviations or concatenation of terms that can not be identified using consistent mechanisms such as naming conventions. It is, therefore, essential to disambiguate concepts conveyed by identifiers to support program comprehension and reap the full benefit of Information Retrieval-based techniques (e.g., feature location and traceability) whose linguistic information (i.e., source code identifiers and comments) used across all software artifacts (e.g., requirements, design, change requests, tests, and source code) must be consistent. To this aim, we propose source code vocabulary normalization approaches that exploit contextual information to align the vocabulary found in the source code with that found in other software artifacts. We were inspired in the choice of context levels by prior works and by our findings. Normalization consists of two tasks: splitting and expansion of source code identifiers. We also investigate the effect of source code vocabulary normalization approaches on software maintenance tasks. Results of our evaluation show that our contextual-aware techniques are accurate and efficient in terms of computation time than state of the art alternatives. In addition, our findings reveal that feature location techniques can benefit from vocabulary normalization approaches when no dynamic information is available.

Buffer overflow (BOF) vulnerabilities when present in code can be exploited to violate security objectives such as availability, confidentiality and integrity. They make up substantial portion of input manipulation attacks due to their common presence and ease of exploitation. In this study, the authors propose a hybrid approach combining static and dynamic program analysis with machine learning to audit BOFs. Simple rules to generate test data is proposed to confirm some of the vulnerabilities through dynamic analysis. Confirmed cases can be fixed by developers without further verification. Statements whose vulnerability is not confirmed by dynamic analysis are predicted by mining static code attributes. In the authors’ evaluation using standard benchmarks, their best classifier achieved a recall over 93% and accuracy >94%. Dynamic analysis itself confirmed 34% of known vulnerabilities along with reporting six new bugs, thereby reducing by third, otherwise needed manual auditing effort.

Concurrency programs are hard to test or debug due to their non-deterministic nature. Existing dynamic program analysis approaches tried to address this by carefully examine a recorded execution trace. However, developing such analysis tools is complicated, requiring to take care of many tedious implementation details, and comparing and evaluating different analysis approaches are also subject to various biases, due to lack of a common base platform. This motivates us to design DPAC, an infrastructure that support in building dynamic program analysis tools for concurrency Java programs. DPAC takes events and their various processing mechanisms as its underlying model to facilitate monitoring and manipulation of program executions as required by dynamic program analysis. Various analysis tools can be implemented by customizing their required event types and processing mechanisms. We show two concrete case studies how our DPAC helps building existing dynamic program analysis approaches, as well as tuning subtle implementation details for supporting customized function implementation and code transformation.

Correlational studies have suggested some harmful effects of television viewing in early childhood, especially for the viewing of fast-paced entertainment programs. However, this has not been consistently supported by experimental studies, many of which have lacked ecological validity. The current study explores the effects of pace of program on the attention, problem solving and comprehension of 41 3- and 4-year-olds using an ecologically valid experimental design. Children were visited twice at home; on each visit they were shown an episode of a popular animated entertainment program which differed in pace: one faster paced, one slower paced. Children’s behavior was coded for attention and arousal during viewing, attention, and effort on a problem-solving task after viewing, and performance on unrelated (problem-solving) and related (program comprehension) tasks. The faster-paced program was attended to more, while 3-year-olds showed more attention and effort on the problem-solving task after watching the slower program, but there were no significant differences in performance on unrelated or related tasks depending on pace. The lack of differences observed in this naturalistic setting together with the high levels of comprehension of the programs watched provides some evidence to counter the “harm” perceived in young children watching fast-paced entertainment programs.

Visualizing object interactions in an execution trace with a sequence diagram is a promising technique for helping developers to comprehend effectively the behavior of an object-oriented system. However, in most cases, the reverse-engineered sequence diagram, which is automatically generated from an execution trace, contains enormous amounts of information, which causes scalability issues. In this paper, we present a method that abstracts the history of object interactions based on Pree's meta patterns usage. We identify objects that are strongly related to each other by focusing on the relation of template-hook structures which are often used in object-oriented programming. Grouping the strongly correlated objects, we visualize the system's behavior in terms of intergroup interactions with a sequence diagram. The sequence diagram that is generated is helpful for grasping the big picture of the overall behavior of the system, and so is a valuable aid for program comprehension. In this research, we implemented a tool to visualize the history of object interactions based on our proposed method and demonstrated the feasibility of our proposed method. We applied the tool to three kinds of open-source software systems and evaluated the effectiveness of our proposed method in program comprehension tasks.

To support program comprehension, software artifacts can be labeled--for example within software visualization tools--with a set of representative words, hereby referred to as labels. Such labels can be obtained using various approaches, including Information Retrieval (IR) methods or other simple heuristics. They provide a bird-eye's view of the source code, allowing developers to look over software components fast and make more informed decisions on which parts of the source code they need to analyze in detail. However, few empirical studies have been conducted to verify whether the extracted labels make sense to software developers. This paper investigates (i) to what extent various IR techniques and other simple heuristics overlap with (and differ from) labeling performed by humans; (ii) what kinds of source code terms do humans use when labeling software artifacts; and (iii) what factors--in particular what characteristics of the artifacts to be labeled--influence the performance of automatic labeling techniques. We conducted two experiments in which we asked a group of students (38 in total) to label 20 classes from two Java software systems, JHotDraw and eXVantage. Then, we analyzed to what extent the words identified with an automated technique--including Vector Space Models, Latent Semantic Indexing (LSI), latent Dirichlet allocation (LDA), as well as customized heuristics extracting words from specific source code elements--overlap with those identified by humans. Results indicate that, in most cases, simpler automatic labeling techniques--based on the use of words extracted from class and method names as well as from class comments--better reflect human-based labeling. Indeed, clustering-based approaches (LSI and LDA) are more worthwhile to be used for source code artifacts having a high verbosity, as well as for artifacts requiring more effort to be manually labeled. The obtained results help to define guidelines on how to build effective automatic labeling techniques, and provide some insights on the actual usefulness of automatic labeling techniques during program comprehension tasks.

Software companies need to provide a large set of features satisfying functional and non-functional requirements of diverse customers, thereby leading to variability in space. Feature location techniques have been proposed to support software maintenance and evolution in space. However, so far only one feature location technique also analyses the evolution in time of system variants, which is required for feature enhancements and bug fixing. Specifically, existing tools for managing a set of systems over time do not offer proper support for keeping track of feature revisions, updating existing variants, and creating new product configurations based on feature revisions. This paper presents four challenges concerning such capabilities for feature (revision) location and composition of new product configurations based on feature/s (revisions). We also provide a benchmark containing a ground truth and support for computing metrics. We hope that this will motivate researchers to provide and evaluate tool-supported approaches aiming at managing systems evolving in space and time. Further, we do not limit the evaluation of techniques to only this benchmark: we introduce and provide instructions on how to use a benchmark extractor for generating ground truth data for other systems. We expect that the feature (revision) location techniques maximize information retrieval in terms of precision, recall, and F-score, while keeping execution time and memory consumption low.