Dr. Jones : a software design explorer's crystal ball

The Problem: Most of software design is redesign. Redesign happens when the programmer finds a better solution for the initial design problem or the problem itself changes. Yet there is a dearth of effective tools for effective software redesign ‐ it proceeds primarily by planning with pen and paper, away from the computer where tools could help the programmer the most. To address this problem, I am developing Dr. Jones, an assistant that helps the programmer improve the design of Java programs. Dr. Jones diagrams the design of a Java program and allows the user to improve its design by applying refactorings, localized patterns of structural change in object-oriented programs that improve their design, without changing their visible behavior [1]. Dr. Jones records the programmer’s intended refactorings and updates the diagram with the resulting (presumably improved) design. It will support the kind of design exploration a programmer would ordinarily do with pen and paper, while also providing a “crystal ball:” the ability to see design evolve. This facilitates exploring the design space of the program, enabling the programmer to choose the best alternative design. Motivation: Effective software redesign is crucial step in reducing the cost of software maintenance. But planning such redesign is presently a cumbersome manual process. The first step ‐ getting a clear picture of the current design ‐ typically requires a programmer to manually reverse engineer the program into hand-drawn diagrams. Next, problems and necessary refactorings are noted on these diagrams. Finally, the programmer returns to the source and implements the refactorings using the diagram as a guide. If further refactoring is needed ‐ or the refactoring plan has to be rethought ‐ this process must begin from scratch. Tools like Dr. Jones have immense potential for streamlining this process. Diagrams that accurately reflect the current program design can be generated automatically by analyzing source code. Refactoring proceeds by interacting with the diagram, where cumulative impact can be measured, alternatives explored, and plans recorded, without the need for manual redrawing. Previous Work: Nearly all existing refactoring systems are based on the metaphor of source code transformation ‐ a refactoring immediately alters the source text of the program [2]. This limits the programmer to refactorings that can be done safely and automatically. Partially automating source-level refactorings doesn’t help, because it forces the programmer to make detailed programming decisions when she would rather be thinking about design.

[1]  William G. Griswold,et al.  Supporting the restructuring of data abstractions through manipulation of a program visualization , 1998, TSEM.

[2]  Ralph E. Johnson,et al.  A Refactoring Tool for Smalltalk , 1997, Theory Pract. Object Syst..

[3]  Emden R. Gansner,et al.  An open graph visualization system and its applications to software engineering , 2000 .

[4]  Audris Mockus,et al.  Visualizing Software Changes , 2002, IEEE Trans. Software Eng..

[5]  Bjørn N. Freeman-Benson,et al.  Visualizing dynamic software system information through high-level models , 1998, OOPSLA '98.

[6]  Kent Beck,et al.  Test-infected: programmers love writing tests , 2000 .

[7]  Mel Ó Cinnéide,et al.  A methodology for the automated introduction of design patterns , 1999, Proceedings IEEE International Conference on Software Maintenance - 1999 (ICSM'99). 'Software Maintenance for Business Change' (Cat. No.99CB36360).

[8]  William G. Griswold,et al.  Tool support for planning the restructuring of data abstractions in large systems , 1996, SIGSOFT '96.

[9]  Michael Oltmans,et al.  Understanding Naturally Conveyed Explanations of Device Behavior , 2000 .

[10]  James A. Landay,et al.  Interactive sketching for the early stages of user interface design , 1995, CHI '95.

[11]  Stéphane Ducasse,et al.  A categorization of classes based on the visualization of their internal structure: the class blueprint , 2001, OOPSLA '01.

[12]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[13]  Howard E Shrobe,et al.  Dependency Directed Reasoning for Complex Program Understanding , 1979 .

[14]  Tarja Systä,et al.  Understanding the Behavior of Java Programs , 2000, WCRE.

[15]  Eduardo Casais The Automatic Reorganization of Object Oriented Hierarchies - A Case Study , 1994 .

[16]  Philip R. Cohen,et al.  QuickSet: multimodal interaction for distributed applications , 1997, MULTIMEDIA '97.

[17]  Katsuhisa Maruyama,et al.  Automatic method refactoring using weighted dependence graphs , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[18]  William G. Griswold,et al.  Exploiting the map metaphor in a tool for software evolution , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[19]  Hausi A. Müller,et al.  Cognitive design elements to support the construction of a mental model during software visualization , 1997, Proceedings Fifth International Workshop on Program Comprehension. IWPC'97.

[20]  Raymond McCall,et al.  Making Argumentation Serve Design , 1996, Hum. Comput. Interact..

[21]  Holger Eichelberger,et al.  Aesthetics of class diagrams , 2002, Proceedings First International Workshop on Visualizing Software for Understanding and Analysis.

[22]  Rudolf K. Keller,et al.  Pattern visualization for software comprehension , 1998, Proceedings. 6th International Workshop on Program Comprehension. IWPC'98 (Cat. No.98TB100242).

[23]  John M. Carroll,et al.  Design rationale: concepts, techniques, and use , 1996 .

[24]  Linda Mary Wills,et al.  Automated program recognition by graph parsing , 1992 .

[25]  Emden R. Gansner,et al.  An open graph visualization system and its applications to software engineering , 2000, Softw. Pract. Exp..

[26]  Jay Banerjee,et al.  Semantics and implementation of schema evolution in object-oriented databases , 1987, SIGMOD '87.

[27]  Hausi A. Müller,et al.  A reverse engineering environment based on spatial and visual software interconnection models , 1992 .

[28]  Mel O Cinn eide Automated application of design patterns: a refactoring approach , 2001 .

[29]  Oscar Nierstrasz,et al.  A meta-model for language-independent refactoring , 2000, Proceedings International Symposium on Principles of Software Evolution.

[30]  William G. Griswold,et al.  Dynamically discovering likely program invariants to support program evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[31]  Mel Ó Cinnéide Automated application of design patterns : a refactoring approach , 2001 .

[32]  Kent L. Beck,et al.  Extreme programming explained - embrace change , 1990 .

[33]  Ivan Moore,et al.  Automatic inheritance hierarchy restructuring and method refactoring , 1996, OOPSLA '96.

[34]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[35]  William G. Griswold,et al.  Automated assistance for program restructuring , 1993, TSEM.

[36]  Martin P. Robillard,et al.  Concern graphs: finding and describing concerns using structural program dependencies , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[37]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[38]  Danny B. Lange,et al.  Interactive visualization of design patterns can help in framework understanding , 1995, OOPSLA.

[39]  William G. Griswold Program restructuring as an aid to software maintenance , 1992 .

[40]  Frank Maurer,et al.  Tool Support for Complex Refactoring to Design Patterns , 2003, XP.

[41]  David Notkin,et al.  Software Reflexion Models: Bridging the Gap between Design and Implementation , 2001, IEEE Trans. Software Eng..

[42]  Don S. Batory,et al.  Evolving Object-Oriented Designs with Refactorings , 2004, Automated Software Engineering.

[43]  Robert Balzer Automated Enhancement of Knowledge Representations , 1985, IJCAI.

[44]  Anneliese Amschler Andrews,et al.  Program Comprehension During Software Maintenance and Evolution , 1995, Computer.

[45]  Hausi A. Müller,et al.  Rigi: A Visualization Environment for Reverse Engineering , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[46]  Martin Fowler,et al.  Refactoring - Improving the Design of Existing Code , 1999, Addison Wesley object technology series.

[47]  Howard B. Reubenstein,et al.  Automated Acquisition of Evolving Informal Descriptions , 1990 .

[48]  Richard C. Waters,et al.  The Programmer''s Apprentice Project: A Research Overview , 1987 .

[49]  David Lorge Parnas,et al.  Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[50]  Tarja Systä,et al.  Dynamic Reverse Engineering of Java Software , 1999, ECOOP Workshops.

[51]  Ahmed Seffah,et al.  The CONCEPT project - applying source code analysis to reduce information complexity of static and dynamic visualization techniques , 2002, Proceedings First International Workshop on Visualizing Software for Understanding and Analysis.

[52]  Don Roberts,et al.  Practical analysis for refactoring , 1999 .

[53]  William G. Griswold,et al.  Automated support for program refactoring using invariants , 2001, Proceedings IEEE International Conference on Software Maintenance. ICSM 2001.

[54]  Kuntz Werner,et al.  Issues as Elements of Information Systems , 1970 .

[55]  Ralph E. Johnson,et al.  Refactoring and Aggregation , 1993, ISOTAS.

[56]  Martin P. Robillard,et al.  Efficient mapping of software system traces to architectural views , 2000, CASCON.

[57]  Daniel Jackson,et al.  Lightweight extraction of object models from bytecode , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[58]  Hausi A. Müller,et al.  A reverse engineering environment based on spatial and visual software interconnection models , 1992, SDE 5.

[59]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[60]  G. W. Furnas,et al.  Generalized fisheye views , 1986, CHI '86.

[61]  C. V. Ramamoorthy,et al.  Object-oriented systems , 1988, IEEE Expert.

[62]  Stéphane Ducasse,et al.  Understanding software evolution using a combination of software visualization and software metrics , 2002, Obj. Logiciel Base données Réseaux.

[63]  E. Jeffrey Conklin,et al.  A process-oriented approach to design rationale , 1991 .

[64]  Alexander Egyed Semantic abstraction rules for class diagrams , 2000, Proceedings ASE 2000. Fifteenth IEEE International Conference on Automated Software Engineering.