1,024 research outputs found
Building Program Vector Representations for Deep Learning
Deep learning has made significant breakthroughs in various fields of
artificial intelligence. Advantages of deep learning include the ability to
capture highly complicated features, weak involvement of human engineering,
etc. However, it is still virtually impossible to use deep learning to analyze
programs since deep architectures cannot be trained effectively with pure back
propagation. In this pioneering paper, we propose the "coding criterion" to
build program vector representations, which are the premise of deep learning
for program analysis. Our representation learning approach directly makes deep
learning a reality in this new field. We evaluate the learned vector
representations both qualitatively and quantitatively. We conclude, based on
the experiments, the coding criterion is successful in building program
representations. To evaluate whether deep learning is beneficial for program
analysis, we feed the representations to deep neural networks, and achieve
higher accuracy in the program classification task than "shallow" methods, such
as logistic regression and the support vector machine. This result confirms the
feasibility of deep learning to analyze programs. It also gives primary
evidence of its success in this new field. We believe deep learning will become
an outstanding technique for program analysis in the near future.Comment: This paper was submitted to ICSE'1
Identifying Components from Object-Oriented APIs Based on Dynamic Analysis
The reuse at the component level is generally more effective than the one at
the object-oriented class level. This is due to the granularity level where
components expose their functionalities at an abstract level compared to the
fine-grained object-oriented classes. Moreover, components clearly define their
dependencies through their provided and required interfaces in an explicit way
that facilitates the understanding of how to reuse these components. Therefore,
several component identification approaches have been proposed to identify
components based on the analysis object-oriented software applications.
Nevertheless, most of the existing component identification approaches did not
consider co-usage dependencies between API classes to identify classes/methods
that can be reused to implement a specific scenario. In this paper, we propose
an approach to identify reusable software components in object-oriented APIs,
based on the interactions between client applications and the targeted API. As
we are dealing with actual clients using the API, dynamic analysis allows to
better capture the instances of API usage. Approaches using static analysis are
usually limited by the difficulty of handling dynamic features such as
polymorphism and class loading. We evaluate our approach by applying it to
three Java APIs with eight client applications from the DaCapo benchmark.
DaCapo provides a set of pre-defined usage scenarios. The results show that our
component identification approach has a very high precision.Comment: 11 pages, 5 figure
- …