215 research outputs found
Enhancing Source Code Representations for Deep Learning with Static Analysis
Deep learning techniques applied to program analysis tasks such as code
classification, summarization, and bug detection have seen widespread interest.
Traditional approaches, however, treat programming source code as natural
language text, which may neglect significant structural or semantic details.
Additionally, most current methods of representing source code focus solely on
the code, without considering beneficial additional context. This paper
explores the integration of static analysis and additional context such as bug
reports and design patterns into source code representations for deep learning
models. We use the Abstract Syntax Tree-based Neural Network (ASTNN) method and
augment it with additional context information obtained from bug reports and
design patterns, creating an enriched source code representation that
significantly enhances the performance of common software engineering tasks
such as code classification and code clone detection. Utilizing existing
open-source code data, our approach improves the representation and processing
of source code, thereby improving task performance
DyPyBench: A Benchmark of Executable Python Software
Python has emerged as one of the most popular programming languages,
extensively utilized in domains such as machine learning, data analysis, and
web applications. Python's dynamic nature and extensive usage make it an
attractive candidate for dynamic program analysis. However, unlike for other
popular languages, there currently is no comprehensive benchmark suite of
executable Python projects, which hinders the development of dynamic analyses.
This work addresses this gap by presenting DyPyBench, the first benchmark of
Python projects that is large scale, diverse, ready to run (i.e., with fully
configured and prepared test suites), and ready to analyze (by integrating with
the DynaPyt dynamic analysis framework). The benchmark encompasses 50 popular
opensource projects from various application domains, with a total of 681k
lines of Python code, and 30k test cases. DyPyBench enables various
applications in testing and dynamic analysis, of which we explore three in this
work: (i) Gathering dynamic call graphs and empirically comparing them to
statically computed call graphs, which exposes and quantifies limitations of
existing call graph construction techniques for Python. (ii) Using DyPyBench to
build a training data set for LExecutor, a neural model that learns to predict
values that otherwise would be missing at runtime. (iii) Using dynamically
gathered execution traces to mine API usage specifications, which establishes a
baseline for future work on specification mining for Python. We envision
DyPyBench to provide a basis for other dynamic analyses and for studying the
runtime behavior of Python code
Opinion Mining for Software Development: A Systematic Literature Review
Opinion mining, sometimes referred to as sentiment analysis, has gained increasing attention in software engineering (SE) studies.
SE researchers have applied opinion mining techniques in various contexts, such as identifying developers’ emotions expressed in
code comments and extracting users’ critics toward mobile apps. Given the large amount of relevant studies available, it can take
considerable time for researchers and developers to figure out which approaches they can adopt in their own studies and what perils
these approaches entail.
We conducted a systematic literature review involving 185 papers. More specifically, we present 1) well-defined categories of opinion
mining-related software development activities, 2) available opinion mining approaches, whether they are evaluated when adopted in
other studies, and how their performance is compared, 3) available datasets for performance evaluation and tool customization, and 4)
concerns or limitations SE researchers might need to take into account when applying/customizing these opinion mining techniques.
The results of our study serve as references to choose suitable opinion mining tools for software development activities, and provide
critical insights for the further development of opinion mining techniques in the SE domain
API Usage Recommendation via Multi-View Heterogeneous Graph Representation Learning
Developers often need to decide which APIs to use for the functions being
implemented. With the ever-growing number of APIs and libraries, it becomes
increasingly difficult for developers to find appropriate APIs, indicating the
necessity of automatic API usage recommendation. Previous studies adopt
statistical models or collaborative filtering methods to mine the implicit API
usage patterns for recommendation. However, they rely on the occurrence
frequencies of APIs for mining usage patterns, thus prone to fail for the
low-frequency APIs. Besides, prior studies generally regard the API call
interaction graph as homogeneous graph, ignoring the rich information (e.g.,
edge types) in the structure graph. In this work, we propose a novel method
named MEGA for improving the recommendation accuracy especially for the
low-frequency APIs. Specifically, besides call interaction graph, MEGA
considers another two new heterogeneous graphs: global API co-occurrence graph
enriched with the API frequency information and hierarchical structure graph
enriched with the project component information. With the three multi-view
heterogeneous graphs, MEGA can capture the API usage patterns more accurately.
Experiments on three Java benchmark datasets demonstrate that MEGA
significantly outperforms the baseline models by at least 19% with respect to
the Success Rate@1 metric. Especially, for the low-frequency APIs, MEGA also
increases the baselines by at least 55% regarding the Success Rate@1
Predicting Software Performance with Divide-and-Learn
Predicting the performance of highly configurable software systems is the
foundation for performance testing and quality assurance. To that end, recent
work has been relying on machine/deep learning to model software performance.
However, a crucial yet unaddressed challenge is how to cater for the sparsity
inherited from the configuration landscape: the influence of configuration
options (features) and the distribution of data samples are highly sparse.
In this paper, we propose an approach based on the concept of
'divide-and-learn', dubbed . The basic idea is that, to handle sample
sparsity, we divide the samples from the configuration landscape into distant
divisions, for each of which we build a regularized Deep Neural Network as the
local model to deal with the feature sparsity. A newly given configuration
would then be assigned to the right model of division for the final prediction.
Experiment results from eight real-world systems and five sets of training
data reveal that, compared with the state-of-the-art approaches, performs
no worse than the best counterpart on 33 out of 40 cases (within which 26 cases
are significantly better) with up to improvement on accuracy;
requires fewer samples to reach the same/better accuracy; and producing
acceptable training overhead. Practically, also considerably improves
different global models when using them as the underlying local models, which
further strengthens its flexibility. To promote open science, all the data,
code, and supplementary figures of this work can be accessed at our repository:
https://github.com/ideas-labo/DaL.Comment: This paper has been accepted by The ACM Joint European Software
Engineering Conference and Symposium on the Foundations of Software
Engineering (ESEC/FSE), 202
Runtime Resolution of Feature Interactions through Adaptive Requirement Weakening
The feature interaction problem occurs when two or more independently
developed components interact with each other in unanticipated ways, resulting
in undesirable system behaviors. Feature interaction problems remain a
challenge for emerging domains in cyber-physical systems (CPS), such as the
Internet of Things and autonomous drones. Existing techniques for resolving
feature interactions take a "winner-takes-all" approach, where one out of the
conflicting features is selected as the most desirable one, and the rest are
disabled. However, when multiple of the conflicting features fulfill important
system requirements, being forced to select one of them can result in an
undesirable system outcome. In this paper, we propose a new resolution approach
that allows all of the conflicting features to continue to partially fulfill
their requirements during the resolution process. In particular, our approach
leverages the idea of adaptive requirement weakening, which involves one or
more features temporarily weakening their level of performance in order to
co-exist with the other features in a consistent manner. Given feature
requirements specified in Signal Temporal Logic (STL), we propose an automated
method and a runtime architecture for automatically weakening the requirements
to resolve a conflict. We demonstrate our approach through case studies on
feature interactions in autonomous drones.Comment: 10 pages, submitted to SEAMS conferenc
- …