Java Core API Migration: Challenges and Techniques

Automatic Control and Computer Sciences, 2018

The development of a procedure supporting automated migration of Java programs to a new set of libraries is explored. Code migration is a common task in modern software projects. For example, it may arise when a project must be ported to a more secure or feature-rich library, a new platform, or a new version of an existing library. This paper presents a procedure for semantics-driven automated migration. A metamodel that applies the formalism earlier proposed by the authors and intended to describe libraries in object-oriented languages was developed for the migration procedure. The formalism specifies a library behaviour by using a system of extended finite state machines (EFSMs). The migration is split into five steps and each step is described in the paper. The procedure applies an algorithm of an equivalent path based on a breadth-first search extended for the needs of the migration task. The proposed procedure is implemented in a prototype of the migration tool. The tool includes modules for extraction of the software execution path, visualization of library models, user interaction, and migration. A library description language was developed for the tool. The prototype was tested by both artificial code and a real-world open source project. The article describes the experiments performed, the difficulties that have arisen in the process of migration of test samples, and how they are solved in the proposed procedure. The HTTP protocol and log library are used as libraries in the experiment. The results of the experiments indicate that code migration can be successfully automated through the developed procedures.

2019 IEEE International Conference on Software Maintenance and Evolution (ICSME), 2019

In this paper we introduce, MigrationMiner, an automated tool that detects code migrations performed between Java third-party library. Given a list of open source projects, the tool detects potential library migration code changes and collects the specific code fragments in which the developer replaces methods from the retired library with methods from the new library. To support the migration process, MigrationMiner collects the library documentation that is associated with every method involved in the migration. We evaluate our tool on a benchmark of manually validated library migrations. Results show that MigrationMiner achieves an accuracy of 100%. A demo video of Migration-Miner is available at https://youtu.be/sAlR1HNetXc.

2001

This paper proposes a system named Addistant, which enables the distributed execution of “legacy” Java bytecode. Here “legacy” means the software originally developed to be executed on a single Java virtual machine (JVM). For adapting legacy software to distributed execution on multiple JVM, developers using Addistant have only to specify the host where instances of each class are allocated and how remote references are implemented. According to that specification, Addistant automatically transforms the bytecode at load time. A technical contribution by Addistant is that it covers a number of issues for implementing distributed execution in the real world. In fact, Addistant can adapt a legacy program written with the Swing library so that Swing objects are executed on a local JVM while the rest of objects are on a remote JVM.

2006

We present an overview of JTL (the Java Tools Language, pronounced "Gee-tel"), a novel language for querying JAVA [8] programs. JTL was designed to serve the development of source code software tools for JAVA, and as a small language to aid programming language extensions to JAVA. Applications include definition of pointcuts for aspect-oriented programming, fixing type constraints for generic programming, specification of encapsulation policies, definition of micro-patterns, etc. We argue that the JTL expression of each of these is systematic, concise, intuitive and general.

Lecture Notes in Computer Science, 2005

Java 1.5 generics enable the creation of reusable container classes with compiler-enforced type-safe usage. This eliminates the need for potentially unsafe down-casts when retrieving elements from containers. We present a refactoring that replaces raw references to generic library classes with parameterized references. The refactoring infers actual type parameters for allocation sites and declarations using an existing framework of type constraints, and removes casts that have been rendered redundant. The refactoring was implemented in Eclipse, a popular open-source development environment for Java, and laid the grounds for a similar refactoring in the forthcoming Eclipse 3.1 release. We evaluated our work by refactoring several Java programs that use the standard collections framework to use Java 1.5's generic version instead. In these benchmarks, on average, 48.6% of the casts are removed, and 91.2% of the compiler warnings related to the use of raw types are eliminated. Our approach distinguishes itself from the state-of-the-art [8] by being more scalable, by its ability to accommodate user-defined subtypes of generic library classes, and by being incorporated in a popular integrated development environment.

2011

Evolutionary changes in object-oriented systems can result in large, complex classes, known as "God Classes". In this paper, we present a tool, developed as part of the JDeodorant Eclipse plugin, that can recognize opportunities for extracting cohesive classes from "God Classes" and automatically apply the refactoring chosen by the developer.

2006

The reverse inheritance class relationship has several potential uses. It can be exploited as a mechanism integrated in one of the object-oriented programming languages or as a mean for reengineering class hierarchies in order to obtain locally adapted software releases. The limited local adaptations and restricted enhancements can be encapsulated in the superclass of the reverse inheritance class relationship and using a software tool they can be applied automatically to each software release. The implementation of the software tool works on Java class hierarchies.

Science of Computer Programming, 2008

The Java TM programming language is primarily used for platform-independent programming. Yet it also offers many productivity, maintainability and performance benefits for platform-specific functions, such as the generation of machine code.

2003

As Java increases in popularity and maturity, many people find it desirable to convert legacy C++ or C programs to Java. Our hypothesis is that a tool which performs rigorous analysis on a C++ program, providing detailed output on the changes necessary, will make conversion a much more efficient and reliable process. MoHCA-J&a is such a tool. It performs detailed analysis on a C++ abstract syntax tree; the parameters of the analysis can be specified and extended very quickly and easily using a rule-based language. We have found that MoHCA-Java is very useful for identifying and implementing source code changes, and that its extensibility is a very important factor, specially to adapt the tool to assist in the conversion of C++ code that makes extensive use of libraries to Java code that uses similar libraries.

2010

Dynamic code evolution is a technique to update a program while it is running. In an object-oriented language such as Java, this can be seen as replacing a set of classes by new versions. We modified an existing high-performance virtual machine to allow arbitrary changes to the definition of loaded classes. Besides adding and deleting fields and methods, we also allow any kind of changes to the class and interface hierarchy. Our approach focuses on increasing developer productivity during debugging. Changes can be applied at any point a Java program can be suspended. The evaluation section shows that our modifications to the virtual machine have no negative performance impact on normal program execution. The fast in-place instance update algorithm ensures that the performance characteristics of a change are comparable with performing a full garbage collection run. Standard Java development environments are capable of using the code evolution features of our modified virtual machine, so no additional tools are required.