Results 1 - 10
of
299
Using Origin Analysis to Detect Merging and Splitting of Source Code Entities
, 2005
"... Merging and splitting source code entities is a common activity during the lifespan of a software system; as developers rethink the essential structure of a system or plan for a new evolutionary direction, so must they be able to reorganize the design artifacts at various abstraction levels as seems ..."
Abstract
-
Cited by 96 (3 self)
- Add to MetaCart
Merging and splitting source code entities is a common activity during the lifespan of a software system; as developers rethink the essential structure of a system or plan for a new evolutionary direction, so must they be able to reorganize the design artifacts at various abstraction levels as seems appropriate. However, while the raw effects of such changes may be plainly evident in the new artifacts, the original context of the design changes is often lost. That is, it may be obvious which characters of which files have changed, but it may not be obvious where or why moving, renaming, merging, and/or splitting of design elements has occurred. In this paper, we discuss how we have extended origin analysis [1], [2] to aid in the detection of merging and splitting of files and functions in procedural code; in particular, we show how reasoning about how call relationships have changed can aid a developer in locating where merges and splits have occurred, thereby helping to recover some information about the context of the design change. We also describe a case study of these techniques (as implemented in the Beagle tool) using the PostgreSQL database system as the subject.
CatchUp!: capturing and replaying refactorings to support API evolution
- In ICSE
, 2005
"... Library developers who have to evolve a library to accommodate changing requirements often face a dilemma: Either they implement a clean, efficient solution but risk breaking client code, or they maintain compatibility with client code, but pay with increased design complexity and thus higher mainte ..."
Abstract
-
Cited by 74 (0 self)
- Add to MetaCart
(Show Context)
Library developers who have to evolve a library to accommodate changing requirements often face a dilemma: Either they implement a clean, efficient solution but risk breaking client code, or they maintain compatibility with client code, but pay with increased design complexity and thus higher maintenance costs over time. We address this dilemma by presenting a lightweight approach for evolving application programming interfaces (APIs), which does not depend on version control or configuration management systems. Instead, we capture API refactoring actions as a developer evolves an API. Users of the API can then replay the refactorings to bring their client software components up to date. We present CatchUp!, an implementation of our approach that captures and replays refactoring actions within an integrated development environment semi-automatically. Our experiments suggest that our approach could be valuable in practice.
Analysing Refactoring Dependencies Using Graph Transformation
- SOSYM MANUSCRIPT
"... Refactoring is a widely accepted technique to improve the structure of object-oriented software. Nevertheless, existing tool support remains restricted to automatically applying refactoring transformations. Deciding what to refactor and which refactoring to apply still remains a difficult manual pr ..."
Abstract
-
Cited by 55 (12 self)
- Add to MetaCart
Refactoring is a widely accepted technique to improve the structure of object-oriented software. Nevertheless, existing tool support remains restricted to automatically applying refactoring transformations. Deciding what to refactor and which refactoring to apply still remains a difficult manual process, due to the many dependencies and interrelationships between relevant refactorings. In this paper, we represent refactorings as graph transformations, and we propose the techniques of critical pair analysis and sequential dependency analysis to detect the implicit dependencies between refactorings. The results of this analysis can help the developer to make an informed decision of which refactoring is most suitable in a given context and why. We report on several experiments we carried out in the AGG graph transformation tool to support our claims.
Generic and Domain-Specific Model Refactoring using a Model Transformation Engine
- Volume II of Research and Practice in Software Engineering
, 2005
"... Refactoring is an essential approach toward improving the internal structure of a software system while preserving its external behavior. Traditional refactoring techniques have focused on the implementation stage, with source code as the primary artifact of the refactoring process. However, a recen ..."
Abstract
-
Cited by 43 (5 self)
- Add to MetaCart
(Show Context)
Refactoring is an essential approach toward improving the internal structure of a software system while preserving its external behavior. Traditional refactoring techniques have focused on the implementation stage, with source code as the primary artifact of the refactoring process. However, a recent trend is to apply the concepts of refactoring to higher levels of abstraction. Consequently, model refactoring is emerging as a desirable means to improve design models using behavior-preserving transformations.
Template-based reconstruction of complex refactorings
- in Software Maintenance (ICSM), 2010 IEEE International Conference on
, 2010
"... Abstract—Knowing which types of refactoring occurred between two program versions can help programmers better understand code changes. Our survey of refactoring identification techniques found that existing techniques cannot easily identify complex refactorings, such as an replace conditional with p ..."
Abstract
-
Cited by 37 (8 self)
- Add to MetaCart
(Show Context)
Abstract—Knowing which types of refactoring occurred between two program versions can help programmers better understand code changes. Our survey of refactoring identification techniques found that existing techniques cannot easily identify complex refactorings, such as an replace conditional with polymorphism refactoring, which consist of a set of atomic refactorings. This paper presents REF-FINDER that identifies complex refactorings between two program versions using a templatebased refactoring reconstruction approach—REF-FINDER expresses each refactoring type in terms of template logic rules and uses a logic programming engine to infer concrete refactoring instances. It currently supports sixty three refactoring types from Fowler’s catalog, showing the most comprehensive coverage among existing techniques. The evaluation using code examples from Fowler’s catalog and open source project histories shows that REF-FINDER identifies refactorings with an overall precision of 0.79 and recall of 0.95. I.
Refactoring OCL Annotated UML Class Diagrams
- In MoDELS’05, volume 3713 of LNCS
, 2005
"... Abstract. Refactoring of UML class diagrams is an emerging research topic and heavily inspired by refactoring of program code written in object-oriented implementation languages. Current class diagram refactoring techniques concentrate on the diagrammatic part but neglect OCL constraints that might ..."
Abstract
-
Cited by 35 (6 self)
- Add to MetaCart
(Show Context)
Abstract. Refactoring of UML class diagrams is an emerging research topic and heavily inspired by refactoring of program code written in object-oriented implementation languages. Current class diagram refactoring techniques concentrate on the diagrammatic part but neglect OCL constraints that might become syntactically incorrect by changing the underlying class diagram. This paper formalizes the most important refactoring rules for class diagrams and classifies them with respect to their impact on annotated OCL constraints. For refactoring rules, whose application on class diagrams could make attached OCL constraints incorrect, we formally describe how the OCL constraints have to be refactored to preserve their syntactical correctness. Our refactoring rules are defined in the graph-grammar based formalism proposed by the QVT Merge Group for the specification of model transformations. 1
Identification of move method refactoring opportunities. Software Engineering,
- In Proceedings of the Tenth International Workshop on Mining Software Repositories,
, 2009
"... ..."
Detecting Structural Refactoring Conflicts Using Critical Pair Analysis
- In Proceedings of the Workshop on Software Evolution through Transformations: Model-based vs. Implementation-level Solutions
, 2005
"... Refactorings are program transformations that improve the software structure while preserving the external behaviour. In spite of this very useful property, refactorings can still give rise to structural conflicts when parallel evolutions to the same software are made by different developers. This p ..."
Abstract
-
Cited by 28 (6 self)
- Add to MetaCart
(Show Context)
Refactorings are program transformations that improve the software structure while preserving the external behaviour. In spite of this very useful property, refactorings can still give rise to structural conflicts when parallel evolutions to the same software are made by different developers. This paper explores this problem of structural evolution conflicts in a formal way by using graph transformation and critical pair analysis. Based on experiments carried out in the graph transformation tool AGG, we show how this formalism can be exploited to detect and resolve refactoring conflicts. Key words: refactoring, restructuring, graph transformation, critical pair analysis, evolution conflicts, parallel changes
Refactoring using type constraints
- ACM Trans. Program. Lang. Syst
, 2011
"... Abstract. Type constraints express subtype-relationships between the types of program expressions that are required for type-correctness, and were originally proposed as a convenient framework for solving type checking and type inference problems. In this paper, we show how type constraints can be ..."
Abstract
-
Cited by 24 (6 self)
- Add to MetaCart
(Show Context)
Abstract. Type constraints express subtype-relationships between the types of program expressions that are required for type-correctness, and were originally proposed as a convenient framework for solving type checking and type inference problems. In this paper, we show how type constraints can be used as the basis for practical refactoring tools. In our approach, a set of type constraints is derived from a type-correct program P . The main insight behind our work is the fact that P constitutes just one solution to this constraint system, and that alternative solutions may exist that correspond to refactored versions of P . We show how a number of refactorings for manipulating types and class hierarchies can be expressed naturally using type constraints. Several refactorings in the standard distribution of Eclipse are based on our results.
