Analyzing APIs Documentation and Code to Detect Directive Defects

Zhou, Yu; Gu, Ruihang; Chen, Taolue; Huang, Zhiqiu; Panichella, Sebastiano; Gall, Harald C.

doi:10.1109/icse.2017.11

Cited by 99 publications

(66 citation statements)

References 39 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Chaparro et al [11] defined 154 recurrent patterns to describe observed behavior (OB), expected behavior (EB) and step to reproduce (S2R) in bug descriptions with the aim of detecting the presence (or absence) of these pieces of information in such kind of artifacts (i.e., bug descriptions). Zhou et al [45], [46] employed specific linguistic patterns for automatically detecting inconsistencies between API documents and source code. Frequent grammatical patterns (i.e., dependencies in which either the governor or the dependent is a code-like term) along with structural features were also used by Petrosyan et al [36] to discover tutorial sections that explain a given API type.…”

Section: Related Workmentioning

confidence: 99%

Exploiting Natural Language Structures in Software Informal Documentation

Sorbo

Panichella

Visaggio

et al. 2021

IIEEE Trans. Software Eng.

Self Cite

View full text Add to dashboard Cite

Communication means, such as issue trackers, mailing lists, Q&A forums, and app reviews, are premier means of collaboration among developers, and between developers and end-users. Analyzing such sources of information is crucial to build recommenders for developers, for example suggesting experts, re-documenting source code, or transforming user feedback in maintenance and evolution strategies for developers. To ease this analysis, in previous work we proposed DECA (Development Emails Content Analyzer), a tool based on Natural Language Parsing that classifies with high precision development emails' fragments according to their purpose. However, DECA has to be trained through a manual tagging of relevant patterns, which is often effort-intensive, error-prone and requires specific expertise in natural language parsing. In this paper, we first show, with a study involving Master's and Ph.D. students, the extent to which producing rules for identifying such patterns requires effort, depending on the nature and complexity of patterns. Then, we propose an approach, named NEON (Nlp-based softwarE dOcumentation aNalyzer), that automatically mines such rules, minimizing the manual effort. We assess the performances of NEON in the analysis and classification of mobile app reviews, developers discussions, and issues. NEON simplifies the patterns' identification and rules' definition processes, allowing a savings of more than 70% of the time otherwise spent on performing such activities manually. Results also show that NEON-generated rules are close to the manually identified ones, achieving comparable recall.

show abstract

Section: Related Workmentioning

confidence: 99%

Exploiting Natural Language Structures in Software Informal Documentation

Sorbo

Panichella

Visaggio

et al. 2021

IIEEE Trans. Software Eng.

Self Cite

View full text Add to dashboard Cite

show abstract

“…It tries to obtain enough collocations between each word/API and other APIs/words. 9. Default English stop words.…”

Section: Training Set Creationmentioning

confidence: 99%

Bridging Semantic Gaps between Natural Languages and APIs with Word Embedding

Jiang

Kamei

et al. 2020

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

Developers increasingly rely on text matching tools to analyze the relation between natural language words and APIs. However, semantic gaps, namely textual mismatches between words and APIs, negatively affect these tools. Previous studies have transformed words or APIs into low-dimensional vectors for matching; however, inaccurate results were obtained due to the failure of modeling words and APIs simultaneously. To resolve this problem, two main challenges are to be addressed: the acquisition of massive words and APIs for mining and the alignment of words and APIs for modeling. Therefore, this study proposes Word2API to effectively estimate relatedness of words and APIs. Word2API collects millions of commonly used words and APIs from code repositories to address the acquisition challenge. Then, a shuffling strategy is used to transform related words and APIs into tuples to address the alignment challenge. Using these tuples, Word2API models words and APIs simultaneously. Word2API outperforms baselines by 10%-49.6% of relatedness estimation in terms of precision and NDCG. Word2API is also effective on solving typical software tasks, e.g., query expansion and API documents linking. A simple system with Word2API-expanded queries recommends up to 21.4% more related APIs for developers. Meanwhile, Word2API improves comparison algorithms by 7.9%-17.4% in linking questions in Question&Answer communities to API documents.

show abstract

“…This approach is however constrained to Javadoc comments containing information about a method's parameters. Zhou et al devised an approach, similar to @TComment in terms of its application to method's parameter constraints and exception throwing declarations, that detects inconsistencies between API documentation and its source code by extracting documentation from Javadoc comments, analyzing documentation directives and performing a static analysis of the code of methods [61].…”

Section: Inconsistency Detectionmentioning

confidence: 99%

Detecting fragile comments

Ratol

Robillard

2017

2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)

View full text Add to dashboard Cite

The development lifecycle of a software system demands incessant improvements in the source code of a system to maintain its high quality with improved performance and code readability.Refactoring is a common software development practice that reshapes the internal structure and non-functional properties of a system without modifying its core functionality. Many simple refactorings like renaming code elements, extracting a snippet from large method to form new method etc. can be performed with the help of automatic tools. Renaming code elements like classes, interfaces or methods is a widely used refactoring activity. With tool support, rename refactorings can rely on the program structure to ensure correctness of the code transformation. Unfortunately, the textual references to the renamed identifier present in unstructured comment text cannot be formally detected through the syntax of the programming language. These textual references to the previous version of a renamed identifier pose threats to the consistency between code and comments, which leads to poor program comprehensibility. The comments containing such textual references become fragile with respect to the renamed program element and are referred to as fragile comments.This thesis proposes a new rule-based approach to detect and fix the fragile comments that result from renaming the identifiers. We implemented this approach for the Java programming language in the form of an Eclipse plug-in called Fraco. Fraco takes into account the type of an identifier, its morphology i.e. the part-of-speech tag and its inflectional form, its scope that defines its visibility in the source code and the location of comments in the source code with respect to the identifier.i We evaluated the performance of our technique, as implemented for Java in Fraco, by comparing its precision and recall against hand-annotated benchmarks created for both development and test sets each containing six target Java systems, and also compared the results against the performance of Eclipse's automated in-comment identifier replacement feature. Fraco performed with an average of 99% precision and recall on most components of both development and test data sets, and generally outperformed the baseline Eclipse feature. An average percentage of 25% of the total identifiers of category type and method in the data sets had fragile comments after renaming, which further motivates the need for research on automatic comment refactoring. ACKNOWLEDGMENTSThe completion of this thesis has been a great learning journey which has left me indebted to many people who have supported, contributed and guided me, many a times, by going out of their way in doing so.First and foremost, I would like to thank my supervisor Prof. Martin P. Robillard for his unconditional support, methodical guidance and utmost care towards the ideation, development and completion of this thesis. Being confidently able to finish this thesis, I respect and admire his patience in successfully training and repeatedly enc...

show abstract

Analyzing APIs Documentation and Code to Detect Directive Defects

Cited by 99 publications

References 39 publications

Exploiting Natural Language Structures in Software Informal Documentation

Exploiting Natural Language Structures in Software Informal Documentation

Bridging Semantic Gaps between Natural Languages and APIs with Word Embedding

Detecting fragile comments

Contact Info

Product

Resources

About