31,435 research outputs found
A Deep Learning approach to predict software bugs using micro patterns and software metrics
Software bugs prediction is one of the most active research areas in the software engineering community. The process of testing and debugging code proves to be costly during the software development life cycle. Software metrics measure the quality of source code to identify software bugs and vulnerabilities. Traceable code patterns are able to de- scribe code at a finer granularity level to measure quality. Micro patterns will be used in this research to mechanically describe java code at the class level. Machine learning has also been introduced for bug prediction to localize source code for testing and debugging. Deep Learning is a branch of Machine Learning that is relatively new. This research looks to improve the prediction of software bugs by utilizing micro patterns with deep learning techniques. Software bug prediction at a finer granularity level will enable developers to localize code to test and debug during the development process
Automatically Extracting Instances of Code Change Patterns with AST Analysis
A code change pattern represents a kind of recurrent modification in
software. For instance, a known code change pattern consists of the change of
the conditional expression of an if statement. Previous work has identified
different change patterns. Complementary to the identification and definition
of change patterns, the automatic extraction of pattern instances is essential
to measure their empirical importance. For example, it enables one to count and
compare the number of conditional expression changes in the history of
different projects. In this paper we present a novel approach for search
patterns instances from software history. Our technique is based on the
analysis of Abstract Syntax Trees (AST) files within a given commit. We
validate our approach by counting instances of 18 change patterns in 6
open-source Java projects.Comment: ICSM - 29th IEEE International Conference on Software Maintenance
(2013
Decrypting The Java Gene Pool: Predicting Objects' Lifetimes with Micro-patterns
Pretenuring long-lived and immortal objects into infrequently or never collected regions reduces garbage collection costs significantly. However, extant approaches either require computationally expensive, application-specific, off-line profiling, or consider only allocation sites common to all programs, i.e. invoked by the virtual machine rather than application programs. In contrast, we show how a simple program analysis, combined with an object lifetime knowledge bank, can be exploited to match both runtime system and application program structure with object lifetimes. The complexity of the analysis is linear in the size of the program, so need not be run ahead of time. We obtain performance gains between 6-77% in GC time against a generational copying collector for several SPEC jvm98 programs
Invertible Program Restructurings for Continuing Modular Maintenance
When one chooses a main axis of structural decompostion for a software, such
as function- or data-oriented decompositions, the other axes become secondary,
which can be harmful when one of these secondary axes becomes of main
importance. This is called the tyranny of the dominant decomposition. In the
context of modular extension, this problem is known as the Expression Problem
and has found many solutions, but few solutions have been proposed in a larger
context of modular maintenance. We solve the tyranny of the dominant
decomposition in maintenance with invertible program transformations. We
illustrate this on the typical Expression Problem example. We also report our
experiments with Java and Haskell programs and discuss the open problems with
our approach.Comment: 6 pages, Early Research Achievements Track; 16th European Conference
on Software Maintenance and Reengineering (CSMR 2012), Szeged : Hungary
(2012
Implementing a map based simulator for the location API for J2ME
The Java Location API for J2METM integrates generic positioning and orientation data with
persistent storage of landmark objects. It can be used to develop location based service
applications for small mobile devices, and these applications can be tested using simulation
environments. Currently the only simulation tools in the public domain are proprietary
mobile device simulators that are driven by GPS data log files, but it is sometimes useful to
be able to test location based services using interactive map-based tools. In addition, we
may need to experiment with extensions and changes to the standard API to support
additional services, requiring an open source environment. In this paper we describe the
implementation of an open source map-based simulation tool compatible with other
commonly used development and deployment tools
Opportunities for a Truffle-based Golo Interpreter
Golo is a simple dynamically-typed language for the Java Virtual Machine.
Initially implemented as a ahead-of-time compiler to JVM bytecode, it leverages
invokedy-namic and JSR 292 method handles to implement a reasonably efficient
runtime. Truffle is emerging as a framework for building interpreters for JVM
languages with self-specializing AST nodes. Combined with the Graal compiler,
Truffle offers a simple path towards writing efficient interpreters while
keeping the engineering efforts balanced. The Golo project is interested in
experimenting with a Truffle interpreter in the future, as it would provides
interesting comparison elements between invokedynamic versus Truffle for
building a language runtime
- âŠ