Towards Improving Interface Modularity in Legacy Java Software through Automated Refactoring

The skeletal implementation pattern is a software design pattern consisting of defining an abstract class that provides a partial interface implementation. However, since Java allows only single class inheritance, if implementers decide to extend a skeletal implementation, they will not be allowed to extend any other class. Also, discovering the skeletal implementation may require a global analysis. Java 8 enhanced interfaces alleviate these problems by allowing interfaces to contain (default) method implementations, which implementers inherit. Java classes are then free to extend a different class, and a separate abstract class is no longer needed; developers considering implementing an interface need only examine the interface itself. We argue that both these benefits improve software modularity, and discuss our ongoing work in developing an automated refactoring tool that would assist developers in taking advantage of the enhanced interface feature for their legacy Java software

Structured Review of the Evidence for Effects of Code Duplication on Software Quality

This report presents the detailed steps and results of a structured review of code clone literature. The aim of the review is to investigate the evidence for the claim that code duplication has a negative effect on code changeability. This report contains only the details of the review for which there is not enough place to include them in the companion paper published at a conference (Hordijk, Ponisio et al. 2009 - Harmfulness of Code Duplication - A Structured Review of the Evidence)

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache

Experiences In Migrating An Industrial Application To Aspects

Aspect-Oriented Software Development (AOSD) is a paradigm aiming to solve problems of object-oriented programming (OOP). With normal OOP it’s often unlikely to accomplish fine system modularity due to crosscutting concerns being scattered and tangled throughout the system. AOSD resolves this problem by its capability to crosscut the regular code and as a consequence transfer the crosscutting concerns to a single model called aspect. This thesis describes an experiment on industrial application wherein the effectiveness of aspect-oriented techniques is explained in migration the OOP application into aspects. The experiment goals at first to identify the crosscutting concerns in source code of the industrial application and transform these concerns to a functionally equivalent aspect-oriented version. In addition to presenting experiences gained through the experiment, the thesis aims to provide practical guidance of aspect solutions in a real application

Barriers to Refactoring: Issues and Solutions

Refactoring mechanism is commonly used in software development. Though Object oriented programming promotes ease in designing reusable software but the long coded methods makes it unreadable and enhances the complexity of the methods. The common code defects are associated with large classes and methods. To ease up the code comprehension Extract method, Extract class serves as a comfortable option to reduce the disorganization and duplication of the code to produce more fine grained methods and classes. Though refactoring serves as an important mechanism to improve the software quality whether performed manually or in an automated way with the help of tools or IDEs but there are umpteen cases where refactoring could lead to deterrent effect. This paper intends to explore the various problems and barriers associated with refactoring and specifically while extracting the code (extract method, extract class, extract interface) and their solutions

A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw

Aspect oriented programming aims at achieving better modularization for a system's crosscutting concerns in order to improve its key quality attributes, such as evolvability and reusability. Consequently, the adoption of aspect-oriented techniques in existing (legacy) software systems is of interest to remediate software aging. The refactoring of existing systems to employ aspect-orientation will be considerably eased by a systematic approach that will ensure a safe and consistent migration. In this paper, we propose a refactoring and testing strategy that supports such an approach and consider issues of behavior conservation and (incremental) integration of the aspect-oriented solution with the original system. The strategy is applied to the JHotDraw open source project and illustrated on a group of selected concerns. Finally, we abstract from the case study and present a number of generic refactorings which contribute to an incremental aspect-oriented refactoring process and associate particular types of crosscutting concerns to the model and features of the employed aspect language. The contributions of this paper are both in the area of supporting migration towards aspect-oriented solutions and supporting the development of aspect languages that are better suited for such migrations.Comment: 25 page

The Impact Of Design Patterns In Refactoring Technique To Measure Performance Efficiency

Designing and developing software application has never been an easy task. The process is often time consuming and requires interaction between several different aspects. It will be harder in re-engineering the legacy system through refactoring technique, especially when consider to achieve software standard quality. Performance is one of the essential a quality attribute of software quality. Many studies in the literature have premise that design patterns improve the quality of object-oriented software systems but some studies suggest that the use of design patterns do not always result in appropriate designs. There are remaining question issues on negative or positive impacts of pattern refactoring in performance. In practice, refactoring in any part or structure of the system may take effect to another related part or structure. Effect of the process using refactoring technique and design patterns may improve software quality by making it more performable efficiency. Considerable research has been devoted in re-designing the system to improve software quality as maintainability and reliability. Less attention has been paid in measuring impact of performance efficiency quality factor. The main idea of this thesis is to investigate the impact, demonstrate how design patterns can be used to refactor the legacy software application in term of performance efficiency. It is therefore beneficial to investigate whether design patterns may influence performance of applications. In the thesis, an enterprise project named SIA (Sistem Informasi Akademik) is designed by applying Java EE platform. Some issues related to design patterns are addressed. The selection of design pattern is based on the application context issue. There are three kind of parameters measure, time behavior, resource utilization and capacity measures that based on standard guideline. We use tools support in experimentation as Apache JMeter and Java Mission Control. These tools provide convenient and generate appropriate result of performance measurement. The experiment results shown that the comparison between the legacy and refactored system that implemented design pattern indicates influence on application quality, especially on performance efficiency. ================================================================================================== Merancang dan mengembangkan aplikasi perangkat lunak bukan merupakan pekerjaan yang mudah karena membutuhkan waktu dan interaksi antara beberapa aspek. Proses desain pada rekayasa ulang akan lebih sulit meskipun melalui teknik refactoring, terutama untuk mencapai standar kualitas perangkat lunak. Kinerja merupakan salah satu atribut terpenting kualitas perangkat lunak. Banyak penelitian menjelaskan pola desain memperbaiki kualitas sistem perangkat lunak berorientasi objek, namun beberapa penelitian juga menunjukkan bahwa penggunaan pola desain tidak selalu menghasilkan desain yang sesuai. Masih ada pertanyaan tentang dampak negatif atau positif dari kinerja pola refactoring. Pada praktiknya, melakukan refactoring pada suatu bagian atau struktur sistem akan berpengaruh pada bagian atau struktur lain yang terkait. Penggunaan teknik refactoring dan pola desain dapat meningkatkan kualitas perangkat lunak dengan kinerja lebih efisien. Sudah banyak penelitian yang berfokus untuk merancang ulang sistem untuk meningkatkan kualitas perangkat lunak sebagai kemampuan rawatan dan keandalan. Tetapi masih kurang penelitian perhatian dalam mengukur dampak faktor kualitas efisiensi kinerja. Tujuan utama dalam tesis ini adalah untuk mengetahui dampaknya, menunjukkan bagaimana pola desain dapat digunakan untuk refactor aplikasi perangkat lunak terdahulu dalam hal efisiensi kinerja. Oleh karena itu, akan bermanfaat untuk menyelidiki apakah pola desain dapat mempengaruhi kinerja aplikasi. Dalam tesis ini, sebuah proyek perusahaan bernama SIA (Sistem Informasi Akademik) dirancang dengan menerapkan platform Java EE. Beberapa masalah yang terkait dengan pola desain diketahui. Pemilihan pola desain berdasarkan pada isu konteks aplikasi. Tiga jenis ukuran parameter dipakai untuk penilitian ini, perilaku waktu, pemanfaatan sumber daya dan ukuran kapasitas yang berdasarkan pada pedoman standar. Kami menggunakan Apache JMeter dan Java Mission Control sebagai alat bantu dalam eksperimen. Hasil percobaan menunjukkan bahwa perbandingan antara sistem terdahulu dengan penelitian ini yang menerapkan pola desain menunjukkan bahwa hasilnya berpengaruh terhadap kualitas aplikasi terutama pada efisiensi kinerja