Refactoring with Contracts

1998

jContractor is a purely library and design-pattern based approach to support Design By Contract specifications such as preconditions, postconditions, class invariants, and recovery and exception handling in Java. jContractor uses an intuitive naming convention, and standard Java syntax to instrument Java classes and enforce Design By Contract constructs. The designer of a class specifies a contract by defining protected methods which conform to the jContractor design patterns. jContractor uses Java Reflection to synthesize an instrumented version of a Java class containing jContractor contract specifications. The instrumented version contains code which enforces the Design By Contract specifications. Programmers enable the run-time enforcement of contracts by either incorporating the jContractor class loader or by instantiating objects directly from the instrumented subclass through the jContractor factory. Programmers can use exactly the same syntax for invoking methods and passing...

IEEE International Conference on Computer Systems and Applications, 2006., 2006

Poorly designed software systems are difficult to understand and maintain. Modifying code in one place could lead to unwanted repercussions elsewhere due to high coupling. Adding new features can cause further quality degradation to the code if proper design and architectural concerns were not implemented. Development in a large enterprise system with such attributes will, over time, lead to a myriad of concerns unless the system is periodically overhauled or refactored in some way. Refactoring can aid the developer to improve the design of the code and to make it cleaner, without changing its behaviour. This study provides answers for some of the questions on refactoring. A refactoring tool survey is given. The IDEs surveyed include some of the most popular commercial and open source offerings from IntelliJ's IDEA, IBM's Eclipse and Sun's Netbeans. We also explain a way to automatically find targets for refactorings via automatic detection of code smells from static code analysis. Concerns on viewing compiler refactorings as a fully automated refactorings are raised. We will perform a critical evaluation of refactoring by surveying these tools.

Ninth Asia-Pacific Software Engineering Conference, 2002., 2002

Software often needs to be modified for accommodating requirements changes through the software life cycle. To deal with several accidental requirements changes related to software maintenance, a systematic and safe approach to modifying softwares is needed. The design patterns provide a high degree of design flexibility for such accidental requirements changes. In this paper, we propose an automated approach to refactoring based on design patterns in Java programs. In our approach, for a particular design pattern, we define an inference rule to automatically identify a set of candidate spots and a refactoring strategy to transform one of the set of candidate spots into the desired design pattern structure. A candidate spot may be a class or a set of classes to which the design patterns can be applied. We believe that our approach would be helpful to the maintainers in the sense that much of manual analysis on source code can be reduced, and the fashion of automated program transformation preserves the behavior of the original program by means of the refactoring technique.

2008

Abstract. This paper proposes a case for the GraBaTs' 08 tool contest. The graph transformation system to be implemented shall (i) import a graph-based representation of models of Java programs in a Gxl-based format,(ii) allow these models to be transformed interactively with three well-known program refactorings Encapsulate Field, Move Method, and Pull-up Method, and (iii) export the resulting models in the same Gxlformat.

Electronic Notes in …, 2003

In this paper we provide an extensive overview of existing research in the field of software restructuring and refactoring, from a formal as well as a practical point of view. Next, we propose an extensive list of open questions that indicate future research directions, and we provide some partial answers to these questions.

2014

This report documents the program and the outcomes of Dagstuhl Seminar 14211 on “The Future of Refactoring.” Over the past decade, refactoring has become firmly established as an essential part of industrial software development. At the same time, academic interest in refactoring has grown at a fast pace, resulting in a large body of literature on many dierent aspects of refactoring. The aim of this seminar was to provide a forum for refactoring researchers and practitioners to discuss what has been achieved, get to know each others’ work, and plan future collaboration. This report presents abstracts of the participants’ talks and summaries of breakout sessions, and introduces some joint projects that were started as a result of the seminar. Seminar May 18‐23, 2014 ‐ http://www.dagstuhl.de/14211 1998 ACM Subject Classification D.2.7 Restructuring, reverse engineering, and reengineering

Seventh European Conference onSoftware Maintenance and Reengineering, 2003. Proceedings.

Refactoring is a very important technology to improve the reusability and maintainability of existing code, and it is widely used in software development. In order to extract the code segment into a new method easily and cover the shortage of Eclipse in refactoring, the method of Context-Aware Automatic Code Segment Extraction and Refactoring (CAACSER) is proposed. By analyzing the context of the code, the input parameter class, and the output parameter class are introduced to handle complex code segments. The experimental results show that the CAACSER effectively solves some problems and drawbacks of many existing tools in code segment extraction, which acts as a basic step for realizing automatic and semi-automatic refactoring methods. The visualization tool of CAACSER can also carry out reasonable optimizations of the code without changing the systems' behaviors.

Revista Facultad De Ingenieria Universidad De Antioquia, 2013

Component-Based Software Engineering (CBSE) claims to improve software modularisation and to embed architectural concerns. Refactoring Java legacy code with CBSE in mind requires first assessing the compliance of legacy code with component programming principles. This paper presents a portfolio of rules to assess the compliance of Java legacy code with the Communication Integrity (CI) property, which is one of the major strengths of the CBSE approach. These rules are proposed with the objective of identifying implicit component types and thus provide a measure of the componentisation of an application. In order to help developers and legacy code maintainers when refactoring their applications, along with the rules, this work leads to define a set of refactoring actions. Additionally, the results of testing, comparing and analysing the outputs of refactoring several Java applications are also presented.

Refactoring is a crucial process to improve the quality of software. Refactoring is part of software engineering that improves more readability of program and maintainability of the software. Refactoring is a most widely used technique that gives the code simpler, cleaner, reusable, extendable, maintainable or other characteristics by transforming a program. In programming languages, bad smell or code smell is a code or design problem that makes the software hard to understand and maintain the code. Basically, bad smells are structured characteristics of software that indicate a problem, may be need it refactoring of code. In this paper some refactoring techniques discussed that are used to remove code smells from code or program. Simulation has been done for some refactoring techniques like Rename method, Extract method, Move method, Pull up method using Eclipse tool. Eclipse refactoring tool supports the java development language. It has been observed that pull up method is better as compared to other refactoring methods because pull up method dispose the complexity and duplicate code from program.

2005

Refactoring is an essential and useful practice in developing and maintaining object-oriented software since it improves the design of existing code without changing its external behavior. Therefore, several refactoring tools tend to be integrated into contemporary IDEs. However, these tools represent source code as an abstract syntax tree (AST) and thus their implementations are hard to extend and modify. This paper presents Jrbx, a refactoring tool that uses a fine-grained XML representation of source code and supports stylized manipulations of the representation. Moreover, Jrbx aggressively exploits control flow graphs (CFGs) and program dependence graphs (PDGs) for both precondition checking and change creation. The use of the XML, CFG, and PDG representations makes the implementation of Jrbx more understandable and reusable, and thus facilitates tool developers creating new refactorings and modifying existing ones.

Proceedings First International Workshop on …, 2003

This position paper identifies emerging trends in refactoring research, and enumerates a list of open questions, from a practical as well as a theoretical point of view. We suggest these directions for further research based on our own experience with refactoring, as well as on a detailed literature survey on software refactoring.

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.

Proceedings of the 2nd Workshop on Refactoring Tools, 2008

Many automated refactoring tools only work with one programming language. However, most complex programs rely on polyglot programming-entailing the use of different programming languages, libraries and frameworks. While finding a general solution for extending refactoring across multiple languages is hard, it is simple and possible to support automated refactorings for some common cases that programmers already encounter in their programs today. Supporting those common cases is essential in encouraging programmers to make changes that would increase the understandability and maintainability of their programs. This paper is a step toward encouraging tool developers to think about supporting multi-language refactorings. We present our tool for supporting multi-language refactorings from studying the interactions between Java and XML configuration files. Our tool extends Rename Refactoring support across three different popular Java frameworks: Struts, Hibernate and Spring.

Proceedings of the 2nd Workshop on Refactoring Tools - WRT '08, 2008

Oftentimes the changes required to improve the design of code are crosscutting in nature and thus easier to perform with the assistance of automated refactoring tools. However, the developers of such refactoring tools cannot anticipate every practical transformation, particularly those that are specific to the program's domain. We demonstrate Arcum, a declarative language for describing and performing both general and domain-specific transformations. Because Arcum works directly with declarative descriptions of crosscutting code it can ensure that code written or modified after the transformation also satisfies the design's requirements. As a result, preconditions and postconditions are persistently checked, making the crosscutting code (such as the use of a design idiom or programming style) behave more like a module with respect to checkability and substitutability. Bringing such capabilities into the IDE allows for code to be decomposed closer to the programmer's intentions and less coupled to specific implementations.

… (CAiSE 05). Doctoral Consortium, Porto, Portugal, 2005

Refactoring is an emergent trend in software evolution. There are activities and work lines not yet covered in this process. Assistance to refactoring with a certain language independence is one of them. This work presents a proposal to the refactoring process definition based on a model language, with the aim of establishing a solid base to the development of software tools, which use refactoring with a language independence. In particular, we pretend to refactor in the context of object-oriented languages, statically typed with advanced inheritance and genericity.