Code refactoring

Summary

In computer programming and software design, code refactoring is the process of restructuring existing computer code—changing the factoring—without changing its external behavior. Refactoring is intended to improve the design, structure, and/or implementation of the software (its non-functional attributes), while preserving its functionality. Potential advantages of refactoring may include improved code readability and reduced complexity; these can improve the source codes maintainability and create a simpler, cleaner, or more expressive internal architecture or object model to improve extensibility. Another potential goal for refactoring is improved performance; software engineers face an ongoing challenge to write programs that perform faster or use less memory. Typically, refactoring applies a series of standardized basic micro-refactorings, each of which is (usually) a tiny change in a computer program's source code that either preserves the behavior of the software, or at least

Official source

https://en.wikipedia.org/wiki/Code_refactoring

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related publications (15)

Model refactoring using transformations

Slavisa Markovic

Modern software is reaching levels of complexity encountered in biological systems; sometimes comprising systems of systems each of which may include tens of millions of lines of code. Model Driven Engineering (MDE) advocates raising the level of abstraction as an instrument to deal with software complexity. It promotes usage of software models as primary artifacts in a software development process. Traditionally, these MDE models are specified by Unified Modeling Language (UML) or by a modeling language created for a specific domain. However, in the vast area of software engineering there are other techniques used to improve quality of software under development. One of such techniques is refactoring which represents introducing structured changes in software in order to improve its readability, extensibility, and maintainability, while preserving behavior of the software. The main application area for refactorings is still programming code, despite the fact that modeling languages and techniques has significantly gained in popularity, in recent years. The main topic of this thesis is making an alliance between the two virtually orthogonal techniques: software modeling and refactoring. In this thesis we have investigated how to raise the level of abstraction of programming code refactorings to the modeling level. This resulted in a catalog of model refactorings each specified as a model transformation rule. In addition, we have investigated synchronization problems between different models used to describe one software system, i.e. when one model is refactored what is the impact on all dependent models and how this impact can be formalized. We have concentrated on UML class diagrams as domain of refactorings. As models dependent on class diagrams, we have selected Object Constraint Language (OCL) annotations, and object diagrams. This thesis formalizes the most important refactoring rules for UML class diagrams and classifies them with respect to their impact on object diagrams and annotated OCL constraints. For refactoring rules that have an impact on dependent artifacts we formalize the necessary changes of these artifacts. Moreover, in this thesis, we present a simple criterion and a proof technique for the semantic preservation of refactoring rules that are defined for UML class and object diagrams, and OCL constraints. In order to be able to prove semantic preservation, we propose a model transformation approach to specify the semantics of constraint languages.

EPFL2008

Refactorings represent a powerful approach for improving the quality of software systems. A refactoring can be seen as a special kind of behavior preserving model transformation. The Object Constraint Language (OCL) together with the metamodel of Unified Modeling Language (UML) can be used for defining rules for refactoring UML models. This paper investigates descriptions of refactoring rules that can be checked, reused and composed. The main contribution of this paper is an algorithm to compute the description of sequentially composed transformations. This allows one to check if a sequence of transformations is successfully applicable for a given model before the transformations are executed on it. Furthermore, it facilitates the analysis of the effects of transformation chain and its usage in other compositions.

2004

RoclET– Refactoring OCL Expressions by Transformations

Leander Eyer, Cédric Jeanneret, Slavisa Markovic

The role of UML models in software development has changed considerably over the last years. While UML was used in its early days mostly as a notation for sketching ideas, developers more and more recognize now the value of a UML model as a formal document that can be processed by tools, e.g. in order to generate code and documentation. Precise software models, however, can usually not be expressed by the pure diagrammatic elements of UML. Instead, they are best captured by constraints written in OCL. Despite the primary importance of constraints within precise modeling, the tool support for OCL is still in a rudimentary stage and there is much room for improvements. In this paper, we describe the architecture and the functionality of our own OCL tool called RoclET. Currently, our tool supports the parsing of OCL assertions (invariants, pre-/post-conditions), their evaluation in given system snapshots (object diagrams) and refactoring, i.e. the automatic propagation of changes made in the underlying class diagram across annotated OCL constraints. RoclET is highly customizable and can handle different OCL dialects. Its functionality is mainly implemented in form of QVT transformation rules that can be adapted by the user. RoclET is realized in form of an Eclipse plugin.

2006

Related people (1)

Related people

Related units (1)

Related units

Related concepts (46)

Related concepts

Related courses (2)

This course teaches the basics of modern software development: designing software, working in a team, writing good code, shipping software, and evolving software. It emphasizes building software that meets high standards of quality, reliability, security, and manageability.

This course focuses on software security fundamentals, secure coding guidelines and principles, and advanced software security concepts. Students learn to assess and understand threats, learn how to design and implement secure software systems, and get hands-on experience with security pitfalls.

Related courses

Related lectures (3)

Related lectures

Model refactoring using transformations

Slavisa Markovic

EPFL2008