Jairo Aponte

On the Use of Automated Text Summarization Techniques for Summarizing Source Code

During maintenance developers cannot read the entire code of large systems. They need a way to get a quick understanding of source code entities (such as, classes, methods, packages, etc.), so they can efficiently identify and then focus on the ones related to their task at hand. Sometimes reading just a method header or a class name does not tell enough about its purpose and meaning, while reading the entire implementation takes too long. We study a solution which mitigates the two approaches, i.e., short and accurate textual descriptions that illustrate the software entities without having to read the details of the implementation. We create such descriptions using techniques from automatic text summarization. The paper presents a study that investigates the suitability of various such techniques for generating source code summaries. The results indicate that a combination of text summarization techniques is most appropriate for source code summarization and that developers generally agree with the summaries produced.

Supporting program comprehension with source code summarization

One of the main challenges faced by todays 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.

Automatic generation of natural language summaries for Java classes

Most software engineering tasks require developers to understand parts of the source code. When faced with unfamiliar code, developers often rely on (internal or external) documentation to gain an overall understanding of the code and determine whether it is relevant for the current task. Unfortunately, the documentation is often absent or outdated. This paper presents a technique to automatically generate human readable summaries for Java classes, assuming no documentation exists. The summaries allow developers to understand the main goal and structure of the class. The focus of the summaries is on the content and responsibilities of the classes, rather than their relationships with other classes. The summarization tool determines the class and method stereotypes and uses them, in conjunction with heuristics, to select the information to be included in the summaries. Then it generates the summaries using existing lexicalization tools. A group of programmers judged a set of generated summaries for Java classes and determined that they are readable and understandable, they do not include extraneous information, and, in most cases, they are not missing essential information.

Mining source code descriptions from developer communications

Very often, source code lacks comments that adequately describe its behavior. In such situations developers need to infer knowledge from the source code itself or to search for source code descriptions in external artifacts. We argue that messages exchanged among contributors/developers, in the form of bug reports and emails, are a useful source of information to help understanding source code. However, such communications are unstructured and usually not explicitly meant to describe specific parts of the source code. Developers searching for code descriptions within communications face the challenge of filtering large amount of data to extract what pieces of information are important to them. We propose an approach to automatically extract method descriptions from communications in bug tracking systems and mailing lists. We have evaluated the approach on bug reports and mailing lists from two open source systems (Lucene and Eclipse). The results indicate that mailing lists and bug reports contain relevant descriptions of about 36% of the methods from Lucene and 7% from Eclipse, and that the proposed approach is able to extract such descriptions with a precision of up to 79% for Eclipse and 87% for Lucene. The extracted method descriptions can help developers in understanding the code and could also be used as a starting point for source code re-documentation.

On Automatically Generating Commit Messages via Summarization of Source Code Changes

Although version control systems allow developers to describe and explain the rationale behind code changes in commit messages, the state of practice indicates that most of the time such commit messages are either very short or even empty. In fact, in a recent study of 23K+ Java projects it has been found that only 10% of the messages are descriptive and over 66% of those messages contained fewer words as compared to a typical English sentence (i.e., 15-20 words). However, accurate and complete commit messages summarizing software changes are important to support a number of development and maintenance tasks. In this paper we present an approach, coined as Change Scribe, which is designed to generate commit messages automatically from change sets. Change Scribe generates natural language commit messages by taking into account commit stereotype, the type of changes (e.g., files rename, changes done only to property files), as well as the impact set of the underlying changes. We evaluated Change Scribe in a survey involving 23 developers in which the participants analyzed automatically generated commit messages from real changes and compared them with commit messages written by the original developers of six open source systems. The results demonstrate that automatically generated messages by Change Scribe are preferred in about 62% of the cases for large commits, and about 54% for small commits.

ChangeScribe: a tool for automatically generating commit messages

During software maintenances tasks, commit messages are an important source of information, knowledge, and documentation that developers rely upon. However, the number and nature of daily activities and interruptions can influence the quality of resulting commit messages. This formal demonstration paper presents ChangeScribe, a tool for automatically generating commit messages. ChangeScribe is available at http://www.cs.wm.edu/semeru/changescribe (Eclipse plugin, instructions, demos and the source code).

Improving traceability link recovery methods through software artifact summarization

Analyzing candidate traceability links is a difficult, time consuming and error prone task, as it usually requires a detailed study of a long list of software artifacts of various kinds. One option to alleviate this problem is to select the most important features of the software artifacts that the developers would investigate. We discuss in this position paper how text summarization techniques could be used to address this problem. The potential gains in using summaries are both in terms of time and correctness of the traceability link recovery process.

Towards the Automatic Extraction of Structural Business Rules from Legacy Databases

One of the most important problems in the evolution of legacy systems is the loss of knowledge about them. In this paper, we present an approach for extracting structural business rules from legacy databases. We used the technique to recover business rules from SIFI (SIstema Fiduciario Integra do), an existing legacy system, implemented mostly in PL/SQL and Oracle Forms. Four employees of the company that know the system and its domain evaluated the extracted rules in order to assess the precision of the extraction technique. The results show that 29% of recovered rules are correct structural business rules, 36% correspond to implementation rules, and 35% are incomplete or incorrect rules. The recovery technique proves to be practical, while there is room for improvement, and it will be used as basis for the recovery of additional types of business rules.

Finding relationships between socio-technical aspects and personality traits by mining developer e-mails

Personality traits influence most, if not all, of the human activities, from those as natural as the way people walk, talk, dress and write to those most complex as the way they interact with others. Most importantly, personality influences the way people make decisions including, in the case of developers, the criteria they consider when selecting a software project they want to participate. Most of the works that study the influence of social, technical and human factors in software development projects have been focused on the impact of communications in software quality. For instance, on identifying predictors to detect files that may contain bugs before releasing an enhanced version of a software product. Only a few of these works focus on the analysis of personality traits of developers with commit permissions (committers) in Free/Libre and Open-Source Software projects and their relationship with the software artifacts they interact with. This paper presents an approach, based on the automatic recognition of personality traits from e-mails sent by committers in FLOSS projects, to uncover relationships between the social and technical aspects that occur during the software development process. Our experimental results suggest the existence of some relationships among personality traits projected by the committers through their e-mails and the social (communication) and technical activities they undertake. This work is a preliminary study aimed at supporting the setting up of efficient work teams in software development projects based on an appropriate mix of stakeholders taking into account their personality traits.

Efficacy of a computer-based cognitive training program in older people with subjective memory complaints: A randomized study

ABSTRACT Objective: the aim of this study was to investigate the effect of computer-assisted cognitive training in healthy older adults with subjective memory complaints. Methods: Forty older adults, mean age (standard deviation) = 66.4 (5.6) with subjective memory complaints, were included in this study. Participants were randomly assigned to an integrated psychostimulation program (IPP) (N = 17), a computerized cognitive training (CCT) (N = 12) or a control group (N = 11). The training was applied for 8 weeks (90 min/d, 4 d/week for IPP, and 60 min/d, 4 d/week for CCT). Effectiveness was evaluated with a neuropsychological assessment battery, used before and after the implementation of the cognitive training. Results: According to the data analysis, with analysis of covariance (ANCOVA), we found a statistically significant change in the majority of the cognitive variables measured before and after the experimental conditions compared with the control group. Although, according to a paired t-test, the IPP was more effective in the improvement of cognitive functioning in the participants. Additionally, a decrease in anxiety symptoms was observed after the cognitive intervention in IPP and CCT conditions. Conclusion: Our findings suggested that cognitive training of moderate intensity, supported by a web platform, could lead to significant improvements in cognitive and psychological well-being in older people with subjective memory complaints.