| Type | Conference Paper |
|---|---|
| Author | F. W. Calliss |
| Author | M. Khalil |
| Author | M. Munro |
| Author | M. Ward |
| Date | 1988 |
| Proceedings Title | in Proceedings for the Conference on Software Maintenance |
| Pages | 319―324 |
| Date Added | Fri Nov 28 12:27:42 2008 |
| Modified | Fri Nov 28 12:27:42 2008 |
Expert system for C code analysis and transformation requires knowledge elicitation from expert maintainers and domain experts.
Semantics-based using program "plans"
"A catalogue of proven transformations..."
Relevance: 4
| Type | Conference Paper |
|---|---|
| Author | William Opdyke |
| Author | Ralph Johnson |
| Date | 1990 |
| Proceedings Title | Proceedings of Symposium on Object-Oriented Programming Emphasizing Practical Applications |
| Conference Name | SOOPPA'90 |
| Date Added | Mon Dec 8 09:47:36 2008 |
| Modified | Mon Dec 8 09:50:06 2008 |
| Type | Thesis |
|---|---|
| Author | William Opdyke |
| Type | PhD Thesis |
| University | University of Illinois at Urbana-Champaign |
| Date | May, 1992 |
| Date Added | Mon Dec 8 08:34:45 2008 |
| Modified | Mon Dec 8 08:37:04 2008 |
The origin of "refactoring".
| Type | Conference Paper |
|---|---|
| Author | Ivan Moore |
| Abstract | Most, object-oriented programs have imperfectly designed inheritance hierarchies and imperfectly factored methods, and these imperfections tend to increase with maintenance. Hence, even object-oriented programs are more expensive to maintain, harder to understand and larger than necessary. Automatic restructuring of inheritance hierarchies and refactoring of methods can improve the design of inheritance hierarchies, and the factoring of methods. This results in programs being smaller, having better code re-use and being more consistent. This paper describes Guru, a prototype tool for automatic inheritance hierarchy restructuring and method refactoring of Self programs. Results from realistic applications of the tool are presented. |
| Date | 1996 |
| Proceedings Title | Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications |
| Place | San Jose, California, United States |
| Publisher | ACM |
| Pages | 235-250 |
| DOI | 10.1145/236337.236361 |
| ISBN | 0-89791-788-X |
| URL | http://portal.acm.org/citation.cfm? id=236361 |
| Accessed | Thu Jul 23 19:08:36 2009 |
| Archive | ACM |
| Date Added | Thu Jul 23 19:08:36 2009 |
| Modified | Thu Jul 23 19:08:36 2009 |
Self doesn't have static classes, so it's not clear how this applies to OO languages like C++ and Java. The approach is to flatten the inheritance hierarchy and then rebuild superclasses to optimally distribute reused methods. The authors point out that Guru will make the optimal allocation based on how the system currently exists, not on how it should have existed.
| Type | Conference Paper |
|---|---|
| Author | Gregor Snelting |
| Author | Frank Tip |
| Abstract | The design of a class hierarchy may be imperfect. For example, a class C may contain a member m not accessed in any C-instance, an indication that m could be eliminated, or moved into a derived class. Furthermore, different subsets of C's members may be accessed from different C-instances, indicating that it might be appropriate to split C into multiple classes. We present a framework for detecting and remediating such design problems, which is based on concept analysis. Our method analyzes a class hierarchy along with a set of applications that use it, and constructs a lattice that provides valuable insights into the usage of the class hierarchy in a specific context. We show how a restructured class hierarchy can be generated from the lattice, and how the lattice can serve as a formal basis for interactive tools for redesigning and restructuring class hierarchies. |
| Date | 1998 |
| Proceedings Title | Proceedings of the 6th ACM SIGSOFT international symposium on Foundations of software engineering |
| Place | Lake Buena Vista, Florida, United States |
| Publisher | ACM |
| Pages | 99-110 |
| DOI | 10.1145/288195.288273 |
| ISBN | 1-58113-108-9 |
| URL | http://portal.acm.org/citation.cfm? id=288273 |
| Accessed | Fri Jun 5 11:28:06 2009 |
| Archive | ACM |
| Date Added | Fri Jun 5 11:28:06 2009 |
| Modified | Fri Jun 5 11:28:06 2009 |
| Type | Book |
|---|---|
| Author | Martin Fowler |
| Author | Kent Beck |
| Author | John Brant |
| Author | William Opdyke |
| Author | Don Roberts |
| Place | Boston |
| Publisher | Addison-Wesley |
| Date | 1999 |
| # of Pages | 431 |
| ISBN | 0201485672, 9780201485677 |
| Library Catalog | Google Books |
| Call Number | QA76.76 R42 F787 R |
| Date Added | Fri Nov 28 13:36:36 2008 |
| Modified | Fri Aug 7 10:08:33 2009 |
http://victoria.lconz.ac.nz.voyager-myvicsso.
vuw.ac.nz/cgi-bin/Pwebrecon.cgi?BBID=999504
| Type | Conference Paper |
|---|---|
| Author | Magdalena Balazinska |
| Author | Ettore Merlo |
| Author | Michel Dagenais |
| Author | Bruno Lagüe |
| Author | Kostas Kontogiannis |
| Date | 2000 |
| Proceedings Title | WCRE '00: Proceedings of the Seventh Working Conference on Reverse Engineering (WCRE'00) |
| Place | Washington, DC, USA |
| Publisher | IEEE Computer Society |
| Pages | 98 |
| ISBN | 0-7695-0881-2 |
| Date Added | Fri Nov 28 13:07:51 2008 |
| Modified | Fri Nov 28 13:07:51 2008 |
| Type | Conference Paper |
|---|---|
| Author | Frank Simon |
| Author | Frank Steinbrückner |
| Author | Claus Lewerentz |
| Abstract | Refactoring is one key issue to increase internal software quality during the whole software lifecycle. Since identifying structures where refactorings should be applied often is explained with subjective perceptions like "bad taste" or "bad smell" an automatic refactoring location finder seems difficult. We show that a special kind of metrics can support these subjective perceptions and thus can be used as effective and efficient way to get support for the decision where to apply which refactoring. Due to the fact that the software developer is the last authority we provide powerful and metrics based software visualisation to support the developers judging their products. In this paper we demonstrate this approach for four typical refactorings and present both a tool supporting the identification and case studies of its application. |
| Date | 2001 |
| Proceedings Title | Proceedings of the Fifth European Conference on Software Maintenance and Reengineering |
| Publisher | IEEE Computer Society |
| Pages | 30 |
| ISBN | 0-7695-1028-0 |
| URL | http://portal.acm.org/citation.cfm? id=794203.795287 |
| Accessed | Wed Dec 17 10:33:05 2008 |
| Archive | ACM |
| Date Added | Wed Dec 17 10:33:05 2008 |
| Modified | Wed Dec 17 10:33:05 2008 |
Discusses how some smells can be interpreted via metrics, primarily coupling and cohesion. The emphasis is on visualization.
Relevance: 4
| Type | Conference Paper |
|---|---|
| Author | Yuming Zhou |
| Author | Baowen Xu |
| Author | Jianjun Zhao |
| Author | Hongji Yang |
| Abstract | Class cohesion could be used to evaluate the design quality of classes, to develop test measures for object-oriented software and to restructure poorly designed classes. Among a number of class cohesion measures proposed in the last decade, H. S. Chae's measure is based on the structure of the reference graph of a class, which overcomes the limitations of most class cohesion measures. However, it only considers the patterns of interactions among the members of a class partly and hence does not satisfy monotonicity, which might cause the measuring results inconsistent with intuition in some cases. This paper first analyzes the limitations of typical cohesion measures for classes in detail, and then proposes an improved cohesion measure ICBMC. Finally, this paper exemplifies the advantages and applications of ICBMC. |
| Date | 2002 |
| Proceedings Title | Proceedings of the International Conference on Software Maintenance (ICSM'02) |
| Publisher | IEEE Computer Society |
| Pages | 44-53 |
| DOI | 10.1109/ICSM.2002.1167746 |
| ISBN | 0-7695-1819-2 |
| Short Title | ICBMC |
| URL | http://portal.acm.org/citation.cfm? id=879764 |
| Accessed | Mon Apr 20 19:16:36 2009 |
| Archive | ACM |
| Date Added | Mon Apr 20 19:16:36 2009 |
| Modified | Fri Aug 27 12:31:56 2010 |
ICMBC is an improvement on the graph-based CMBC cohesion metric. This paper also discusses how this metric can be used for restructuring classes.
Uses the term "reference graph" for graphs showing the interdependencies of methods and attributes.
Discusses drawbacks of some other metrics.
Relevance: 5
| Type | Thesis |
|---|---|
| Author | Thomas Dudziak |
| Author | Jan Wloka |
| Abstract | Software systems are changed throughout their entire life, e.g. to adapt it to changed environments or to incorporate new features. Refactoring deals with restructuring a system in such a way that these changes can be implemented without problems. Manual refactoring however is costly and error prone so that tools are preferred which handle certain tasks in a fast and reliable way. We present an approach for creating a tool that supports the developer in three important areas: 1. The tool is able to detect structural weaknesses automatically, and to report them to the developer. A tool can perform this task much faster and more thorough, even though only a limited range of problems in the structure are detectable by tools. 2. In addition, it can determine for certain problems which kinds of restructuring would provide the most benefit. This type of analysis is especially difficult for developers. 3. For certain kinds of restructuring it can assess whether they are applicable, and it then can perform them in an automated fashion. Especially restructuring is particularly suited for automatization. We use simple program representations (abstract syntax tree) and commonplace static analysis in order to implement a prototypical add-in for the NetBeans IDE. |
| Type | Master's thesis |
| University | Technical University of Berlin |
| Date | February 2002 |
| # of Pages | 200 |
| Date Added | Mon Aug 3 13:35:40 2009 |
| Modified | Mon Aug 3 13:47:45 2009 |
| Type | Conference Paper |
|---|---|
| Author | Y. Kataoka |
| Author | T. Imai |
| Author | H. Andou |
| Author | T. Fukaya |
| Abstract | Program refactoring is a technique to enhance the maintainability of a program. Although the concept itself is considered to be effective, there are few quantitative evaluation of its impact to the software maintainability. It is sometimes difficult to judge whether the refactoring in question should be applied or not without knowing the effect accurately. We propose a quantitative evaluation method to measure the maintainability enhancement effect of program refactoring. We focused on the coupling metrics to evaluate the refactoring effect. By comparing the coupling before and after the refactoring, we could evaluate the degree of maintainability enhancement. We applied our method to a certain program and showed that our method was really effective to quantify the refactoring effect and helped us to choose appropriate refactorings. |
| Date | 2002-10-03 |
| Conference Name | 18th IEEE International Conference on Software Maintenance (ICSM'02) |
| URL | http://www2.computer.org/portal/web/csdl/doi/10.1109/ICSM.2002.1167822 |
| Accessed | Mon Aug 31 14:23:52 2009 |
| Date Added | Mon Aug 31 14:23:52 2009 |
| Modified | Mon Aug 31 14:26:41 2009 |
| Type | Book Section |
|---|---|
| Author | Hironori Washizaki |
| Author | Yoshiaki Fukazawa |
| Abstract | We propose a new refactoring “Extract Component” to support the organizational reuse of components and improve the productivity under Agile methods. Our refactoring can extract reusable components composed of classes from object-oriented programs, and modify the surrounding parts of extracted components in original programs. We have developed a tool that performs our refactoring automatically. |
| Book Title | Extreme Programming and Agile Processes in Software Engineering |
| Date | 2003 |
| Pages | 1016 |
| URL | http://dx.doi.org/10.1007/3-540-44870-5_42 |
| Accessed | Tue Apr 21 11:12:26 2009 |
| Library Catalog | SpringerLink |
| Date Added | Tue Apr 21 11:12:26 2009 |
| Modified | Tue Apr 21 11:12:26 2009 |
| Type | Journal Article |
|---|---|
| Author | Christopher Myers |
| Abstract | Software systems emerge from mere keystrokes to form intricate functional networks connecting many collaborating modules, objects, classes, methods, and subroutines. Building on recent advances in the study of complex networks, I have examined software collaboration graphs contained within several open-source software systems, and have found them to reveal scale-free, small-world networks similar to those identified in other technological, sociological, and biological systems. I present several measures of these network topolo- gies, and discuss their relationship to software engineering practices. I also present a simple model of software system evolution based on refactoring processes which captures some of the salient features of the observed systems. Some implications of object-oriented design for questions about network robustness, evolvability, degeneracy, and organization are discussed in the wake of these findings. |
| Publication | Physical Review |
| Volume | E 68 |
| Date | October 20, 2003 |
| DOI | 10.1103/PhysRevE.68.046116 |
| Date Added | Mon Jan 5 17:03:26 2009 |
| Modified | Mon Jan 5 17:50:12 2009 |
This is a broad-ranging paper that considers software systems relative to other emergent systems, including biological and social systems. It discussing refactoring, evolution, intelligent design, and design patterns.
Relevance: 5
| Type | Journal Article |
|---|---|
| Author | T Mens |
| Author | T Tourwe |
| Abstract | We provide an extensive overview of existing research in the field of software refactoring. This research is compared and discussed based on a number of different criteria: the refactoring activities that are supported, the specific techniques and formalisms that are used for supporting these activities, the types of software artifacts that are being refactored, the important issues that need to be taken into account when building refactoring tool support, and the effect of refactoring on the software process. A running example is used to explain and illustrate the main concepts. |
| Publication | Software Engineering, IEEE Transactions on |
| Volume | 30 |
| Issue | 2 |
| Pages | 139, 126 |
| Date | 2004 |
| URL | http://ieeexplore.ieee.org/xpls/abs_all.jsp? arnumber=1265817 |
| Accessed | Wed Mar 4 15:00:19 2009 |
| Library Catalog | CiteULike |
| Date Added | Wed Mar 4 15:00:19 2009 |
| Modified | Wed Mar 4 15:00:19 2009 |
| Type | Conference Paper |
|---|---|
| Author | Xia Xu |
| Author | Chung-Horng Lung |
| Author | Marzia Zaman |
| Author | Anand Srinivasan |
| Abstract | Program restructuring is a key method for improving the quality of ill-structured programs, thereby increasing the understandability and reducing the maintenance cost. It is a challenging task and a great deal of research is still ongoing. This paper presents an approach to program restructuring at the function level, based on clustering techniques with cohesion as the major concern. Clustering has been widely used to group related entities together. The approach focuses on automated support for identifying ill-structured or low-cohesive functions and providing heuristic advice in both the development and evolution phases. A new similarity measure is defined and studied intensively. The approach is applied to restructure a real industrial program. The empirical observations show that the heuristic advice provided by the approach can help software designers make better decision of why and how to restructure a program. Specific source code level software metrics are presented to demonstrate the value of the approach. |
| Date | 2004 |
| Proceedings Title | Proceedings of the Source Code Analysis and Manipulation, Fourth IEEE International Workshop |
| Publisher | IEEE Computer Society |
| Pages | 75-84 |
| ISBN | 0-7695-2144-4 |
| Accessed | Fri Dec 12 17:36:50 2008 |
| Archive | ACM |
| Date Added | Fri Dec 12 17:36:50 2008 |
| Modified | Tue Aug 11 10:48:48 2009 |
http://portal.acm.org/citation.cfm?id=1022147
| Type | Conference Paper |
|---|---|
| Author | B. Du Bois |
| Author | S. Demeyer |
| Author | J. Verelst |
| Abstract | Refactorings are widely recognised as ways to improve the internal structure of object-oriented software while maintaining its external behaviour. Unfortunately, refactorings concentrate on the treatment of symptoms (the so called code-smells), thus improvements depend a lot on the skills of the maintained coupling and cohesion on the other hand are quality attributes which are generally recognized as being among the most likely quantifiable indicators for software maintainability. Therefore, this paper analyzes how refactorings manipulate coupling/cohesion characteristics, and how to identify refactoring opportunities that improve these characteristics. As such we provide practical guidelines for the optimal usage of refactoring in a software maintenance process. |
| Date | 2004 |
| Proceedings Title | Proceedings. 11th Working Conference on Reverse Engineering, 2004. |
| Conference Name | 11th Working Conference on Reverse Engineering, 2004. |
| Pages | 144-151 |
| DOI | 10.1109/WCRE.2004.33 |
| ISBN | 1095-1350 |
| Archive | IEEE Xplore |
| Date Added | Tue Apr 21 10:52:41 2009 |
| Modified | Mon Jul 20 16:59:53 2009 |
Has a (+0-) table that shows the qualitative effects of various refactorings on coupling and cohesion measurements. Surprise, many refactorings could make things better or worse.
Relevance: 3
| Type | Conference Paper |
|---|---|
| Author | Mirko Streckenbach |
| Author | Gregor Snelting |
| Abstract | KABA is an innovative system for refactoring Java class hierar-chies. It uses the Snelting/Tip algorithm [13] in order to determine a behavior-preserving refactoring which is optimal with respect to a given set of client programs. KABA can be based on dynamic as well as static program analysis. The static variant will preserve program behavior for all possible input values; the dynamic version guarantees preservation of behavior for all runs in a given test suite. KABA offers automatic refactoring as well as manual refactoring using a dedicated editor. |
| Date | 2004 |
| Proceedings Title | Proceedings of the 19th annual ACM SIGPLAN conference on object-oriented programming, systems, languages, and applications |
| Conference Name | OOPSLA-2004 |
| Place | Vancouver, BC, Canada |
| Publisher | ACM |
| Pages | 315-330 |
| DOI | 10.1145/1028976.1029003 |
| ISBN | 1-58113-831-9 |
| Accessed | Mon May 4 18:50:15 2009 |
| Archive | ACM |
| Date Added | Mon May 4 18:50:15 2009 |
| Modified | Thu Aug 13 10:37:43 2009 |
http://portal.acm.org/citation.cfm?id=1028976.1029003
| Type | Conference Paper |
|---|---|
| Author | M.J. Munro |
| Abstract | Refactoring can have a direct influence on reducing the cost of software maintenance through changing the internal structure of the source-code to improve the overall design that helps the present and future programmers evolve and understand a system. Bad smells are a set of design problems with refactoring identified as a solution. Locating these bad smells has been described as more a human intuition than an exact science. This paper addresses the issue of identifying the characteristics of a bad smell through the use of a set of software metrics. Then by using a pre-defined set of interpretation rules to interpret the software metric results applied to Java source-code, the software engineer can be provided with significant guidance as to the location of bad smells. These issues are addressed in a number of ways. Firstly, a precise definition of bad smells is given from the informal descriptions given by the originators Fowler and Beck. The characteristics of the bad smells have been used to define a set of measurements and interpretation rules for a subset of the bad smells. A prototype tool has been implemented to enable the evaluation of the interpretation rules in two case studies. |
| Date | 2005 |
| Proceedings Title | Software Metrics, 2005. 11th IEEE International Symposium |
| Conference Name | Software Metrics, 2005. 11th IEEE International Symposium |
| Pages | 15 |
| ISBN | 1530-1435 |
| Archive | IEEE Xplore |
| Date Added | Thu Mar 5 14:44:50 2009 |
| Modified | Thu Mar 5 14:44:50 2009 |
A fairly lightweight paper about automatically detecting lazy classes and temporary fields.
Relevance: 3
| Type | Thesis |
|---|---|
| Author | Jason Daniel Skowronski |
| Type | Master's thesis |
| University | University of Illinois at Urbana-Champaign |
| Date | 2005 |
| # of Pages | 29 |
| URL | http://worldcat.org/oclc/73801302 |
| Accessed | Tue Dec 1 10:56:22 2009 |
| Library Catalog | ScientificCommons |
| Date Added | Tue Dec 1 10:56:21 2009 |
| Modified | Tue Dec 1 10:57:48 2009 |
Worked with Danny Dig. Used the Eclipse metrics plug-in.
| Type | Conference Paper |
|---|---|
| Author | Serge Demeyer |
| Author | Filip Van Rysselberghe |
| Author | Tudor Girba |
| Author | Jacek Ratzinger |
| Author | Radu Marinescu |
| Author | Tom Mens |
| Author | Bart Du Bois |
| Author | Dirk Janssens |
| Author | Stéphane Ducasse |
| Author | Michele Lanza |
| Author | Matthias Rieger |
| Author | Harald Gall |
| Author | Mohammad El-Ramly |
| Abstract | The notion of refactoring - transforming the sourcecode 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. |
| Date | 2005 |
| Proceedings Title | Proceedings of the Eighth International Workshop on Principles of Software Evolution |
| Publisher | IEEE Computer Society |
| Pages | 123-134 |
| ISBN | 0-7695-2349-8 |
| Short Title | The LAN-simulation |
| URL | http://portal.acm.org/citation.cfm? id=1107840.1108151 |
| Accessed | Mon Sep 28 12:53:25 2009 |
| Archive | ACM |
| Date Added | Mon Sep 28 12:53:25 2009 |
| Modified | Mon Sep 28 12:53:25 2009 |
| Type | Conference Paper |
|---|---|
| Author | Robert L. Akers |
| Author | Ira D. Baxter |
| Author | Michael Mehlich |
| Author | Brian J. Ellis |
| Author | Kenn R. Luecke |
| Date | 2005 |
| Proceedings Title | WCRE '05: Proceedings of the 12th Working Conference on Reverse Engineering |
| Place | Washington, DC, USA |
| Publisher | IEEE Computer Society |
| Pages | 13―22 |
| DOI | http://dx.doi.org/10.1109/WCRE.2005.25 |
| ISBN | 0-7695-2474-5 |
| Date Added | Fri Nov 28 12:27:41 2008 |
| Modified | Fri Nov 28 12:27:41 2008 |
AST-to-AST rewriting engine, ability to specify and apply source-to-source program transformations based on language syntax, ties rules to grammar elements
DMS has been under development for nine years. As presently constituted, it has been used for a variety of large scale commercial activities, including crossplatform migrations, domain-specific code generation, and construction of a variety of conventional software engineering tools implementing tasks such as dead/clone code elimination, test code coverage, execution profiling, source code browsing, and static metrics analysis.
Relevance: 5
| Type | Conference Paper |
|---|---|
| Author | Douglas Kirk |
| Author | Marc Roper |
| Author | Neil Walkinshaw |
| Date | 2005 |
| Proceedings Title | Beyond Program Slicing |
| Date Added | Wed May 6 10:25:55 2009 |
| Modified | Wed May 6 10:25:55 2009 |
| Type | Book |
|---|---|
| Author | Joshua Kerievsky |
| Publisher | Addison-Wesley |
| Date | 2005 |
| ISBN | 0321213351 |
| Date Added | Fri Nov 28 13:07:22 2008 |
| Modified | Mon Dec 22 09:16:31 2008 |
Discusses when code should be refactored to use a design pattern, including indicators in the original code.
Relevance: 5
Pattern catalog is at http://www.industriallogic.com/xp/refactoring/catalog.html
| Type | Conference Paper |
|---|---|
| Author | Ira Baxter |
| Author | Jeff Gray |
| Date | October 24-27, 2005 |
| Conference Name | OMG's Second Annual Architecture-Driven Modernization Workshop |
| Place | October 24-27, 2005 |
| Date Added | Mon Dec 1 11:38:51 2008 |
| Modified | Mon Dec 1 11:41:25 2008 |
This tutorial discusses program transformations via rewrite rules, including the mathematical basis and the desirable components of a transformation system.
Relevance: 5
| Type | Web Page |
|---|---|
| Author | Adrian Trifu |
| Author | Radu Marinescu |
| Abstract | Software decay is a phenomenon that plagues aging software systems. While in recent years, there has been significant progress in the area of automatic detection of “code smells” on one hand, and code refactorings on the other hand, we claim that existing restructuring practices are seriously hampered by their symptomatic and informal (nonrepeatable) nature. This paper makes a clear distinction between structural problems and structural symptoms (also known as code smells), and presents a novel, causal approach to restructuring object oriented systems. Our approach is based on two innovations: the encapsulation of correlations of symptoms and additional contextual information into higher-level design problems, and the univocal, explicit mapping of problems to unique refactoring solutions. Due to its explicit, repeatable nature, the approach shows high potential for increased levels of automation in the restructuring process, and consequently a decrease in maintenance costs. |
| Website Type | text |
| Date | 2005-11-07 |
| URL | http://www2.computer.org/portal/web/csdl/doi/10.1109/WCRE.2005.15 |
| Accessed | Wed Aug 5 09:01:19 2009 |
| Date Added | Wed Aug 5 09:01:18 2009 |
| Modified | Wed Aug 5 09:04:59 2009 |
| Type | Book |
|---|---|
| Author | Phillip A. Laplante |
| Author | Colin J. Neill |
| Publisher | CRC Press |
| Date | 2005-12-15 |
| # of Pages | 344 |
| ISBN | 9780849329944 |
| Short Title | AntiPatterns |
| Library Catalog | Google Books |
| Date Added | Sun Jun 6 08:29:38 2010 |
| Modified | Sun Jun 6 08:29:38 2010 |
Uses "refactor relentlessly"
| Type | Conference Paper |
|---|---|
| Author | S. Counsell |
| Author | Y. Hassoun |
| Author | G. Loizou |
| Author | R. Najjar |
| Abstract | Refactoring, as a software engineering discipline has emerged over recent years to become an important aspect of maintaining software. Refactoring refers to the restructuring of software according to specific mechanics and principles. In this paper, we describe an analysis of the results from a tool whose purpose was to identify and extract refactorings from seven open-source Java systems. In particular, we analyzed the mechanics of the most commonly and least commonly applied refactorings to try and account for their frequency. Results showed the most common refactorings of the fifteen coined a ‘Gang of Six’, to be generally those with a high in-degree and low out-degree when mapped on a dependency graph; the same refactorings also featured strongly in the remedying of bad code smells. Remarkably and surprisingly, inheritance and encapsulation- based refactorings were found to have been applied relatively infrequently - we offer explanations for why this may be the case. The paper thus identifies ‘core’ refactorings central to many of the changes made by developers on open-source systems. While we can not guarantee that developers consciously undertake refactoring in any sense, the empirical results demonstrate that simple renaming and moving fields/methods between classes are common components of open-source system re-engineering. From a wider software engineering perspective, knowledge of what a modification will incur in likely sub-tasks is of value to developers whether working on open-source or other forms of software. |
| Date | 2006 |
| Proceedings Title | Proceedings of the 2006 ACM/IEEE International symposium on empirical software engineering - ISESE '06 |
| Place | Rio de Janeiro, Brazil |
| Pages | 288 |
| DOI | 10.1145/1159733.1159777 |
| URL | http://portal.acm.org/citation.cfm? id=1159777&dl=ACM&… |
| Accessed | Wed Nov 24 22:20:22 2010 |
| Library Catalog | CrossRef |
| Date Added | Wed Nov 24 22:20:22 2010 |
| Modified | Mon Jan 24 18:06:09 2011 |
| Type | Conference Paper |
|---|---|
| Author | Mathieu Verbaere |
| Author | Arnaud Payement |
| Author | Oege de Moor |
| Abstract | We describe JunGL, a language to script refactoring transformations. It manipulates a graph representation of the program, including extensible semantic information such as variable binding and dataflow. JunGL enables the full automation of complex refactorings: finding program elements of interest, checking preconditions and performing the transformation itself. |
| Date | 2006 |
| Proceedings Title | Companion to the 21st ACM SIGPLAN symposium on Object-oriented programming systems, languages, and applications |
| Place | Portland, Oregon, USA |
| Publisher | ACM |
| Pages | 651-652 |
| DOI | 10.1145/1176617.1176656 |
| ISBN | 1-59593-491-X |
| URL | http://portal.acm.org/citation.cfm? id=1176656# |
| Accessed | Mon Dec 8 10:14:23 2008 |
| Archive | ACM |
| Date Added | Mon Dec 8 10:14:23 2008 |
| Modified | Mon Dec 8 10:14:23 2008 |
Talks about a scripting language for transformations that is a hybrid of a functional and a logical query language. It has been used to recognize and perform three different refactorings.
Relevance: 5
| Type | Conference Paper |
|---|---|
| Author | Stan Jarzabek |
| Date | 2006 |
| Proceedings Title | APSEC '06: Proceedings of the XIII Asia Pacific Software Engineering Conference |
| Place | Washington, DC, USA |
| Publisher | IEEE Computer Society |
| Pages | 293―300 |
| DOI | http://dx.doi.org/10.1109/APSEC.2006.37 |
| ISBN | 0-7695-2685-3 |
| Date Added | Fri Nov 28 13:07:52 2008 |
| Modified | Fri Nov 28 13:07:52 2008 |
Gives some good background on similarity, how it can be removed, but also some on why it can't or shouldn't be removed. He then discusses his "generative meta-programming technique."
Relevance: 3
| Type | Book Section |
|---|---|
| Author | Francesco Logozzo |
| Author | Agostino Cortesi |
| Abstract | A semantics-based framework is presented for the definition and manipulation of class hierarchies for object-oriented languages. The framework is based on the notion of observable of a class, i.e., an abstraction of its semantics when focusing on a behavioral property of interest. We define a semantic subclass relation, capturing the fact that a subclass preserves the behavior of its superclass up to a given (tunable) observed property. We study the relation between syntactic subclass, as present in mainstream object-oriented languages, and the notion of semantic subclass. The approach is then extended to class hierarchies, leading to a semantics-based modular treatment of a suite of basic observable-preserving operators on hierarchies. We instantiate the framework by presenting effective algorithms that compute a semantic superclass for two given classes, that extend a hierarchy with a new class, and that merge two hierarchies by preserving semantic subclass relations. |
| Book Title | Verification, Model Checking, and Abstract Interpretation |
| Date | 2006 |
| Pages | 313-331 |
| URL | http://dx.doi.org/10.1007/11609773_21 |
| Accessed | Fri Jun 5 10:49:24 2009 |
| Library Catalog | SpringerLink |
| Date Added | Fri Jun 5 10:49:24 2009 |
| Modified | Fri Jun 5 10:49:24 2009 |
| Type | Conference Paper |
|---|---|
| Author | Raul Marticorena |
| Author | Carlos López |
| Author | Yania Crespo |
| Abstract | Bad Smells define in an informal way code flaws, in order to suggest refactorings, their aim is to improve the design of the code. Current taxonomies group code smells, making use of similarity or correlation criteria between them, and leading to a manual revision of the code. By other side, it is suggested the assistance of using metrics in the detection of bad smells. Metrics can be collected automatically helping to suggest the presence of flaws. Nevertheless, current taxonomies do not link these concepts. This work tries to establish additional criteria when we want to classify bad smells. These criteria are also related to metric features. Following the current classifications, we propose a method to evaluate the suitability of the tools assisting bad code smell detection, as well as selection and implementation of metrics linked with bad code smells. |
| Date | 2006 |
| Proceedings Title | 7th ECCOP International Workshop on Object-Oriented Reengineering |
| URL | http://www.giro.infor.uva.es/Publications/2006/MLC06/ |
| Accessed | Thu Mar 5 14:54:02 2009 |
| Archive | CiteULike |
| Date Added | Thu Mar 5 14:54:02 2009 |
| Modified | Fri Apr 16 14:32:35 2010 |
The authors discuss the connection between metrics and code smells by adding classifiers to both, and seeing where the classifiers agree in order to determine which metrics are related to which code smells.
| Type | Journal Article |
|---|---|
| Author | István-Gergely Czibula |
| Author | Gabriela Serban |
| Abstract | Clustering is a division of data into groups of similar objects, a data mining activity that aims to differentiate groups inside a given set of objects, with respect to a set of relevant attributes of the analyzed objects. Refactoring is the process of improving the design of software systems. Its goal is to change a software system in such a way that it does not alter the external behavior of the code, but improves its internal structure ([9]). This paper aims at presenting a new approach for improving systems design using clustering. Clustering is used in order to recondition the class structure of a software system. The proposed approach can be useful for assisting software engineers in their daily works of refactoring software systems. We evaluate our approach using the open source case study JHotDraw ([18]) based on two newly defined measures. A comparison with previous approaches is also provided. |
| Publication | IJCSNS International Journal of Computer Science and Network Security |
| Volume | 6 |
| Issue | 12 |
| Pages | 40-49 |
| Date | 2006 |
| Date Added | Thu Jul 23 18:41:48 2009 |
| Modified | Thu Jul 23 18:45:20 2009 |
| Type | Conference Paper |
|---|---|
| Author | Olaf Seng |
| Author | Johannes Stammel |
| Author | David Burkhart |
| Abstract | A software system's structure degrades over time, a phenomenon that is known as software decay or design drift. Since the quality of the structure has major impact on the maintainability of a system, the structure has to be reconditioned from time to time. Even if recent advances in the fields of automated detection of bad smells and refactorings have made life easier for software engineers, this is still a very complex and resource consuming task. Search-based approaches have turned out to be helpful in aiding a software engineer to improve the subsystem structure of a software system. In this paper we show that such techniques are also applicable when reconditioning the class structure of a system. We describe a novel search-based approach that assists a software engineer who has to perform this task by suggesting a list of refactorings. Our approach uses an evolutionary algorithm and simulated refactorings that do not change the system's externally visible behavior. The approach is evaluated using the open-source case study JHotDraw. |
| Date | 2006 |
| Proceedings Title | Proceedings of the 8th annual conference on Genetic and evolutionary computation |
| Place | Seattle, Washington, USA |
| Publisher | ACM |
| Pages | 1909-1916 |
| DOI | 10.1145/1143997.1144315 |
| ISBN | 1-59593-186-4 |
| Accessed | Wed Dec 17 12:18:50 2008 |
| Archive | ACM |
| Date Added | Wed Dec 17 12:18:50 2008 |
| Modified | Tue Aug 11 10:50:51 2009 |
http://portal.acm.org/citation.cfm?doid=1143997.1144315
The paper concentrates on the "move method" refactoring. While they advocate a genetic algorithm kind of approach, they also build in a lot of special case knowledge about where to do crossovers, etc.
Relevance: 4
| Type | Conference Paper |
|---|---|
| Author | Y. Crespo |
| Author | C. Lopez |
| Author | R. Marticorena |
| Abstract | To detect flaws, bad smells, etc, we often use quantitative methods: metrics or measures. It is common in practice to use thresholds to set the correctness of the measures. Most of the current tools use generic values. Nevertheless, there is a certain concern about the effects of threshold applications on obtained values. Current research is working on case studies of thresholds for several products and different versions. However, product domain and size could also affect the results, so we deal with the question of using generic vs. relative thresholds, looking at what effects this could have in bad smell detection. |
| Date | 2006 |
| Proceedings Title | QAOOSE 2006 Proceedings |
| Pages | 109 |
| Short Title | Relative Thresholds |
| Archive | Google Scholar |
| Date Added | Thu Mar 5 14:18:11 2009 |
| Modified | Mon Nov 30 16:43:40 2009 |
| Type | Magazine Article |
|---|---|
| Author | Leif Frenzel |
| Publication | Eclipse Magazin |
| Volume | 5 |
| Date | January, 2006 |
| URL | http://www.eclipse.org/articles/Article-LTK/ltk.html |
| Date Added | Mon Dec 1 11:43:20 2008 |
| Modified | Wed Feb 3 15:26:45 2010 |
Describes some of the specific Eclipse refactoring APIs.
Relevance: 5
| Type | Magazine Article |
|---|---|
| Author | Tobias Widmer |
| Publication | Eclipse Magazine |
| Date | July 4, 2006 |
| URL | http://www.eclipse.org/articles/article.php? file=Article-Unleashing-the-Power-of-Refactoring/index.html |
| Date Added | Mon Dec 1 12:01:23 2008 |
| Modified | Wed Mar 4 15:05:26 2009 |
Describes how some of the specific Eclipse refactoring APIs are used within an example.
Relevance: 5
| Type | Conference Paper |
|---|---|
| Author | K Stroggylos |
| Author | D Spinellis |
| Abstract | 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. |
| Date | 2007 |
| Proceedings Title | Software Quality, 2007. WoSQ'07: ICSE Workshops 2007. Fifth International Workshop on |
| Pages | 10, 10 |
| URL | http://dx.doi.org/10.1109/WOSQ.2007.11 |
| Accessed | Wed Mar 4 14:52:27 2009 |
| Archive | CiteULike |
| Date Added | Wed Mar 4 14:52:26 2009 |
| Modified | Wed Mar 4 14:52:26 2009 |
| Type | Journal Article |
|---|---|
| Author | Frank Tip |
| 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. |
| Publication | Static Analysis |
| Pages | 1–17 |
| Date | 2007 |
| Date Added | Thu Nov 25 10:33:59 2010 |
| Modified | Thu Nov 25 10:37:26 2010 |
| Type | Journal Article |
|---|---|
| Author | T. Bodhuin |
| Author | G. Canfora |
| Author | L. Troiano |
| Abstract | In this paper we introduce SORMASA, SOftware Refactor- ing using software Metrics And Search Algorithms, a refactoring decision support tool based on optimization techniques, in particular Genetic Algorithms. |
| Publication | 1st Workshop on Refactoring Tools (WRT'07) |
| Pages | 23-24 |
| Date | 2007 |
| Date Added | Fri Mar 4 08:18:20 2011 |
| Modified | Fri Mar 4 15:44:31 2011 |
| Type | Conference Paper |
|---|---|
| Author | Marios Fokaefs |
| Author | Nikolaos Tsantalis |
| Author | Alexander Chatzigeorgiou |
| Abstract | In this demonstration we present an Eclipse plug-in that identifies feature envy bad smells in Java projects and resolves them by applying the appropriate move method refactorings. The main contribution is the ability to pre-evaluate the impact of all possible move refactorings on design quality and apply the most effective one. |
| Date | 2007 |
| Conference Name | IEEE International Conference on Software Maintenance, ICSM 2007. |
| Pages | 519-520 |
| ISBN | 1063-6773 |
| Short Title | JDeodorant |
| Archive | IEEE Xplore |
| Date Added | Thu Jul 23 18:57:00 2009 |
| Modified | Thu Jul 23 19:02:06 2009 |
| Type | Conference Paper |
|---|---|
| Author | E. Mealy |
| Author | D. Carrington |
| Author | P. Strooper |
| Author | P. Wyeth |
| Abstract | Post-deployment maintenance and evolution can account for up to 75% of the cost of developing a software system. Software refactoring can reduce the costs associated with evolution by improving system quality. Although refactoring can yield benefits, the process includes potentially complex, error-prone, tedious and time-consuming tasks. It is these tasks that automated refactoring tools seek to address. However, although the refactoring process is well-defined, current refactoring tools do not support the full process. To develop better automated refactoring support, we have completed a usability study of software refactoring tools. In the study, we analysed the task of software refactoring using the ISO 9241-11 usability standard and Fitts' List of task allocation. Expanding on this analysis, we reviewed 11 collections of usability guidelines and combined these into a single list of 38 guidelines. From this list, we developed 81 usability requirements for refactoring tools. Using these requirements, the software refactoring tools Eclipse 3.2, Condenser 1.05, RefactorIT 2.5.1, and Eclipse 3.2 with the Simian UI 2.2.12 plugin were studied. Based on the analysis, we have selected a subset of the requirements that can be incorporated into a prototype refactoring tool intended to address the full refactoring process. |
| Date | 2007 |
| Proceedings Title | Software Engineering Conference, 2007. ASWEC 2007. 18th Australian |
| Conference Name | Software Engineering Conference, 2007. ASWEC 2007. 18th Australian |
| Pages | 307-318 |
| ISBN | 1530-0803 |
| Archive | IEEE Xplore |
| Date Added | Mon Dec 8 15:22:09 2008 |
| Modified | Mon Dec 8 15:22:09 2008 |
Usability issues and guidelines for refactoring tools.
Relevance: 3
| Type | Journal Article |
|---|---|
| Author | István-Gergely Czibula |
| Author | Gabriela Serban |
| Abstract | Improving the quality of software systems design is the most important issue during the evolution of object oriented software systems. In this paper we are focusing on the problem of determining refactorings that can be used in order to improve the design of object oriented software systems. Refactoring ([6]) is a major issue to improve internal software quality. This paper aims at presenting a new hierarchical agglomerative clustering algorithm, HARS (Hierarchical agglomerative clustering algorithm for restructuring software systems), that identifies the refactorings needed in order to restructure a software system. Clustering([10]) is used in order to recondition the class structure of the system. The proposed approach can be useful for assisting software engineers in their daily works of refactoring software systems. We evaluate our approach using the open source case study JHotDraw ([7]), emphasizing its advantages in comparison with existing approaches. |
| Publication | INFOCOMP Journal of Computer Science, Brasil |
| Volume | 6 |
| Pages | 43–51 |
| Date | 2007 |
| Date Added | Thu Jul 23 18:49:50 2009 |
| Modified | Thu Jul 23 18:53:46 2009 |
| Type | Conference Paper |
|---|---|
| Author | István-Gergely Czibula |
| Author | Gabriela Serban |
| Date | 2007 |
| Proceedings Title | Proceedings of the First International Conference on Knowledge Engineering: Principles and Techniques |
| Conference Name | KEPT 2007 |
| Pages | 316-323 |
| Date Added | Thu Jul 23 18:37:22 2009 |
| Modified | Thu Dec 10 14:22:59 2009 |
| Type | Conference Paper |
|---|---|
| Author | Adrian Trifu |
| Author | Urs Reupke |
| Abstract | Software aging is an important cost contributor to the maintenance of aging software systems. Recent years have brought significant progress in the area of automatic detection of "code smells" as well as tool support for refactoring and implementing design patterns in the code. Nonetheless, there is hardly any tool support to help the maintainer decide how to refactor in a given situation, such that the recommended refactorings are also meaningful in that particular situation. Most of the existing techniques are either merely supporting the process, such as visualizations, or cannot guarantee meaningful refactorings, such as optimization based techniques. This paper introduces and experimentally evaluates a novel, tool supported approach to determine meaningful refactorings to structural flaws in object oriented systems. The refactorings recommended by our approach are guaranteed to lead to a meaningful and more maintainable structure in each analyzed situation. The approach contributes to a dramatic reduction of costs, by reducing the need and scope of detailed, manual code analysis. |
| Date | 2007 |
| Proceedings Title | Proceedings of the 11th European Conference on Software Maintenance and Reengineering |
| Publisher | IEEE Computer Society |
| Pages | 39-48 |
| ISBN | 0-7695-2802-3 |
| URL | http://portal.acm.org/citation.cfm? id=1252822 |
| Accessed | Wed Aug 5 09:07:22 2009 |
| Archive | ACM |
| Date Added | Wed Aug 5 09:07:22 2009 |
| Modified | Wed Aug 5 09:07:22 2009 |
| Type | Report |
|---|---|
| Author | István-Gergely Czibula |
| Author | Gabriela Serban |
| Abstract | The structure of a software system has a major impact on its maintainability. Refactoring is an activity performed through the entire lifecycle of a software system in order to keep the software structure clean and easy to maintain. We have previously introduced in [3] a clustering approach for identifying refactorings in order to improve the structure of software systems. The aim of this paper is to make a comparative analysis on several clustering algorithms (developed based on the approach from [3]) which can be used in order to recondition the class structure of a software system. Based on this analysis, we highlight the advantages of determining refactorings of object-oriented software systems using clustering. |
| Report Number | Informatica, Volume LII, Number 2 |
| Report Type | Technical Report |
| Place | Cluj-Napoca, Romania |
| Institution | Studia Univ. Babes-Bolyai |
| Date | 2007 |
| Date Added | Thu Jul 23 18:27:07 2009 |
| Modified | Thu Jul 23 18:34:49 2009 |
| Type | Conference Paper |
|---|---|
| Author | G. Serban |
| Author | l.-G. Czibula |
| Abstract | In this paper we are focusing on the problem of restructuring object oriented software systems using clustering techniques. Refactoring ([1]) is one major issue to improve the design of software systems, increasing the internal software quality. This paper aims at introducing a new k-medoids based clustering algorithm that can be used for improving the design of software systems, by identifying the needed refactorings. The algorithm uses a measure that evaluates a software system design. Clustering ([2]) is used in order to recondition the class structure of a software system. The proposed approach can be useful for assisting software engineers in their daily works of refactoring software systems. We evaluate our approach using the open source case study JHotDraw ([3]), illustrating the advantages of our approach in comparison with existing approaches. |
| Date | November 7-9, 2007 |
| Proceedings Title | Proceedings of The 22th International Symposium on Computer and Information Sciences |
| Conference Name | 22nd international symposium on Computer and information sciences, iscis 2007 |
| Place | Ankara, Turkey |
| Pages | 1-6 |
| Archive | IEEE Xplore |
| Date Added | Fri Dec 12 17:14:13 2008 |
| Modified | Tue Jun 15 10:46:35 2010 |
This discusses a variation of k-medoids to cluster attributes, methods, and classes based on cohesion. Interestingly, each object of these three entity types is treated similarly in that they have "property sets" that include objects the other two entity types as well as themselves. Following the clustering run, refactorings are proposed to convert the original system into the proposed one.
Relevance: 5
| Type | Magazine Article |
|---|---|
| Author | Emerson Murphy-Hill |
| Author | Andrew P. Black |
| Abstract | Refactoring tools can improve the speed and accuracy with which developers create and maintain software—but only if they are used. In practice, tools are not used as much as they could be; this seems to be because sometimes they do not align with the refactoring tactic preferred by most programmers, a tactic the authors call "floss refactoring." They propose five principles that characterize successful floss-refactoring tools—principles that can help programmers to choose the most appropriate refactoring tools and also help toolsmiths to design tools that fit the programmer's purpose. |
| Publication | IEEE Software |
| Volume | 25 |
| Issue | 5 |
| Date | 2008 |
| Pages | 38-44 |
| ISSN | 0740-7459 |
| Short Title | Refactoring Tools |
| Library Catalog | IEEE Computer Society |
| Date Added | Sun Sep 12 13:53:13 2010 |
| Modified | Sun Sep 12 13:53:13 2010 |
| Type | Conference Paper |
|---|---|
| Author | I.G. Czibula |
| Author | G. Czibula |
| Abstract | The aim of this paper is to approach the problem of improving the design of an object oriented software system, by identifying the appropriate refactorings. It is well known that improving the quality of software systems design is an important issue during the evolution of object oriented software systems. This improvement can be achieved by refactoring the software system in order to improve its internal structure, but without altering the external behavior of the code. In this paper we introduce a hierarchical divisive clustering algorithm for automatic identification of refactorings that improve the internal structure of a software system. We evaluate our approach using JHotDraw case study and a real software system, emphasizing its advantages in comparison with existing similar approaches. |
| Date | 2008 |
| Proceedings Title | Symbolic and Numeric Algorithms for Scientific Computing, 2008. SYNASC '08. 10th International Symposium on |
| Conference Name | Symbolic and Numeric Algorithms for Scientific Computing, 2008. SYNASC '08. 10th International Symposium on |
| Pages | 253-256 |
| DOI | 10.1109/SYNASC.2008.17 |
| Library Catalog | IEEE Xplore |
| Date Added | Fri Mar 4 14:40:58 2011 |
| Modified | Fri Mar 4 14:40:58 2011 |
| Type | Conference Paper |
|---|---|
| Author | Hannes Kegel |
| Author | Friedrich Steimann |
| Abstract | Because of the strong coupling of classes and the proliferation of unneeded class members induced by inheritance, the suggestion to use composition and delegation instead has become commonplace. The presentation of a corresponding refactoring in the literature may lead one to believe that such a transformation is a straightforward undertaking. However, closer analysis reveals that this refactoring is neither always possible, nor does it necessarily achieve its desired effect. We have therefore identified the necessary preconditions and realizable postconditions of the refactoring, and built a tool that can perform it completely automatically. By applying this tool to all subclasses of several open-source projects, we have collected evidence of the applicability of the refactoring and of its capability to deliver on its promises. The refactoring builds on constraint graphs originally developed for type inference to check the preconditions and to compute the necessary delegation as well as the subtype relationships that must be maintained. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 30th international conference on Software engineering |
| Place | Leipzig, Germany |
| Publisher | ACM |
| Pages | 431-440 |
| DOI | 10.1145/1368088.1368147 |
| ISBN | 978-1-60558-079-1 |
| URL | http://portal.acm.org/citation.cfm? id=1368147&dl=GUIDE&… |
| Accessed | Fri Jun 5 10:17:42 2009 |
| Archive | ACM |
| Date Added | Fri Jun 5 10:17:42 2009 |
| Modified | Fri Jun 5 10:17:42 2009 |
This is a well-written paper that goes into detail about the work needed to convert an inheritance relationship into a delegation relationship. It even discusses IntelliJ's implementation of the refactoring and its problems.
Relevance: 4
| Type | Conference Paper |
|---|---|
| Author | Jens Dietrich |
| Author | Vyacheslav Yakovlev |
| Author | Catherine McCartin |
| Author | Graham Jenson |
| Author | Manfred Duchrow |
| Abstract | We present a novel approach to the analysis of dependency graphs of object-oriented programs. We propose to use the Girvan-Newman clustering algorithm to compute the modular structure of programs. This is useful in assisting software engineers to redraw component boundaries in software, in order to improve the level of reuse and maintainability. The results of this analysis can be used as a starting point for refactoring the software. We present BARRIO, an Eclipse plugin that can detect and visualise clusters in dependency graphs extracted from Java programs by means of source code and byte code analysis. These clusters are then compared with the modular structure of the analysed programs defined by package and container specifications. Two metrics are introduced to measure the degree of overlap between the defined and the computed modular structure. Some empirical results obtained from analysing non-trivial software packages are presented. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 4th ACM Symposium on Software Visualization |
| Place | Ammersee, Germany |
| Publisher | ACM |
| Pages | 91-94 |
| DOI | 10.1145/1409720.1409735 |
| ISBN | 978-1-60558-112-5 |
| Accessed | Fri Dec 19 10:17:13 2008 |
| Archive | ACM |
| Date Added | Fri Dec 19 10:17:13 2008 |
| Modified | Tue Aug 11 10:48:18 2009 |
http://portal.acm.org/citation.cfm?doid=1409720.1409735
Mentions social network concepts like betweenness. Makes use of Jung for the Girvan-Newman algorithm and Prefuse for visualization. The emphasis is on (re)packaging.
Relevance: 4
| Type | Book Section |
|---|---|
| Author | Gabriela Serban |
| Author | István-Gergely Czibula |
| Abstract | It is well-known that maintenance and evolution represent important stages in the lifecycle of any software system (about 66% from the total cost of the software systems development). That is why in this paper we are focusing on the problem of automating an essential activity that appears in the maintenance and evolution of software systems: the problem of identifying refactorings that would improve the structure of the system. Refactoring is the process of improving the design of software systems, by improving their internal structure, without altering the external behavior of the code. The aim of this paper is to introduce a new clustering algorithm, CASYR (Clustering Algorithm for Software Systems Restructuring), that can be used for improving software systems design, by identifying the appropriate refactorings. The proposed approach can be useful for assisting software engineers in their daily work of refactoring software systems. We evaluate our approach on a real software system and we also provide a comparison with previous approaches. |
| Book Title | Artificial Intelligence and Soft Computing - ICAISC 2008 |
| Place | Berlin / Heidelberg |
| Publisher | Springer-Verlag |
| Date | 2008 |
| Pages | 693-704 |
| Accessed | Wed Dec 17 11:34:30 2008 |
| Library Catalog | SpringerLink |
| Date Added | Wed Dec 17 11:34:30 2008 |
| Modified | Mon May 3 13:37:12 2010 |
Describes agglomerative clustering for class formation. They use average link for group merging, stating that it gives better results.
Relevance: 5
http://dx.doi.org/10.1007/978-3-540-69731-2_67
| Type | Conference Paper |
|---|---|
| Author | Chris Parnin |
| Author | Carsten Görg |
| Author | Ogechi Nnadi |
| Abstract | Preserving the integrity of software systems is essential in ensuring future product success. Commonly, companies allocate only a limited budget toward perfective maintenance and instead pressure developers to focus on implementing new features. Traditional techniques, such as code inspection, consume many staff resources and attention from developers. Metrics automate the process of checking for problems but produce voluminous, imprecise, and incongruent results. An opportunity exists for visualization to assist where automated measures have failed; however, current software visualization techniques only handle the voluminous aspect of data but fail to address imprecise and incongruent aspects. In this paper, we describe several techniques for visualizing possible defects reported by automated inspection tools. We propose a catalogue of lightweight visualizations that assist reviewers in weeding out false positives. We implemented the visualizations in a tool called NOSEPRINTS and present a case study on several commercial systems and open source applications in which we examined the impact of our tool on the inspection process. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 4th ACM symposium on Software visuallization |
| Place | Ammersee, Germany |
| Publisher | ACM |
| Pages | 77-86 |
| DOI | 10.1145/1409720.1409733 |
| ISBN | 978-1-60558-112-5 |
| URL | http://portal.acm.org/citation.cfm? id=1409733&dl=GUIDE&… |
| Accessed | Thu Feb 12 10:51:25 2009 |
| Archive | ACM |
| Date Added | Thu Feb 12 10:51:25 2009 |
| Modified | Thu Feb 12 10:51:25 2009 |
| Type | Conference Paper |
|---|---|
| Author | Max Schäfer |
| Author | Torbjörn Ekman |
| Author | Oege de Moor |
| Abstract | Automated refactoring tools are an essential part of a software developer's toolbox. They are most useful for gradually improving large existing code bases and it is essential that they work reliably, since even a simple refactoring may affect many different parts of a program, and the programmer should not have to inspect every individual change to ensure that the transformation went as expected. Even extensively tested industrial-strength refactoring engines, however, are fraught with many bugs that lead to incorrect, non-behaviour preserving transformations. We argue that software refactoring tools are a prime candidate for mechanical verification, offering significant challenges but also the prospect of tangible benefits for real-world software development. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 3rd workshop on Programming languages meets program verification |
| Place | Savannah, GA, USA |
| Publisher | ACM |
| Pages | 67-72 |
| DOI | 10.1145/1481848.1481859 |
| ISBN | 978-1-60558-330-3 |
| Short Title | Challenge proposal |
| URL | http://portal.acm.org/citation.cfm? id=1481859 |
| Accessed | Mon Aug 3 13:32:48 2009 |
| Archive | ACM |
| Date Added | Mon Aug 3 13:32:48 2009 |
| Modified | Mon Aug 3 13:32:48 2009 |
| Type | Book Section |
|---|---|
| Author | Danny Dig |
| Author | Ralph Johnson |
| Author | Frank Tip |
| Author | Oege De Moor |
| Author | Jan Becicka |
| Author | William Griswold |
| Author | Markus Keller |
| Abstract | WRT’07 was the first instance of the Workshop on Refactoring Tools. It was held in Berlin, Germany, on July 31st, in conjunction with ECOOP’07. The workshop brought together over 50 participants from both academia and industry. Participants include the lead developers of two widely used refactoring engines (Eclipse and NetBeans), researchers that work on refactoring tools and techniques, and others generally interested in refactoring. WRT’07 accepted 32 submissions, however, it was impossible to present all these submissions in one single day. Instead, in the morning session we started with a few technical presentations, followed by large group discussions around noon, a poster session and small group discussions in the afternoon. WRT’07 ended with a retrospective session and unanimous consensus to organize another session in the future. |
| Book Title | Object-Oriented Technology. ECOOP 2007 Workshop Reader |
| Date | 2008 |
| Pages | 193-202 |
| URL | http://dx.doi.org/10.1007/978-3-540-78195-0_19 |
| Accessed | Tue May 5 10:04:54 2009 |
| Library Catalog | SpringerLink |
| Date Added | Tue May 5 10:04:54 2009 |
| Modified | Tue May 5 10:04:54 2009 |
| Type | Conference Paper |
|---|---|
| Author | Mark Gabel |
| Author | Lingxiao Jiang |
| Author | Zhendong Su |
| Abstract | Several techniques have been developed for identifying similar code fragments in programs. These similar fragments, referred to as code clones, can be used to identify redundant code, locate bugs, or gain insight into program design. Existing scalable approaches to clone detection are limited to finding program fragments that are similar only in their contiguous syntax. Other, semantics-based approaches are more resilient to differences in syntax, such as reordered statements, related statements interleaved with other unrelated statements, or the use of semantically equivalent control structures. However, none of these techniques have scaled to real world code bases. These approaches capture semantic information from Program Dependence Graphs (PDGs), program representations that encode data and control dependencies between statements and predicates. Our definition of a code clone is also based on this representation: we consider program fragments with isomorphic PDGs to be clones. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 30th international conference on Software engineering |
| Place | Leipzig, Germany |
| Publisher | ACM |
| Pages | 321-330 |
| DOI | 10.1145/1368088.1368132 |
| ISBN | 978-1-60558-079-1 |
| URL | http://portal.acm.org/citation.cfm? id=1368132 |
| Accessed | Wed Dec 10 15:34:05 2008 |
| Archive | ACM |
| Date Added | Wed Dec 10 15:34:05 2008 |
| Modified | Wed Dec 10 15:34:05 2008 |
| Type | Book Section |
|---|---|
| Author | Rainer Koschke |
| Abstract | Ad-hoc reuse through copy-and-paste occurs frequently in practice affecting the evolvability of software. Researchers have investigated ways to locate and remove duplicated code. Empirical studies have explored the root causes and effects of duplicated code and the evolution of duplicated code. This chapter summarizes the state of the art in detecting, managing, and removing software redundancy. It describes consequences, pros and cons of copying and pasting code. |
| Book Title | Software Evolution |
| Date | 2008 |
| Pages | 15-36 |
| URL | http://dx.doi.org/10.1007/978-3-540-76440-3_2 |
| Accessed | Tue Dec 2 08:45:03 2008 |
| Library Catalog | SpringerLink |
| Date Added | Tue Dec 2 08:45:03 2008 |
| Modified | Tue Dec 2 08:45:03 2008 |
| Type | Conference Paper |
|---|---|
| Author | T. Ekman |
| Author | M. Schäfer |
| Author | M. Verbaere |
| Abstract | In order to ensure correctness, refactorings have to check extensive preconditions before performing the transformation. These preconditions usually involve subtle analyses of the program to be refactored, and as long as there is no good support for implementing them, refactoring is not about transformation, but about analysis. In most cases, these refactoring analyses are very similar to analyses implemented in a compiler and require the same level of detail to ensure behaviour preservation. We therefore propose to implement a refactoring engine on top of a compiler to leverage existing infrastructure, and complement it with refactoring-specific functionality. Many simple refactorings appear as building blocks in more complex refactorings. We have implemented two such building blocks that are widely useful: The first one allows to move symbolic names from one place in the program to another while preserving binding structure; it frees the developer from having to worry about issues like name clashes and accidental overriding. The second building block encapsulates data flow and control flow analyses, enabling the developer to specify precise conditions for validity of a transformation in terms of concepts like dominance and liveness. Based on these approaches, we have implemented a refactoring engine as part of a larger effort to generate IDEs from declarative language specifications using the JastAdd metacompiler tools. The described building blocks were successfully used as a foundation for other refactorings such as Rename, Extract Method, and Encapsulate Field. |
| Date | 2008 |
| Proceedings Title | Second Workshop on Refactoring Tools (WRT) |
| Conference Name | Second Workshop on Refactoring Tools (WRT) |
| Date Added | Wed Jul 29 09:02:16 2009 |
| Modified | Wed Jul 29 09:06:11 2009 |
| Type | Book Section |
|---|---|
| Author | Naouel Moha |
| Author | Amine Hacene |
| Author | Petko Valtchev |
| Author | Yann-Gaël Guéhéneuc |
| Abstract | Software engineers often need to identify and correct design defects, i.e., recurring design problems that hinder development and maintenance by making programs harder to comprehend and/or evolve. While detection of design defects is an actively researched area, their correction — mainly a manual and time-consuming activity — is yet to be extensively investigated for automation. In this paper, we propose an automated approach for suggesting defect-correcting refactorings using relational concept analysis (rca). The added value of rca consists in exploiting the links between formal objects which abound in a software re-engineering context. We validated our approach on instances of the Blob design defect taken from four different open-source programs. |
| Book Title | Formal Concept Analysis |
| Series | Lecture Notes in Computer Science |
| Volume | 4933/2008 |
| Place | Berlin / Heidelberg |
| Publisher | Springer |
| Date | 2008 |
| Pages | 289-304 |
| ISBN | 978-3-540-78136-3 |
| Accessed | Mon May 4 18:52:07 2009 |
| Library Catalog | CiteULike |
| Date Added | Mon May 4 18:52:07 2009 |
| Modified | Tue Aug 11 10:50:25 2009 |
http://dx.doi.org/10.1007/978-3-540-78137-0_21
| Type | Conference Paper |
|---|---|
| Author | N Tsantalis |
| Author | T Chaikalis |
| Author | A Chatzigeorgiou |
| Abstract | 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. |
| Date | 2008 |
| Proceedings Title | Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on |
| Pages | 331, 329 |
| Short Title | JDeodorant |
| URL | http://dx.doi.org/10.1109/CSMR.2008.4493342 |
| Accessed | Mon Dec 1 09:07:23 2008 |
| Archive | CiteULike |
| Date Added | Mon Dec 1 09:07:23 2008 |
| Modified | Mon Dec 1 09:07:23 2008 |
The authors present how type checking (switches and conditionals over type-like information) can be detected and refactored. The implementation described can detect and refactor 3 well-known examples.
| Type | Conference Paper |
|---|---|
| Author | Emerson Murphy-Hill |
| Author | Andrew P. Black |
| Abstract | The process of refactoring code---changing its structure while preserving its meaning---has been identified as an important way of maintaining code quality over time. However, it is sometimes difficult for progammers to identify which pieces of code are in need of refactoring. "Smell detectors" are designed to help programmers in this task, but most smell detectors do not mesh well with "floss refactoring," the recommended tactic in which refactoring and programming are finely interleaved. In this paper we present a smell detector that we have built with floss refactoring in mind by combining seven habits that we postulate are important to consider when designing usable smell detectors. We hope that this combination can help the designers of future smell detectors build tools that align with the way that programmers refactor. |
| Date | 2008 |
| Proceedings Title | Proceedings of the 2008 international workshop on Recommendation systems for software engineering |
| Place | Atlanta, Georgia |
| Publisher | ACM |
| Pages | 36-40 |
| DOI | 10.1145/1454247.1454261 |
| ISBN | 978-1-60558-228-3 |
| URL | http://portal.acm.org/citation.cfm? id=1454261 |
| Accessed | Mon Jul 13 09:52:55 2009 |
| Archive | ACM |
| Date Added | Mon Jul 13 09:52:55 2009 |
| Modified | Mon Jul 13 09:52:55 2009 |
| Type | Conference Paper |
|---|---|
| Author | A. De Lucia |
| Author | R. Oliveto |
| Author | L. Vorraro |
| Abstract | Several refactoring methods have been proposed in the literature to improve the cohesion of classes. Very often, refactoring operations are guided by cohesion metrics based on the structural information of the source code, such as attribute references in methods. In this paper we present a novel approach to guide the extract class refactoring (M. Fowler, 1999), taking into account structural and semantic cohesion metrics. The proposed approach has been evaluated in a case study conducted on JHotDraw, an open source software system. The achieved results revealed that the performance achieved with the proposed approach significantly outperforms the results achieved with methods considering only structural or semantic information. The proposed approach has also been integrated in the Eclipse platform. |
| Date | Sept. 28, 2008 |
| Proceedings Title | IEEE International Conference on Software Maintenance, 2008. |
| Conference Name | ICSM 2008 |
| Place | Beijing |
| Pages | 27 - 36 |
| Date Added | Tue Sep 14 21:07:11 2010 |
| Modified | Fri Sep 17 11:51:35 2010 |
Discusses using both structural and semantic similarity to guide an extract class refactoring. They use max-flow/min cut to separate a graph into two. The graph is composed of nodes representing members; each pair is connected by edges that are weighted by the similarity measure. The graph does *not* maintain the structural connections between methods, although the connections should at least be partially reflected in the weightings.
Relevance: 5
| Type | Conference Paper |
|---|---|
| Author | Ahari Abadi |
| Author | Ran Ettinger |
| Author | Yishai Feldman |
| Abstract | Fowler saw the availability of automated support for the Extract Method refactoring in modern IDEs as an indication for the crossing of the refactoring Rubicon. In spite of the advances in refactoring technology, it seems that this Rubicon has not yet been crossed, and refactoring support in modern IDEs leave a lot to be desired. We performed a case study in which we converted a Java servlet to use the model-view-controller pattern, using as much automated support as available. We found that while the whole conversion could be described as a series of refactorings, most of these were inadequately supported by the IDE, and some were not supported at all. Based on these findings, we outline the requirements from a refactoring framework that will support much more of the conversion process, and will also enable the composition of small refactorings into larger ones. |
| Date | October 19, 2008 |
| Proceedings Title | Second ACM Workshop on Refactoring Tools (WRT'08) |
| Conference Name | Second ACM Workshop on Refactoring Tools (WRT'08) |
| Place | Nashville, Tennessee, USA |
| Date Added | Mon Dec 1 11:16:36 2008 |
| Modified | Tue Aug 10 20:10:56 2010 |
Discusses problems with the extract-method refactoring, many having to do with insufficient analysis. For example, assignment to multiple variables could be circumvented by swapping statement positions if the swapped statements did not interact.
Relevance: 5
| Type | Conference Paper |
|---|---|
| Author | Dmitry Jemerov |
| Date | October 19, 2008 |
| Conference Name | Second ACM Workshop on Refactoring Tools (WRT'08) |
| Place | Nashville, Tennessee, USA |
| Date Added | Mon Dec 1 11:47:22 2008 |
| Modified | Mon Dec 1 11:49:09 2008 |
A two-page paper on some aspects of IntelliJ's refactoring capabilities. Includes the notion of a separate pattern-matching specification language to help define custom refactorings.
Relevance: 3
| Type | Conference Paper |
|---|---|
| Author | Sandro Schulze |
| Author | Martin Kuhlemann |
| Author | Marko Rosenmueller |
| Date | October 19, 2008 |
| Conference Name | Second ACM Workshop on Refactoring Tools (WRT'08) |
| Place | Nashville, Tennessee, USA |
| Date Added | Mon Dec 1 11:56:55 2008 |
| Modified | Mon Dec 1 12:00:17 2008 |
This paper discusses refactoring of cloned code from both an OO and an aspect-oriented perspective. It is also useful for the cloning references it has.
Relevance: 4
| Type | Conference Paper |
|---|---|
| Author | Karim O. Elish |
| Author | Mohammad Alshayeb |
| Abstract | Refactoring, the process of improving the design of existing code by changing its internal structure without affecting its external behavior, tends to improve software quality by improving design, improving readability, and reducing bugs. There are many different refactoring methods, each having a particular purpose and effect. Consequently, the effect of refactorings on software quality attribute may vary. Software testing is an external software quality attributes that takes lots of time and effort to make sure that the software performs as intended. In this paper, we propose a classification of refactoring methods based on their measurable effect on software testing effort. This, in turn, helps the software developers decide which refactoring methods to apply in order to optimize a software system with regard to the testing effort. |
| Date | 2009 |
| Proceedings Title | Asia-Pacific Software Engineering Conference |
| Place | Los Alamitos, CA, USA |
| Publisher | IEEE Computer Society |
| Pages | 29-34 |
| DOI | http://doi.ieeecomputersociety.org/10.1109/APSEC.2009.14 |
| Library Catalog | IEEE Computer Society |
| Date Added | Wed May 19 07:28:43 2010 |
| Modified | Wed May 19 07:28:43 2010 |
"“Extract Class” reduces the testing effort"
| Type | Conference Paper |
|---|---|
| Author | Christoph Reichenbach |
| Author | Devin Coughlin |
| Author | Amer Diwan |
| Abstract | Modern development environments support refactoring by providing atomically behaviour-preserving transformations. While useful, these transformations are limited in three ways: (i) atomicity forces transformations to be complex and opaque, (ii) the behaviour preservation requirement disallows deliberate behaviour evolution, and (iii) atomicity limits code reuse opportunities for refactoring implementers. |
| Date | 2009 |
| Proceedings Title | Proceedings of the 23rd European Conference on ECOOP 2009 --- Object-Oriented Programming |
| Place | Italy |
| Publisher | Springer-Verlag |
| Pages | 394-418 |
| ISBN | 978-3-642-03012-3 |
| URL | http://portal.acm.org/citation.cfm? id=1615184.1615209 |
| Accessed | Fri Jun 18 14:43:18 2010 |
| Library Catalog | ACM |
| Date Added | Fri Jun 18 14:43:18 2010 |
| Modified | Fri Jun 18 14:43:18 2010 |
| Type | Conference Paper |
|---|---|
| Author | Javier Pérez |
| Author | Yania Crespo |
| Abstract | Keeping a software system conformant with a desired architecture and consistent with good design principles is a recurring task during the software evolution process. Deviations from good design principles can manifest in the form of bad smells: problems in the system's structure that can negatively affect software quality factors. |
| Date | 2009 |
| Proceedings Title | Proceedings of the joint international and annual ERCIM workshops on Principles of software evolution (IWPSE) and software evolution (Evol) workshops |
| Place | Amsterdam, The Netherlands |
| Publisher | ACM |
| Pages | 99-108 |
| DOI | 10.1145/1595808.1595827 |
| ISBN | 978-1-60558-678-6 |
| URL | http://portal.acm.org/citation.cfm? id=1595827 |
| Accessed | Mon Aug 2 13:20:19 2010 |
| Library Catalog | ACM |
| Date Added | Mon Aug 2 13:20:19 2010 |
| Modified | Mon Aug 2 13:20:19 2010 |
| Type | Journal Article |
|---|---|
| Author | Sami Mäkelä |
| Author | Ville Leppänen |
| Abstract | One purpose of software metrics is to measure the quality of programs. The results can be for example used to predict maintenance costs or improve code quality. An emerging view is that if software metrics are going to be used to improve quality, they must help in finding code that should be refactored. Often refactoring or applying a design pattern is related to the role of the class to be refactored. In client-based metrics, a project gives the class a context. These metrics measure how a class is used by other classes in the context. We present a new client-based metric LCIC (Lack of Coherence in Clients), which analyses if the class being measured has a coherent set of roles in the program. Interfaces represent the roles of classes. If a class does not have a coherent set of roles, it should be refactored, or a new interface should be defined for the class. We have implemented a tool for measuring the metric LCIC for Java projects in the Eclipse environment. We calculated LCIC values for classes of several open source projects. We compare these results with results of other related metrics, and inspect the measured classes to find out what kind of refactorings are needed. We also analyse the relation of different design patterns and refactorings to our metric. Our experiments reveal the usefulness of client-based metrics to improve the quality of code. |
| Publication | Sci. Comput. Program. |
| Volume | 74 |
| Issue | 5-6 |
| Pages | 355-378 |
| Date | 2009 |
| URL | http://portal.acm.org/citation.cfm? id=1518652 |
| Accessed | Thu May 21 15:10:58 2009 |
| Library Catalog | ACM |
| Date Added | Thu May 21 15:10:58 2009 |
| Modified | Thu May 21 15:10:58 2009 |
| Type | Journal Article |
|---|---|
| Author | Weifeng Pan |
| Author | Bing Li |
| Author | Yutao Ma |
| Author | Jing Liu |
| Author | Yeyi Qin |
| Abstract | The quality of a software system is largely determined by its internal structures which always degrade over the software evolution. Therefore, the structures have to be reconditioned from time to time. However, the existing methods are very complex and resource-consuming when doing this task. In this paper, we present an approach to recondition the class structures of object-oriented (OO) software systems. It uses attribute-method networks and method-method networks to represent attributes, methods and dependencies between them; It proposes a guided community detection algorithm to obtain the optimized community structures in the method-method networks, which also correspond to the optimized class structures; It also provides a list of refactorings by comparing the optimized class structures with the real class structure in software systems and inspecting the attribute-method networks. The approach is evaluated using the open-source case study, JHotDraw 5.1, and the advantages of our approach are illustrated in comparison with existing methods. |
| Publication | Frontiers of Computer Science in China |
| Volume | 3 |
| Issue | 3 |
| Pages | 396-404 |
| Date | 8/2009 |
| Journal Abbr | Front. Comput. Sci. China |
| DOI | 10.1007/s11704-009-0054-y |
| ISSN | 1673-7350 |
| URL | http://www.springerlink.com/content/03512u800qpw4344/ |
| Accessed | Mon Jan 24 18:17:47 2011 |
| Library Catalog | CrossRef |
| Date Added | Mon Jan 24 18:17:47 2011 |
| Modified | Mon Jan 24 18:19:34 2011 |
Concentrates on move method. Uses betweenness clustering on two separate networks created for the same class- method-method and method-attribute.
Relevance: 5
| Type | Journal Article |
|---|---|
| Author | Nikolaos Tsantalis |
| Author | Alexander Chatzigeorgiou |
| Abstract | Placement of attributes/methods within classes in an object-oriented system is usually guided by conceptual criteria and aided by appropriate metrics. Moving state and behavior between classes can help reduce coupling and increase cohesion, but it is nontrivial to identify where such refactorings should be applied. In this paper, we propose a methodology for the identification of Move Method refactoring opportunities that constitute a way for solving many common Feature Envy bad smells. An algorithm that employs the notion of distance between system entities (attributes/methods) and classes extracts a list of behavior-preserving refactorings based on the examination of a set of preconditions. In practice, a software system may exhibit such problems in many different places. Therefore, our approach measures the effect of all refactoring suggestions based on a novel Entity Placement metric that quantifies how well entities have been placed in system classes. The proposed methodology can be regarded as a semi-automatic approach since the designer will eventually decide whether a suggested refactoring should be applied or not based on conceptual or other design quality criteria. The evaluation of the proposed approach has been performed considering qualitative, metric, conceptual, and efficiency aspects of the suggested refactorings in a number of open-source projects. |
| Publication | IEEE Transactions on Software Engineering |
| Volume | 35 |
| Issue | 3 |
| Pages | 347-367 |
| Date | 2009-01-06 |
| URL | http://www2.computer.org/portal/web/csdl/doi/10.1109/TSE.2009.1 |
| Accessed | Mon Jul 13 09:41:14 2009 |
| Date Added | Mon Jul 13 09:41:14 2009 |
| Modified | Tue Feb 16 12:49:50 2010 |
| Type | Conference Paper |
|---|---|
| Author | Nikolaos Tsantalis |
| Author | Alexander Chatzigeorgiou |
| Abstract | Extract Method has been recognized as one of the most important refactorings, since it decomposes large methods and can be used in combination with other refactorings for fixing a variety of design problems. However, existing tools and methodologies support extraction of methods based on a set of statements selected by the user in the original method. The goal of the proposed methodology is to automatically identify Extract Method refactoring opportunities and present them as suggestions to the designer of an object-oriented system. The suggested refactorings adhere to three principles: the extracted code should contain the complete computation of a given variable declared in the original method, the behavior of the program should be preserved after the application of the refactoring, and the extracted code should not be excessively duplicated in the original method. The proposed approach is based on the union of static slices that result from the application of a block-based slicing technique. The soundness of the identified refactoring opportunities has been evaluated by an independent designer on the system that he developed. |
| Date | 2009-03-24 |
| Conference Name | European Conference on Software Maintenance and Reengineering |
| URL | http://www2.computer.org/portal/web/csdl/doi/10.1109/CSMR.2009.23 |
| Accessed | Mon Jul 13 09:43:38 2009 |
| Date Added | Mon Jul 13 09:43:38 2009 |
| Modified | Fri Jul 24 15:17:34 2009 |
| Type | Journal Article |
|---|---|
| Author | Mohammad Alshayeb |
| Abstract | Developers and designers always strive for quality software. Quality software tends to be robust, reliable and easy to maintain, and thus reduces the cost of software development and maintenance. Several methods have been applied to improve software quality. Refactoring is one of those methods. The goal of this paper is to validate/invalidate the claims that refactoring improves software quality. We focused this study on different external quality attributes, which are adaptability, maintainability, understandability, reusability, and testability. We found that refactoring does not necessarily improve these quality attributes. |
| Publication | Information and Software Technology |
| Date | April 2009 |
| DOI | 10.1016/j.infsof.2009.04.002 |
| ISSN | 09505849 |
| URL | http://dx.doi.org/10.1016/j.infsof.2009.04.002 |
| Date Added | Tue Jun 30 10:08:10 2009 |
| Modified | Tue Jun 30 10:08:10 2009 |
| Type | Conference Paper |
|---|---|
| Author | Keith Cassell |
| Author | Peter Andreae |
| Author | Lindsay Groves |
| Author | James Noble |
| Abstract | Large, unwieldy classes are a significant maintenance problem. Programmers dislike them because the fundamental logic is often obscured, making them hard to understand and modify. This paper proposes a solution - a semi-automatic technique for splitting large classes into smaller, more cohesive ones. The core of the technique is the use of betweenness clustering to identify the best way of partitioning a class. This turned a tedious manual process into a quick and simple semi-automated one in roughly one third of the cases we examined. |
| Date | 16-20 November 2009 |
| Proceedings Title | 24th IEEE/ACM International Conference on Automated Software Engineering |
| Conference Name | ASE 2009 |
| Place | Auckland, NZ |
| Pages | 595-599 |
| DOI | 10.1109/ASE.2009.21 |
| ISBN | 978-1-4244-5259-0 |
| Date Added | Wed Nov 25 16:30:19 2009 |
| Modified | Wed Mar 2 20:47:00 2011 |
| Type | Journal Article |
|---|---|
| Author | Gustavo Soares |
| Author | Rohit Gheyi |
| Author | Dalton Serey |
| Author | Tiago Massoni |
| Abstract | Developers rely on compilation, test suite and tools to preserve observable behavior during refactoring. However, most of the refactoring tools do not implement all preconditions that guarantee the refactoring correctness, since formally identifying them is cost-prohibitive. Therefore, these tools may perform non-behavior preserving transformations. We present a tool for improving safety during refactoring. It automatically generates a test suite that is suited for detecting behavioral changes. We used our tool to evaluate seven real case study refactorings (from 3 to 100 KLOC). We reason about a JHotDraw (23 KLOC) and its refactored version, and automatically detected a behavioral change. This problem was not identified by developers. Finally, we also evaluated our tool against 17 defective refactorings that are not detected by refactoring tools. It automatically detects most of those errors within a few seconds. |
| Publication | IEEE Software |
| Volume | 27 |
| Issue | 4 |
| Pages | 52-57 |
| Date | 2010 |
| DOI | 10.1109/MS.2010.63 |
| ISSN | 0740-7459 |
| Library Catalog | IEEE Computer Society |
| Date Added | Sun May 23 12:42:25 2010 |
| Modified | Mon Feb 28 15:02:01 2011 |
| Type | Conference Paper |
|---|---|
| Author | G. Antoniol |
| Author | G. Bavota |
| Author | A. De Lucia |
| Author | Y. Gueheneuc |
| Author | R. Oliveto |
| Abstract | In software engineering, developers must often find solutions to problems while balancing competing goals, e.g., quality versus cost, time to market versus resources or cohesion versus coupling. Finding suitable compromises between contrasting goals is often complex and recommendation systems are useful to support developers and managers in performing such a complex task. We believe contrasting goals can be often dealt with game theory techniques. Indeed, game theory is successfully used in other fields, especially in economics, to mathematically propose solutions to strategic situation, in which an individual's success in making choices depends on the choices of others. To demonstrate the applicability of game theory to software engineering and to understand its pros and cons, we propose an approach based on game theory that recommend extract-class refactoring opportunities. A preliminary evaluation inspired by mutation testing demonstrates the applicability and the benefits of the proposed approach. |
| Date | 2010 |
| Proceedings Title | Proceedings of the 26th IEEE International Conference on Software Maintenance |
| Place | Timisoara, Romania |
| Date Added | Wed Sep 15 12:42:31 2010 |
| Modified | Wed Sep 15 12:46:53 2010 |
| Type | Conference Paper |
|---|---|
| Author | Jin Huang |
| Author | Yansheng Lu |
| Author | Jing Yang |
| Abstract | Aspect mining is a technique that decouples the crosscutting concerns from existing software systems. The goal of aspect mining is to refactor the existing software systems with Aspect Oriented Programming technology. Inspired by the link analysis of information retrieval technology, this paper describes a two-state model to approximate how crosscutting concerns can be discovered in the concern graphs extracted from programs. Our mining algorithm generates ”scatter” and ”centralization” of each program element for the final ranking. The convergency of the algorithm proves fast. The Ranking technique, considering both ”scatter” and ”centralization”, produces a final ranking for identifying crosscutting concerns. Our aspect mining approach is evaluated on numerous Java programs that are of the typical selections for aspect mining. Compared with existing aspect mining approaches, our mining approach captures more information that helps domain experts refactor software systems and prove effective in identifying crosscutting concerns. |
| Date | 2010 |
| Proceedings Title | Frontier of Computer Science and Technology (FCST), 2010 Fifth International Conference on |
| Conference Name | Frontier of Computer Science and Technology (FCST), 2010 Fifth International Conference on |
| Pages | 312-317 |
| DOI | 10.1109/FCST.2010.20 |
| Library Catalog | IEEE Xplore |
| Date Added | Mon Jan 10 11:36:06 2011 |
| Modified | Mon Jan 10 11:36:06 2011 |
| Type | Thesis |
|---|---|
| Author | Marios Fokaefs |
| Abstract | Software can be considered a live entity, as it undergoes many alterations throughout its lifecycle. Therefore, code can become rather complex and difficult to understand. More specifically in object-oriented systems, classes may become very large and less cohesive. In order to identify such problematic cases, existing approaches have proposed the use of cohesion metrics. While metrics can identify classes with low cohesion, they usually cannot identify new or independent concepts. In this work, we propose a class decomposition method using an clustering algorithm based on the Jaccard distance between class members. The methodology is able to identify new concepts and rank the solutions according to their impact on the design quality of the system. The methodology was evaluated in terms of assessment by designers, expert assessment and metrics. The evaluation showed the ability of the method to identify new recognizable concepts and improve the design quality of the underlying system. |
| Type | Master's thesis |
| University | Dept. of Computing Science, University of Alberta |
| Place | Edmonton, Alberta |
| Date | Fall 2010 |
| # of Pages | 50 |
| Date Added | Tue Oct 5 08:47:35 2010 |
| Modified | Fri Jan 28 12:04:09 2011 |
Simple agglomerative clustering using a Jaccard distance. It's unclear exactly what is going into the property sets.
After clustering, suggestions are ranked using the entity placement metric.
Relevance: 5
| Type | Journal Article |
|---|---|
| Author | Nikolaos Tsantalis |
| Author | Alexander Chatzigeorgiou |
| Abstract | Polymorphism is one of the most important features offered by object-oriented programming languages, since it allows to extend/modify the behavior of a class without altering its source code, in accordance to the Open/Closed Principle. However, there is a lack of methods and tools for the identification of places in the code of an existing system that could benefit from the employment of polymorphism. In this paper we propose a technique that extracts refactoring suggestions introducing polymorphism. The approach ensures the behavior preservation of the code and the applicability of the refactoring suggestions based on the examination of a set of preconditions. |
| Publication | Journal of Systems and Software |
| Volume | 83 |
| Issue | 3 |
| Pages | 391-404 |
| Date | March 2010 |
| DOI | 10.1016/j.jss.2009.09.017 |
| ISSN | 0164-1212 |
| URL | http://www.sciencedirect.com/science/article/B6V0N-4X6MSR5-2/2/1cd9c725d91737926009f425afc57f61 |
| Accessed | Mon Aug 2 13:43:35 2010 |
| Library Catalog | ScienceDirect |
| Date Added | Mon Aug 2 13:43:35 2010 |
| Modified | Mon Aug 2 13:43:35 2010 |
| Type | Journal Article |
|---|---|
| Author | Javier Pérez |
| Author | Yania Crespo |
| Author | Berthold Hoffmann |
| Author | Tom Mens |
| Abstract | Abstract This article proposes a case study to evaluate the suitability of graph transformation tools for program refactoring. To qualify for this purpose, a graph transformation system must be able to (1) import a graph-based representation of models of Java programs, (2) allow these models to be transformed interactively with well-known program refactorings and (3) export the resulting models in the same graph-based format used as input. The case study aims to enable comparison of various features of graph transformation tools, such as their expressiveness and their ability to interact with the user. The model of Java programs is presented and some examples for translating Java source code into the model are provided. The refactorings selected for the case study are specified in detail. |
| Publication | International Journal on Software Tools for Technology Transfer (STTT) |
| Volume | 12 |
| Issue | 3 |
| Pages | 183-199 |
| Date | July 01, 2010 |
| DOI | 10.1007/s10009-010-0153-y |
| URL | http://dx.doi.org/10.1007/s10009-010-0153-y |
| Accessed | Mon Aug 2 12:53:23 2010 |
| Library Catalog | SpringerLink |
| Date Added | Mon Aug 2 12:53:23 2010 |
| Modified | Mon Aug 2 12:53:23 2010 |
| Type | Report |
|---|---|
| Author | Keith Cassell |
| Author | Craig Anslow |
| Author | Lindsay Groves |
| Author | Peter Andreae |
| Abstract | When developing object-oriented classes, it is difficult to determine how to best reallocate the members of large, complex classes to create smaller, more cohesive ones. Clustering techniques can provide guidance on how to solve this alloca- tion problem; however, inappropriate use of clustering can result in a class structure that is less maintainable than the original. The ExtC Visualizer helps the programmer understand the class structure by visually emphasizing important features of the class's members and their interelationships. More importantly, it helps users see how various clustering algorithms group the class's members. These insights help a programmer choose appropriate techniques for refactoring large classes. |
| Report Number | ECSTR 10-17 |
| Report Type | Technical Report |
| Place | Wellington, NZ |
| Institution | Victoria University of Wellington, Dept. ECS |
| Date | 26 July 2010 |
| Pages | 10 |
| URL | http://ecs.victoria.ac.nz/twiki/pub/Main/TechnicalReportSeries/ECSTR10-17.pdf |
| Date Added | Mon Jul 26 12:45:13 2010 |
| Modified | Mon Jul 26 12:50:52 2010 |
| Type | Journal Article |
|---|---|
| Author | Michael Bowman |
| Author | Lionel C Briand |
| Author | Yvan Labiche |
| Abstract | In the context of object-oriented analysis and design (OOAD), class responsibility assignment is not an easy skill to acquire. Though there are many methodologies for assigning responsibilities to classes, they all rely on human judgment and decision making. Our objective is to provide decision-making support to re-assign methods and attributes to classes in a class diagram. Our solution is based on a multi-objective genetic algorithm (MOGA) and uses class coupling and cohesion measurement for defining fitness functions. Our MOGA takes as input a class diagram to be optimized and suggests possible improvements to it. The choice of a MOGA stems from the fact that there are typically many evaluation criteria that cannot be easily combined into one objective, and several alternative solutions are acceptable for a given OO domain model. Using a carefully selected case study, this article investigates the application of our proposed MOGA to the class responsibility assignment problem, in the context of object-oriented analysis and domain class models. Our results suggest that the MOGA can help correct suboptimal class responsibility assignment decisions and perform far better than simpler alternative heuristics such as hill climbing and a single objective GA. |
| Publication | IEEE Transactions on Software Engineering |
| Issue | 99 |
| Date | July 29, 2010 |
| URL | http://citeseerx.ist.psu.edu/viewdoc/summary? doi=10.1.1.164.571 |
| Accessed | Sat Oct 9 13:02:10 2010 |
| Date Added | Sat Oct 9 13:02:10 2010 |
| Modified | Sat Oct 9 13:05:05 2010 |
| Type | Report |
|---|---|
| Author | Keith Cassell |
| Author | Peter Andreae |
| Author | Lindsay Groves |
| Author | James Noble |
| Abstract | When developing object-oriented classes, it is difficult to determine how to best refactor large, complex classes to create smaller, more cohesive ones. Automated algorithms can recommend solutions, but how can a programmer feel confident that an algorithm's recommendations are good ones? The test suite described here provides test classes for use as inputs to these automated algorithms, together with the preferred results - the class members that should be distributed to the extracted class. By comparing the actual results to the expected ones, a programmer can have some confidence that his algorithms are providing useful suggestions for refactoring. |
| Report Number | ECSTR 10-21 |
| Report Type | Technical Report |
| Place | Wellington, NZ |
| Institution | Victoria University of Wellington, Dept. ECS |
| Date | September 17, 2010 |
| Pages | 13 |
| URL | http://ecs.victoria.ac.nz/twiki/pub/Main/TechnicalReportSeries/ECSTR10-21.pdf |
| Date Added | Fri Sep 17 16:23:45 2010 |
| Modified | Fri Oct 8 17:25:54 2010 |
| Type | Conference Paper |
|---|---|
| Author | Keith Cassell |
| Author | Craig Anslow |
| Author | Lindsay Groves |
| Author | Peter Andreae |
| Abstract | When developing object-oriented classes, it is difficult to determine how to best reallocate the members of large, complex classes to create smaller, more cohesive ones. Clustering techniques can provide guidance on how to solve this allocation problem; however, inappropriate use of clustering can result in a class structure that is less maintainable than the original. The ExtC Visualizer helps the programmer understand the class structure by visually emphasizing important features of the class's members and their inter-relationships. More importantly, it helps users see how various clustering algorithms group the class's members. These insights help a programmer choose appropriate techniques for refactoring large classes. |
| Date | January 2011 |
| Proceedings Title | Proc. Australasian Computer Science Conference (ACSC 2011) |
| Conference Name | Australasian Computer Science Conference (ACSC '11) |
| Place | Perth, Australia |
| Publisher | ACS |
| Volume | 113 |
| Pages | 63-72 |
| Series | CRPIT |
| Date Added | Thu Dec 2 16:59:04 2010 |
| Modified | Fri Jan 28 11:26:07 2011 |