3 research outputs found
Enhancing API Documentation through BERTopic Modeling and Summarization
As the amount of textual data in various fields, including software
development, continues to grow, there is a pressing demand for efficient and
effective extraction and presentation of meaningful insights. This paper
presents a unique approach to address this need, focusing on the complexities
of interpreting Application Programming Interface (API) documentation. While
official API documentation serves as a primary source of information for
developers, it can often be extensive and lacks user-friendliness. In light of
this, developers frequently resort to unofficial sources like Stack Overflow
and GitHub. Our novel approach employs the strengths of BERTopic for topic
modeling and Natural Language Processing (NLP) to automatically generate
summaries of API documentation, thereby creating a more efficient method for
developers to extract the information they need. The produced summaries and
topics are evaluated based on their performance, coherence, and
interoperability.
The findings of this research contribute to the field of API documentation
analysis by providing insights into recurring topics, identifying common
issues, and generating potential solutions. By improving the accessibility and
efficiency of API documentation comprehension, our work aims to enhance the
software development process and empower developers with practical tools for
navigating complex APIs
Leveraging Deep Learning for Abstractive Code Summarization of Unofficial Documentation
Usually, programming languages have official documentation to guide
developers with APIs, methods, and classes. However, researchers identified
insufficient or inadequate documentation examples and flaws with the API's
complex structure as barriers to learning an API. As a result, developers may
consult other sources (StackOverflow, GitHub, etc.) to learn more about an API.
Recent research studies have shown that unofficial documentation is a valuable
source of information for generating code summaries. We, therefore, have been
motivated to leverage such a type of documentation along with deep learning
techniques towards generating high-quality summaries for APIs discussed in
informal documentation. This paper proposes an automatic approach using the
BART algorithm, a state-of-the-art transformer model, to generate summaries for
APIs discussed in StackOverflow. We built an oracle of human-generated
summaries to evaluate our approach against it using ROUGE and BLEU metrics
which are the most widely used evaluation metrics in text summarization.
Furthermore, we evaluated our summaries empirically against a previous work in
terms of quality. Our findings demonstrate that using deep learning algorithms
can improve summaries' quality and outperform the previous work by an average
of %57 for Precision, %66 for Recall, and %61 for F-measure, and it runs 4.4
times faster
Improving Code Example Recommendations on Informal Documentation Using BERT and Query-Aware LSH: A Comparative Study
Our research investigates the recommendation of code examples to aid software
developers, a practice that saves developers significant time by providing
ready-to-use code snippets. The focus of our study is Stack Overflow, a
commonly used resource for coding discussions and solutions, particularly in
the context of the Java programming language.
We applied BERT, a powerful Large Language Model (LLM) that enables us to
transform code examples into numerical vectors by extracting their semantic
information. Once these numerical representations are prepared, we identify
Approximate Nearest Neighbors (ANN) using Locality-Sensitive Hashing (LSH). Our
research employed two variants of LSH: Random Hyperplane-based LSH and
Query-Aware LSH. We rigorously compared these two approaches across four
parameters: HitRate, Mean Reciprocal Rank (MRR), Average Execution Time, and
Relevance.
Our study revealed that the Query-Aware (QA) approach showed superior
performance over the Random Hyperplane-based (RH) method. Specifically, it
exhibited a notable improvement of 20% to 35% in HitRate for query pairs
compared to the RH approach. Furthermore, the QA approach proved significantly
more time-efficient, with its speed in creating hashing tables and assigning
data samples to buckets being at least four times faster. It can return code
examples within milliseconds, whereas the RH approach typically requires
several seconds to recommend code examples. Due to the superior performance of
the QA approach, we tested it against PostFinder and FaCoY, the
state-of-the-art baselines. Our QA method showed comparable efficiency proving
its potential for effective code recommendation