Wed, 20 Aug 2008 21:20:05 BST CiteULike: mcphee's watchlist http://www.citeulike.org/user/mcphee/watchlist CiteULike.org en-gb Copyright © 2004-2008 citeulike.org http://www.citeulike.org/user/shimomura/article/3078315 <i></i> リファクタリング―プログラムの体質改善テクニック (Object Technology Series) マーチン ファウラー Martin Fowler 児玉 公信 平澤 友野 晶夫 梅沢 真史 2008-08-03T07:41:55-00:00 ピアソンエデュケーション 2000 engineer refactoring software http://www.citeulike.org/user/paulampkelly/article/1218263 <i>Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on, Vol. 00 (2006), 10 pp..</i><br /><br />Software-intensive systems evolve continuously under the pressure of new and changing requirements, generally leading to an increase in overall system complexity. In this respect, to improve quality and decrease complexity, software artifacts need to be restructured and refactored throughout their lifecycle. Since software architecture artifacts represent the highest level of implementation abstraction, and constitute the first step in mapping requirements to design, architecture refactorings can be considered as the first step in the quest of maintaining system quality during evolution. In this paper, we introduce an approach for refactoring software architecture artifacts using model transformations and quality improvement semantic annotations. First, the conceptual architecture view is represented as a UML 2.0 profile with corresponding stereotypes. Second, instantiated architecture models are annotated using elements of the refactoring context, including soft-goals, metrics, and constraints. Finally, the actions that are most suitable for the given refactoring context are applied after being selected from a set of possible refactorings. The approach is applied to a simple example, demonstrating refactoring transformations for improved maintainability, performance, and security. A framework for software architecture refactoring using model transformations and semantic annotations I Ivkovic K Kontogiannis doi:10.1109/CSMR.2006.3 Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on, Vol. 00 (2006), 10 pp.. 2007-04-09T20:40:07-00:00 2006 Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on 00 10 pp. and model refactoring transformations http://www.citeulike.org/user/mrabick/article/2785317 <i>(2005), pp. 111-122.</i> Towards a catalog of aspect-oriented refactorings Miguel Monteiro Ao Jo\ doi:10.1145/1052898.1052908 (2005), pp. 111-122. 2008-05-11T19:52:46-00:00 2005 111 122 ACM aspect catalog refactoring http://www.citeulike.org/user/mrabick/article/3033411 <i>(2005), pp. 123-134.</i> Deriving refactorings for AspectJ Leonardo Cole Paulo Borba doi:10.1145/1052898.1052909 (2005), pp. 123-134. 2008-07-22T18:51:51-00:00 2005 123 134 ACM aspect aspectj refactoring http://www.citeulike.org/user/mrabick/article/2785321 <i>(2007)</i> Bridging the gap between aspect mining and refactoring Isaac Yuen Martin Robillard doi:10.1145/1275672.1275673 (2007) 2008-05-11T19:58:55-00:00 2007 ACM aspect mining refactoring http://www.citeulike.org/user/leonardo/article/3033237 <i>Electronic Notes in Theoretical Computer Science, Vol. 214 (28 June 2008), pp. 331-357.</i><br /><br />Refactorings are systematic changes made to programs, models or specifications in order to improve their structure without changing the externally observable behaviour. We will examine how a constraint solver (the Alloy Analyzer) can be used to automatically check if refactorings, applied to a formal specification (written in Z), meet this requirement. Furthermore, we identify a class of refactorings for which the use of this tool is reasonable in general. Alloy as a Refactoring Checker? H-Christian Estler Heike Wehrheim doi:10.1016/j.entcs.2008.06.015 Electronic Notes in Theoretical Computer Science, Vol. 214 (28 June 2008), pp. 331-357. 2008-07-22T17:11:57-00:00 2008 Electronic Notes in Theoretical Computer Science 214 331 357 2008 alloy checker _hardcopy refactoring http://www.citeulike.org/user/alphabetagamma/article/3017891 <i>Software Engineering Conference, 2004. 11th Asia-Pacific (2004), pp. 484-491.</i><br /><br />Use case models are widely used for requirements engineering to capture functional and nonfunctional requirements, guide scenario-based design and validation, and to manage projects. Our tool for use case development and evolution supports reorganization (refactoring) of use case models as well as the extension of use case models to include new functional and nonfunctional requirements. The tool is based on a three-level metamodel covering the environment or context of a use case model, the structure of use cases, and the event or message-passing details of a scenario. In this paper we describe the tool that we have developed, and demonstrate its application to a case study for bank teller machines (ATMs). We show that the concept of refactoring can be applied to use case models as an aid to their development and evolution. We are now working on a firm semantic foundation for use cases in order to verify the behaviour-preserving property of individual refactorings. Use case refactoring: a tool and a case study J Xu W Yu K Rui G Butler doi:10.1109/APSEC.2004.106 Software Engineering Conference, 2004. 11th Asia-Pacific (2004), pp. 484-491. 2008-07-18T13:09:22-00:00 2004 Software Engineering Conference, 2004. 11th Asia-Pacific 484 491 refactoring http://www.citeulike.org/user/alphabetagamma/article/3008425 <i>(2004)</i><br /><br />Abstract. Refactorings are specific code transformations that can improve the design of existing code without changing its behavior. Many refactorings for object-oriented programs are well known, and refactoring support is now common in IDEs. Authors of AspectJ programs, however, cannot take full advantage of this wisdom and tool support for two reasons. First, there is currently a limited set of aspect-oriented refactorings. A second, more fundamental, problem is that aspect-oriented language constructs can impact what changes are behavior-preserving. As a result, even traditional refactorings are unreliable. This paper presents a framework for judging whether a program transformation is a refactoring in AspectJ. This framework is then applied to establish AspectJ-safe versions of existing refactorings and several new refactorings specific to AOP designs. 1 A basis for AspectJ refactoring Shimon Rura Barbara Lerner (2004) 2008-07-16T13:00:56-00:00 2004 aop refactoring http://www.citeulike.org/user/alphabetagamma/article/3008419 <i>(2005), pp. 1-5.</i> An approach to aspect refactoring based on crosscutting concern types Marius Marin Leon Moonen Arie van Deursen doi:10.1145/1083125.1083140 (2005), pp. 1-5. 2008-07-16T12:59:31-00:00 2005 1 5 ACM aop refactoring http://www.citeulike.org/user/alphabetagamma/article/3007915 <i>(2003), pp. 74-78.</i> Refactoring to aspects: an interactive approach Jan Hannemann Thomas Fritz Gail Murphy doi:10.1145/965660.965676 (2003), pp. 74-78. 2008-07-16T09:23:50-00:00 2003 74 78 ACM aop refactoring http://www.citeulike.org/user/emerson/article/506466 <i>Communications Magazine, IEEE, Vol. 39, No. 10. (2001), pp. 88-93.</i><br /><br />Refactoring can be an important ingredient in the strategy for development and evolution of complex telecommunications software systems. Refactoring is one way to reuse and extend a successful software system. This article presents some design tactics that will assist a development team when they choose evolution from an existing software system over building a completely new system from the ground up. Strictly speaking, the refactoring process changes only the internal design of the software. Refactoring does not add any new functionality. However, the goal of refactoring work is to pave the way for the software to be modified and extended more easily. The simplest example of redesign is the creation of simple “wrapper classes” that contain groups of functions extracted from the legacy code. More complex design patterns are also useful when attempting to improve the design. Developers usually divide the redesign work into stages so that each stage can be implemented and tested separately. This article describes a real-world example of this approach that shows how refactoring improved the design of a wireless base station controller product Refactoring for software migration D Mancl Communications Magazine, IEEE, Vol. 39, No. 10. (2001), pp. 88-93. 2006-02-15T19:33:13-00:00 2001 Communications Magazine, IEEE 39 10 88 93 refactoring http://www.citeulike.org/user/emerson/article/609099 <i>Principles of Software Evolution, Eighth International Workshop on (2005), pp. 123-131.</i><br /><br />The notion of refactoring - transforming the source-code of an object-oriented program without changing its external behaviour - has been studied intensively within the last decade. This diversity has created a plethora of toy-examples, cases and code snippets, which make it hard to assess the current state-of-the-art. Moreover, due to this diversity, there is currently no accepted way of teaching good refactoring practices, despite the acknowledgment in the software engineering body of knowledge. Therefore, this paper presents a common example - the LAN simulation - which has been used by a number of European Universities for both research and teaching purposes. The LAN-simulation: a refactoring teaching example S Demeyer F Van Rysselberghe T Girba J Ratzinger R Marinescu T Mens B Du Bois D Janssens S Ducasse M Lanza M Rieger H Gall M El-Ramly Principles of Software Evolution, Eighth International Workshop on (2005), pp. 123-131. 2006-05-01T15:28:47-00:00 2005 Principles of Software Evolution, Eighth International Workshop on 123 131 refactoring http://www.citeulike.org/user/billkidwell/article/2973157 <i>Software Maintenance, 2007. ICSM 2007. IEEE International Conference on (2007), pp. 24-33.</i><br /><br />Although source code cloning (copy&paste programming) represents a significant threat to the maintainability of a software system, problems usually start to arise only when the system evolves. Most of the related research papers tackle the question of finding code clones in one particular version of the software only, leaving the dynamic behavior of the clones out of consideration. Eliminating these clones in large software systems often seems absolutely hopeless, as there might exist several thousands of them. Alternatively, tracking the evolution of individual clones can be used to identify those occurrences that could really cause problems in the future versions. In this paper we present an approach for mapping clones from one particular version of the software to another one, based on a similarity measure. This mapping is used to define conditions under which clones become suspicious (or "smelly") compared to their other occurrences. Accordingly, these conditions introduce the notion of dynamic clone smells. The usefulness of these smells is validated on the Mozilla Firefox internet browser, where the approach was able to find specific bugs that resulted from neglecting earlier copy&paste activities. Clone Smells in Software Evolution T Bakota R Ferenc T Gyimothy doi:10.1109/ICSM.2007.4362615 Software Maintenance, 2007. ICSM 2007. IEEE International Conference on (2007), pp. 24-33. 2008-07-08T18:45:02-00:00 2007 Software Maintenance, 2007. ICSM 2007. IEEE International Conference on 24 33 analysis maintenance refactoring smells software http://www.citeulike.org/group/5863/article/1731404 <i>(05 June 2006)</i><br /><br /><i>Large Refactorings</i> looks at methods of establish design improvements as an important and independent activity during development of software, and will help to ensure that software continues to adapt, improve and remain easy to read and modify without altering its observable behaviour. It provides real-world experience from real refactored projects and shows how to refactor software to ensure that it is efficient, fresh and adaptable. Refactoring in Large Software Projects: Performing Complex Restructurings Successfully Martin Lippert Stephen Roock (05 June 2006) 2007-10-05T17:22:05-00:00 2006 Wiley programming refactoring http://www.citeulike.org/user/emerson/article/2948963 <i>J. Syst. Softw., Vol. 80, No. 2. (February 2007), pp. 240-264.</i> A case study in re-engineering to enforce architectural control flow and data sharing Marwan Abi-Antoun Jonathan Aldrich Wesley Coelho doi:10.1016/j.jss.2006.10.036 J. Syst. Softw., Vol. 80, No. 2. (February 2007), pp. 240-264. 2008-07-01T18:14:26-00:00 2007 J. Syst. Softw. 0164-1212 80 2 240 264 Elsevier Science Inc. refactoring http://www.citeulike.org/user/billkidwell/article/2948627 <i>(2007), pp. 511-518.</i> An Empirical Study of the Evolution of an Agile-Developed Software System A Capiluppi J Fernandez-Ramil J Higman HC Sharp N Smith doi:10.1109/ICSE.2007.14 (2007), pp. 511-518. 2008-07-01T15:27:12-00:00 2007 511 518 IEEE Computer Society agile evolution metrics refactoring software http://www.citeulike.org/user/leonardo/article/2942467 <i>“UML�? 2003 - The Unified Modeling Language (2003), pp. 159-174.</i><br /><br />A model refactoring is a model transformation that improves the design described in the model. A refactoring should only affect a previously chosen subset of the original model. In this paper, we discuss how to define and execute model refactorings as rule-based transformations. We also present an experimental tool to execute these transformations. Model Refactorings as Rule-Based Update Transformations Ivan Porres “UML�? 2003 - The Unified Modeling Language (2003), pp. 159-174. 2008-06-30T01:04:09-00:00 2003 “UML�? 2003 - The Unified Modeling Language 159 174 2003 refactoring http://www.citeulike.org/user/emerson/article/2932340 <i>Computer, Vol. 39, No. 12. (2006), pp. 131-134.</i><br /><br />Our studies indicate that strategic refactoring using design patterns is the most effective way to repair decaying code for object-oriented (OO) systems. However, applying a pattern-based approach to legacy system repair or even post-design pattern injection is often difficult and, in some cases if misapplied, detrimental Paying Down Design Debt with Strategic Refactoring CJ Neill PA Laplante doi:10.1109/MC.2006.435 Computer, Vol. 39, No. 12. (2006), pp. 131-134. 2008-06-27T01:15:05-00:00 2006 Computer 39 12 131 134 refactoring refactoring_process http://www.citeulike.org/user/emerson/article/2932336 <i>Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on (2008), pp. 329-331.</i><br /><br />In this demonstration, we present an Eclipse plug-in that automatically identifies type-checking bad smells in Java source code, and resolves them by applying the "replace conditional with polymorphism" or "replace type code with state/strategy " refactorings. To the best of our knowledge there is a lack of tools that identify type-checking bad smells. Moreover, none of the state-of-the-art IDEs support the refactorings that resolve such kind of bad smells. JDeodorant: Identification and Removal of Type-Checking Bad Smells N Tsantalis T Chaikalis A Chatzigeorgiou doi:10.1109/CSMR.2008.4493342 Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on (2008), pp. 329-331. 2008-06-27T01:09:47-00:00 2008 Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on 329 331 code_smells refactoring http://www.citeulike.org/user/pautasso/article/2624464 <i>Visual Languages and Human-Centric Computing, 2005 IEEE Symposium on (2005), pp. 311-313.</i><br /><br />Agile methodologies employ light-weight development practices emphasizing a test-driven approach to the development of software systems. Modern agile development environments support this approach by providing tools that automate most of the work required to effectively deal with change, including unit testing and different forms of refactoring. In this paper we discuss how to apply such techniques within the JOpera Visual Composition Language. More precisely, we show how we used the visual language to implement a regression testing framework for compositions written in the language itself and how we introduced support in the visual environment for refactorings such as renaming, synchronization of service interface changes, and extraction/inlining across different levels of nesting. This is done in the context of the Web service composition tools provided with the JOpera for Eclipse research platform. JOpera: an agile environment for Web service composition with visual unit testing and refactoring C Pautasso doi:10.1109/VLHCC.2005.48 Visual Languages and Human-Centric Computing, 2005 IEEE Symposium on (2005), pp. 311-313. 2008-04-02T21:17:01-00:00 2005 Visual Languages and Human-Centric Computing, 2005 IEEE Symposium on 311 313 agile composition eclipse jopera refactoring service visual web http://www.citeulike.org/user/fabul/article/2889992 <i>Software Engineering, 2007. ICSE 2007. 29th International Conference on (2007), pp. 127-136.</i><br /><br />Software refactoring is the process of reorganizing the internal structure of code while preserving the external behavior. Aspect-Oriented Programming (AOP) provides new modularization of software systems by encapsulating crosscutting concerns. Based on these two techniques, aspect-oriented (AO) refactoring restructures crosscutting elements in code. AO refactoring includes two steps: aspect mining (identification of aspect candidates in code) and as- pect refactoring (semantic-preserving transformation to mi- grate the aspect-candidate code to AO code). Aspect refac- toring clusters similar join points together for the aspect candidates and encapsulates each cluster with an effective pointcut definition. With the increase in size of the code and crosscutting concerns, it is tedious to manually identify aspects and their corresponding join points, cluster the join points, and infer pointcut expressions. Therefore, there is a need to auto- mate the process of AO refactoring. This paper proposes an automated approach that identifies aspect candidates in code and infers pointcut expressions for these aspects. Our approach mines for aspect candidates, identifies the join points for the aspect candidates, clusters the join points, and infers an effective pointcut expression for each clus- ter of join points. The approach also provides an addi- tional testing mechanismto ensure that the inferred pointcut expressions are of correct strength. The empirical results show that our approach helps achieve a significant reduc- tion in the total number of pointcut expressions to be used in the refactored code. Automated Inference of Pointcuts in Aspect-Oriented Refactoring Prasanth Anbalagan Tao Xie doi:10.1109/ICSE.2007.19 Software Engineering, 2007. ICSE 2007. 29th International Conference on (2007), pp. 127-136. 2008-06-12T20:15:45-00:00 2007 Software Engineering, 2007. ICSE 2007. 29th International Conference on 127 136 aop aosd refactoring http://www.citeulike.org/user/emerson/article/2881667 <i>Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on, Vol. 00 (2006), 8 pp..</i><br /><br />It is observed that most object oriented coupling metrics are macroscopic, which makes them unsuitable for making finer refactoring decisions. The notions of microscopic viewpoints and coupling projections are introduced. Existing metrics are classified in terms of viewpoints and projections. Two microscopic metrics called relative method coupling (RMC) and relative inward coupling (RIC) are introduced, and a method of applying them to refactoring is discussed. A case study is also included. Microscopic coupling metrics for refactoring P Joshi RK Joshi doi:10.1109/CSMR.2006.32 Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on, Vol. 00 (2006), 8 pp.. 2008-06-11T05:35:03-00:00 2006 Software Maintenance and Reengineering, 2006. CSMR 2006. Proceedings of the 10th European Conference on 00 8 pp. metrics refactoring http://www.citeulike.org/user/emerson/article/2881650 <i>Software Quality, 2007. WoSQ'07: ICSE Workshops 2007. Fifth International Workshop on (2007), pp. 10-10.</i><br /><br />Software systems undergo modifications, improvements and enhancements to cope with evolving requirements. This maintenance can cause their quality to decrease. Various metrics can be used to evaluate the way the quality is affected. Refactoring is one of the most important and commonly used techniques of transforming a piece of software in order to improve its quality. However, although it would be expected that the increase in quality achieved via refactoring is reflected in the various metrics, measurements on real life systems indicate the opposite. We analyzed source code version control system logs of popular open source software systems to detect changes marked as refactorings and examine how the software metrics are affected by this process, in order to evaluate whether refactoring is effectively used as a means to improve software quality within the open source community. Refactoring--Does It Improve Software Quality? K Stroggylos D Spinellis doi:10.1109/WOSQ.2007.11 Software Quality, 2007. WoSQ'07: ICSE Workshops 2007. Fifth International Workshop on (2007), pp. 10-10. 2008-06-11T05:11:59-00:00 2007 Software Quality, 2007. WoSQ'07: ICSE Workshops 2007. Fifth International Workshop on 10 10 metrics refactoring http://www.citeulike.org/user/momo54/article/2878651 <i>Software Engineering, IEEE Transactions on, Vol. 34, No. 3. (2008), pp. 321-335.</i><br /><br />Current text based Software Configuration Management (SCM) systems have trouble with refactorings. Refactorings result in global changes which lead to merge conflicts. A refactoring-aware SCM system reduces merge conflicts. This paper describes MolhadoRef, a refactoring-aware SCM system and the merge algorithm at its core. MolhadoRef records change operations (refactorings and edits) used to produce one version, and replays them when merging versions. Since refactorings are change operations with well defined semantics, MolhadoRef treats them intelligently. A case study and a controlled experiment show that MolhadoRef automatically solves more merge conflicts than CVS while resulting in fewer merge errors. Effective Software Merging in the Presence of Object-Oriented Refactorings Danny Dig Kashif Manzoor Ralph Johnson Tien Nguyen doi:10.1109/TSE.2008.29 Software Engineering, IEEE Transactions on, Vol. 34, No. 3. (2008), pp. 321-335. 2008-06-10T06:46:22-00:00 2008 Software Engineering, IEEE Transactions on 34 3 321 335 merge refactoring semantic software-engineering http://www.citeulike.org/user/emerson/article/2855817 <i>Computer Systems and Applications, 2006. IEEE International Conference on. (2006), pp. 685-688.</i> Refactoring Tools and Complementary Techniques M Drozdz DG Kourie BW Watson A Boake Computer Systems and Applications, 2006. IEEE International Conference on. (2006), pp. 685-688. 2008-06-02T04:50:18-00:00 2006 Computer Systems and Applications, 2006. IEEE International Conference on. 685 688 refactoring tool_adoption http://www.citeulike.org/user/nominolo/article/530969 <i>(2003), pp. 27-38.</i><br /><br />Refactorings are source-to-source program transformations which change program structure and organisation, but not program functionality. Documented in catalogues and supported by tools, refactoring provides the means to adapt and improve the design of existing code, and has thus enabled the trend towards modern agile software development processes. Refactoring has taken a prominent place in software development and maintenance, but most of this recent success has taken place in the OO and XP communities.In our project, we explore the prospects for 'Refactoring Functional Programs', taking Haskell as a concrete case-study. This paper discusses the variety of pragmatic and implementation issues raised by our work on the Haskell Refactorer. We briefly introduce the ideas behind refactoring, and a set of elementary functional refactorings. The core of the paper then outlines the main challenges that arise from our aim to produce practical tools for a decidedly non-toy language, summarizes our experience in trying to establish the necessary meta-programming infrastructure and gives an implementation overview of our current prototype refactoring tool. Using Haskell as our implementation language, we also offer some preliminary comments on Haskell programming-in-the-large. Tool support for refactoring functional programs Huiqing Li Claus Reinke Simon Thompson doi:10.1145/871895.871899 (2003), pp. 27-38. 2006-03-05T00:54:07-00:00 2003 27 38 ACM Press functional-programming program-transformation refactoring http://www.citeulike.org/user/eabait/article/2796294 <i>(08 July 2002)</i><br /><br />The documentation is missing or obsolete, and the original developers have departed. Your team has limited understanding of the system, and unit tests are missing for many, if not all, of the components. When you fix a bug in one place, another bug pops up somewhere else in the system. Long rebuild times make any change difficult. All of these are signs of software that is close to the breaking point.<br><br>Many systems can be upgraded or simply thrown away if they no longer serve their purpose. Legacy software, however, is crucial for operations and needs to be continually available and upgraded. How can you reduce the complexity of a legacy system sufficiently so that it can continue to be used and adapted at acceptable cost?<br><br>Based on the authors' industrial experiences, this book is a guide on how to reverse engineer legacy systems to understand their problems, and then reengineer those systems to meet new demands. Patterns are used to clarify and explain the process of understanding large code bases, hence transforming them to meet new requirements. The key insight is that the right design and organization of your system is not something that can be evident from the initial requirements alone, but rather as a consequence of understanding how these requirements evolve.<br><br>* Describes how to reverse engineer a monolithic system to understand how it really works and how to identify potential problems.<br>* Includes reengineering patterns that tackle well-known reengineering techniques often encountered in object-oriented programming, such as introducing polymorphism, factoring out common behavior, detecting duplicated code, and understanding design.<br>* Shows how to build a culture of continuous reengineering for achieving flexible and maintainable object-oriented systems. Object Oriented Reengineering Patterns (The Morgan Kaufmann Series in Software Engineering and Programming) Serge Demeyer Stéphane Ducasse Oscar Nierstrasz (08 July 2002) 2008-05-14T00:22:00-00:00 2002 Morgan Kaufmann object-oriented patterns program refactoring transformation http://www.citeulike.org/user/nominolo/article/2759139 <i>Programming Languages and Systems (2007), pp. 303-318.</i><br /><br />We rationally reconstruct the core of the Coccinelle system, used for automating and documenting collateral evolutions in Linux device drivers. A denotational semantics of the system’s underlying semantic patch language (SmPL) is developed, and extended to include variables. The semantics is in essence a higher-order functional program and so executable; but is inefficient and limited to straight-line source programs. A richer and more efficient SmPL version is defined, implemented by compiling to the temporal logic CTL-V (CTL with existentially quantified variables ranging over source code parameters and program points; defined using the staging concept from partial evaluation). The compilation is formally proven correct and a model check algorithm is outlined. The Semantics of “Semantic Patches” in Coccinelle: Program Transformation for the Working Programmer Neil Jones René Hansen doi:10.1007/978-3-540-76637-7_21 Programming Languages and Systems (2007), pp. 303-318. 2008-05-05T20:24:54-00:00 2007 Programming Languages and Systems 303 318 program-analysis refactoring http://www.citeulike.org/user/leonardo/article/2724524 <i>Fundamental Approaches to Software Engineering (2008), pp. 347-361.</i><br /><br />With the success of model-driven development as well as component-based and service-oriented systems, models of software architecture are key artefacts in the development process. To adapt to changing requirements and improve internal software quality such models have to evolve while preserving aspects of their behaviour. To avoid the costly verification of refactoring steps on large systems we present a method which allows us to extract a (usually much smaller) rule from the transformation performed and verify this rule instead. The main result of the paper shows that the verification of rules is indeed sufficient to guarantee the desired semantic relation between source and target models. We apply the approach to the refactoring of architectural models based on UML component, structure, and activity diagrams, with using CSP as a semantic domain. Verification of Architectural Refactorings by Rule Extraction Dénes Bisztray Reiko Heckel Hartmut Ehrig doi:10.1007/978-3-540-78743-3_26 Fundamental Approaches to Software Engineering (2008), pp. 347-361. 2008-04-27T19:06:29-00:00 2008 Fundamental Approaches to Software Engineering 347 361 2008 csp refactoring statecharts uml http://www.citeulike.org/user/leonardo/article/2697473 <i>Electronic Notes in Theoretical Computer Science, Vol. 187 (15 July 2007), pp. 3-17.</i><br /><br />Refactorings are changes made to programs, models or specifications with the intention of improving their structure and thus making them clearer, more readable and re-usable. Refactorings are required to be behaviour-preserving in that the external behaviour of the program/model/specification remains unchanged. In this paper we show how a simple type of refactorings on object-oriented specifications (written in Object-Z) can be formally shown to be behaviour-preserving using a modelchecker (SAL). The class of refactorings treated covers those operating on a single method only. Modelchecking Correctness of Refactorings - Some Experiments H-Christian Estler Thomas Ruhroth Heike Wehrheim doi:10.1016/j.entcs.2006.08.041 Electronic Notes in Theoretical Computer Science, Vol. 187 (15 July 2007), pp. 3-17. 2008-04-21T18:02:42-00:00 2007 Electronic Notes in Theoretical Computer Science 187 3 17 2007 _hardcopy model_checking refactoring http://www.citeulike.org/user/leonardo/article/2464828 <i>«UML» 2001 — The Unified Modeling Language. Modeling Languages, Concepts, and Tools (2001), pp. 134-148.</i><br /><br />Software developers spend most of their time modifying and maintaining existing products. This is because systems, and consequently their design, are in perpetual evolution before they die. Nevertheless, dealing with this evolution is a complex task. Before evolving a system, structural modifications are often required. The goal of this kind of modification is to make certain elements more extensible, permitting the addition of new features. However, designers are seldom able to evaluate the impact, on the whole model, of a single modification. That is, they cannot precisely verify if a change modifies the behavior of the modeled system. A possible solution for this problem is to provide designers with a set of basic transformations, which can ensure behavior preservation. These transformations, also known as refactorings, can then be used, step by step, to improve the design of the system. In this paper we present a set of refactorings and explain how they can be designed so as to preserve the behavior of a UML model. Some of these refactorings are illustrated with examples. Refactoring UML Models Gerson Sunyé Damien Pollet Yves Le Traon Jean Jézéquel doi:10.1007/3-540-45441-1_11 «UML» 2001 — The Unified Modeling Language. Modeling Languages, Concepts, and Tools (2001), pp. 134-148. 2008-03-04T13:18:40-00:00 2001 «UML» 2001 — The Unified Modeling Language. Modeling Languages, Concepts, and Tools 134 148 2001 refactoring uml http://www.citeulike.org/user/segura/article/782693 <i>(2006), pp. 112-121.</i> Feature oriented refactoring of legacy applications Jia Liu Don Batory Christian Lengauer doi:10.1145/1134285.1134303 (2006), pp. 112-121. 2006-08-02T11:53:21-00:00 2006 112 121 ACM Press refactoring http://www.citeulike.org/user/segura/article/1632061 <i>IEEE Trans. Softw. Eng., Vol. 28, No. 5. (May 2002), pp. 449-462.</i> A State-of-the-Art Survey on Software Merging T Mens doi:10.1109/TSE.2002.1000449 IEEE Trans. Softw. Eng., Vol. 28, No. 5. (May 2002), pp. 449-462. 2007-09-07T15:51:39-00:00 2002 IEEE Trans. Softw. Eng. 0098-5589 28 5 449 462 IEEE Press model-merging refactoring http://www.citeulike.org/user/segura/article/466552 <i>IEEE Trans. Softw. Eng., Vol. 30, No. 2. (February 2004), pp. 126-139.</i> A Survey of Software Refactoring Tom Mens Tom Tourw&\#233; doi:10.1109/TSE.2004.1265817 IEEE Trans. Softw. Eng., Vol. 30, No. 2. (February 2004), pp. 126-139. 2006-01-17T00:18:07-00:00 2004 IEEE Trans. Softw. Eng. 0098-5589 30 2 126 139 IEEE Press model-merging refactoring http://www.citeulike.org/user/smogit/article/2280690 <i>(2007)</i> Mining a Change-Based Software Repository Romain Robbes doi:10.1109/MSR.2007.18 (2007) 2008-01-23T13:57:20-00:00 2007 IEEE Computer Society change cvs empirical refactoring http://www.citeulike.org/user/leonardo/article/838411 <i>Requirements Engineering, 2005. Proceedings. 13th IEEE International Conference on, (2005), pp. 363-372.</i><br /><br />A reverse engineering process aims at reconstructing high-level abstractions from source code. This paper presents a novel reverse engineering methodology for recovering stakeholder goal models from both structured and unstructured legacy code. The methodology consists of the following major steps: 1) Refactoring source code by extracting methods based on comments; 2) Converting the refactored code into an abstract structured program through statechart refactoring and hammock graph construction; 3) Extracting a goal model from the structured program's abstract syntax tree; 4) Identifying nonfunctional requirements and derive soft goals based on the traceability between the code and the goal model. To illustrate this requirements recovery process, we refactor stakeholder goal models from two legacy software code bases: an unstructured Web-based email in PHP (SquirrelMail) and a structured email client system in Java (Columba). Reverse Engineering Goal Models from Legacy Code Yijun Yu Yiqiao Wang John Mylopoulos Sotirios Liaskos Alexei Lapouchnian Julio Leite doi:10.1109/RE.2005.61 Requirements Engineering, 2005. Proceedings. 13th IEEE International Conference on, (2005), pp. 363-372. 2006-09-10T02:21:36-00:00 2005 Requirements Engineering, 2005. Proceedings. 13th IEEE International Conference on, 363 372 IEEE Computer Society 2005 _hardcopy refactoring reverse_engineering statecharts http://www.citeulike.org/user/BastianSpanneberg/article/693776 <i>(03 March 2006)</i> Refactoring Databases : Evolutionary Database Design (Addison Wesley Signature Series) Scott Ambler Pramodkumar Sadalage (03 March 2006) 2006-06-12T14:50:16-00:00 2006 Addison-Wesley Professional database refactoring http://www.citeulike.org/user/leonardo/article/2141495 <i>Compiler Construction (2007), pp. 156-171.</i><br /><br />Program refactoring, feature-based and aspect-oriented software synthesis, and model-driven development are disjoint research areas. However, they are all architectural metaprogramming technologies as they treat programs as values and use functions (a.k.a. transformations) to map programs to other programs. In this paper, I explore their underlying connections by reviewing recent advances in each area from an architectural metaprogramming perspective. I conjecture how these areas can converge and outline a theory that may unify them. Program Refactoring, Program Synthesis, and Model-Driven Development Don Batory doi:10.1007/978-3-540-71229-9_11 Compiler Construction (2007), pp. 156-171. 2007-12-18T16:14:16-00:00 2007 Compiler Construction 156 171 2007 mdd refactoring _to_download_springer http://www.citeulike.org/user/leonardo/article/2140534 <i>Emerging Technologies and Factory Automation, 2006. ETFA '06. IEEE Conference on (2006), pp. 1230-1237.</i><br /><br />This paper starts presenting a methodology for embedded systems co-design where statecharts play the role of specification formalism. The system model is expressed using a statechart model, which is a kind of hierarchical and concurrent state diagram, and the methodology relies on the decomposition of the system model into a set of parallel components. The system model is edited using a UML-2.0 compliant graphical editor, and the tool described in this paper produces an intermediary representation of the components using XML (after model partitioning), amenable to feed automatic code generation tools, allowing production of VHDL-code, C-code, or SystemC-code. The paper presents a set of arc lifting mechanisms to be applied to an ill-structured hierarchical and concurrent state diagram in order to obtain a well-structured model, which, according with methodology's requirements, is a requisite for removing hierarchical structures in the model and allow partitioning of the model into a set of concurrent components. Removing ill-structured arcs in Hierarchical and Concurrent State Diagrams L Gomes A Costa doi:10.1109/ETFA.2006.355193 Emerging Technologies and Factory Automation, 2006. ETFA '06. IEEE Conference on (2006), pp. 1230-1237. 2007-12-18T11:22:06-00:00 2006 Emerging Technologies and Factory Automation, 2006. ETFA '06. IEEE Conference on 1230 1237 2006 refactoring statecharts http://www.citeulike.org/user/leonardo/article/1725048 <i>Electronic Notes in Theoretical Computer Science, Vol. 70, No. 3. (November 2002), pp. 311-330.</i><br /><br />In this paper we present how refactoring of object-oriented programs can be accomplished by using refinement. Our approach is based on algebraic laws of an object-oriented language for refinement similar to Java. We follow a strategy involving data and algorithmic refinement of classes. Refactoring by Transformation Márcio Cornélio Ana Cavalcanti Augusto Sampaio doi:10.1016/S1571-0661(05)82564-2 Electronic Notes in Theoretical Computer Science, Vol. 70, No. 3. (November 2002), pp. 311-330. 2007-10-03T20:31:21-00:00 2002 Electronic Notes in Theoretical Computer Science 70 3 311 330 2002 oo refactoring transformation http://www.citeulike.org/user/leonardo/article/2014112 <i>Electronic Notes in Theoretical Computer Science, Vol. 82, No. 7. (June 2003), pp. 91-104.</i><br /><br />Currently there is a lot of interest in graph representations of software systems, as they provide a natural and flexible means to describe complex structures. The various visual sublanguages of the UML are perhaps the most obvious example of this. In [11] a graph representation of object-oriented programs was presented that enables one to describe refactoring operations (behaviour-preserving changes in the structure of a program) in a formal, concise way by graph rewriting productions. In general, however, a refactoring makes changes to a small part of a program, so the graph representation should only contain the information needed to carry out that refactoring. All other details are redundant and make the graph unnecessarily large for good visualization. A possible solution consists in using a hierarchical representation. Such a representation of object-oriented programs is presented in this paper. It is based on node-rewriting graph productions: each refinement step corresponds to a production. The construction is illustrated by applying it to a small Java simulation of a Local Area Network. A Hierarchical Program Representation for Refactoring Niels Van Eetvelde Dirk Janssens doi:10.1016/S1571-0661(04)80749-7 Electronic Notes in Theoretical Computer Science, Vol. 82, No. 7. (June 2003), pp. 91-104. 2007-11-29T12:14:21-00:00 2003 Electronic Notes in Theoretical Computer Science 82 7 91 104 2003 hierarchy refactoring refinement http://www.citeulike.org/user/leonardo/article/1993089 <i>(2006), pp. 1210-1217.</i> Model refactorings through rule-based inconsistency resolution Ragnhild Van Der Straeten Maja D'Hondt doi:10.1145/1141277.1141564 (2006), pp. 1210-1217. 2007-11-27T13:30:17-00:00 2006 1210 1217 ACM 2006 model_inconsistencies refactoring http://www.citeulike.org/user/emerson/article/1988475 <i>(2007), pp. 175-184.</i> Beyond refactoring: a framework for modular maintenance of crosscutting design idioms Macneil Shonle William Griswold Sorin Lerner doi:10.1145/1287624.1287650 (2007), pp. 175-184. 2007-11-26T21:06:27-00:00 2007 175 184 ACM refactoring http://www.citeulike.org/user/leonardo/article/1987258 <i>Software and Systems Modeling, Vol. 7, No. 1. (23 February 2008), pp. 25-47.</i><br /><br />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 attached OCL constraints. For refactoring rules that have an impact on OCL constraints, we formalize the necessary changes of the attached constraints. Our refactoring rules are specified in a graph-grammar inspired formalism. They have been implemented as QVT transformation rules. We finally discuss for our refactoring rules the problem of syntax preservation and show, by using the KeY-system, how this can be resolved. Refactoring OCL annotated UML class diagrams Slaviša Marković Thomas Baar doi:10.1007/s10270-007-0056-x Software and Systems Modeling, Vol. 7, No. 1. (23 February 2008), pp. 25-47. 2007-11-26T16:20:32-00:00 2008 Software and Systems Modeling 7 1 25 47 2008 ocl refactoring uml http://www.citeulike.org/user/emerson/article/1928619 <i>(2006), pp. 288-296.</i> Common refactorings, a dependency graph and some code smells: an empirical study of Java OSS S Counsell Y Hassoun G Loizou R Najjar doi:10.1145/1159733.1159777 (2006), pp. 288-296. 2007-11-16T22:37:51-00:00 2006 288 296 ACM refactoring http://www.citeulike.org/group/1660/article/1903696 <i>Compiler Construction (1999), pp. 244-258.</i><br /><br />Certain features of the object-oriented paradigm are a serious impediment for the runtime performance of object-oriented programs. Although compiler techniques to alleviate this problem were developed over the years, we will present some real-world examples which show that these solutions fall short in making any significant optimizations to systems that are required to be very flexible and highly reusable. As a solution, we propose a radically different approach: using an open compiler to ”compile away” whole designs by performing architectural transformations based on programmer annotations. We will discuss this approach in detail and show why it is more suited to solve the efficiency problems inherently associated with object-oriented programming. Optimizing Object-Oriented Languages through Architectural Transformations Tom Tourwé Wolfgang De Meuter Compiler Construction (1999), pp. 244-258. 2007-11-12T18:20:49-00:00 1999 Compiler Construction 244 258 architecture evolution refactoring software software-architecture software-engineering http://www.citeulike.org/group/1660/article/423212 <i>Automated Software Engg., Vol. 8, No. 1. (January 2001), pp. 89-120.</i> Evolving Object-Oriented Designs with Refactorings Lance Tokuda Don Batory doi:10.1023/A:1008715808855 Automated Software Engg., Vol. 8, No. 1. (January 2001), pp. 89-120. 2005-12-06T05:00:01-00:00 2001 Automated Software Engg. 0928-8910 8 1 89 120 Kluwer Academic Publishers design evolution refactoring software software-engineering http://www.citeulike.org/user/germoglio/article/1903518 <i>Software, IEEE, Vol. 15, No. 4. (1998), pp. 67-68.</i><br /><br />Dekleva's (1992) study confirms that if you build a system well, it will be maintained more than if you don't. Why! Because maintenance is about product enhancement and a well-built system is easier to enhance. So, if you still believe we can eliminate maintenance by doing our development jobs better, the author has a different view. That's not how it works. When it comes to software maintenance, it's increasingly clear that we should be doing more of it, not less. Maintenance is a unique advantage that the discipline of software brings to the table. Maintenance can be best served not by searching for ways of obliterating it, as some have suggested, but by searching for ways of doing it more effectively and efficiently Maintenance: less is not more RL Glass Software, IEEE, Vol. 15, No. 4. (1998), pp. 67-68. 2007-11-12T17:27:10-00:00 1998 Software, IEEE 15 4 67 68 evolution refactoring software software-engineering software-evolution http://www.citeulike.org/user/biomedtextminer/article/1657227 <i>Journal of Biomedical Discovery and Collaboration, Vol. 2 (13 September 2007), 4.</i> Corpus Refactoring: a Feasibility Study Helen Johnson William Baumgartner Martin Krallinger Bretonnel Cohen Lawrence Hunter doi:10.1186/1747-5333-2-4 Journal of Biomedical Discovery and Collaboration, Vol. 2 (13 September 2007), 4. 2007-09-14T15:11:16-00:00 2007 Journal of Biomedical Discovery and Collaboration 1747-5333 2 4 biology corpus curation format language mining natural nlp processing refactoring text http://www.citeulike.org/user/germoglio/article/1899192 <i>Software Evolution, 2003. Proceedings. Sixth International Workshop on Principles of (2003), pp. 126-130.</i><br /><br />In modern software engineering, researchers regard a software system as an organic life form that must continue to evolve to remain successful. Unfortunately, little is known about how successful software systems have evolved, and consequently little has been learned from previous experience. We demonstrate a heuristic to reconstruct evolution processes of existing software systems by exploiting techniques to detect duplication in large amounts of data. A case study, evaluating various versions of Tomcat using this heuristic, revealed that the removal of duplicated code is a much smaller concern than grouping functionality in classes with one clear responsibility. Reconstruction of successful software evolution using clone detection F Van Rysselberghe S Demeyer Software Evolution, 2003. Proceedings. Sixth International Workshop on Principles of (2003), pp. 126-130. 2007-11-11T17:17:27-00:00 2003 Software Evolution, 2003. Proceedings. Sixth International Workshop on Principles of 126 130 evolution refactoring software software-evolution