Automated Adaptive Software Maintenance: A Methodology and Its Applications

In modern software development, maintenance accounts for the majority of the total cost and effort in a software project. Especially burdensome are those tasks which require applying a new technology in order to adapt an application to changed requirements or a different environment. This research explores methodologies, techniques, and approaches for automating such adap-tive maintenance tasks. By combining high-level specifications and generative techniques, a new methodology shapes the design of approaches to automating adaptive maintenance tasks in the application domains of high performance computing (HPC) and enterprise software. Despite the vast differences of these domains and their respective requirements, each approach is shown to be effective at alleviating their adaptive maintenance burden. This thesis proves that it is possible to effectively automate tedious and error-prone adaptive maintenance tasks in a diverse set of domains by exploiting high-level specifications to synthesize specialized low-level code. The specific contributions of this thesis are as follows: (1) a common methodology for designing automated approaches to adaptive maintenance, (2) a novel approach to automating the generation of efficient marshaling logic for HPC applications from a high-level visual model, and (3) a novel approach to automatically upgrading legacy enterprise applications to use annotation-based frameworks. The technical contributions of this thesis have been realized in two software tools for automated adaptive maintenance: MPI Serializer, a marshaling logic generator for MPI applications , and Rosemari, an inference and transformation engine for upgrading enterprise applications. This thesis is based on research papers accepted to IPDPS '08 [93] and OOPSLA '08 [92]. iii Acknowledgments No grad student is an island, and I am surely no exception. My friends, family, and colleagues have ameliorated my life and I truly appreciate the kindness they all have shown me. I would like to take this opportunity to thank many of those who have aided me in one way or another along the way. The never-ending support and love of my parents has sustained, comforted, and driven me throughout my life. Any accomplishments that I have achieved in my time here at Virginia Tech would not have been possible if I did not have them by my side. They are the most caring, loving, and genuine people I have ever known. The faith that both my brother and sister have had in me spurred me on through the most difficult challenges. For the five years that I have known her, Lindsay La Forge has …

[1]  Yutaka Ishikawa,et al.  Proceedings of the Scientific Computing in Object-Oriented Parallel Environments , 1997 .

[2]  Michael Philippsen,et al.  More efficient serialization and RMI for Java , 2000, Concurr. Pract. Exp..

[3]  Fernando Castor,et al.  A Language for Specifying Java Transformations , 2001 .

[4]  Eric Eide,et al.  Flick: a flexible, optimizing IDL compiler , 1997, PLDI '97.

[5]  Chris Richardson Untangling Enterprise Java , 2006, ACM Queue.

[6]  Mikhail Dmitriev Language-specific make technology for the Java programming language , 2002, OOPSLA '02.

[7]  Samuel N. Kamin,et al.  Optimizing marshalling by run-time program generation , 2005, GPCE'05.

[8]  Eelco Visser,et al.  Program Transformation with Stratego/XT: Rules, Strategies, Tools, and Systems in Stratego/XT 0.9 , 2003, Domain-Specific Program Generation.

[9]  Sriram Sankaranarayanan,et al.  Mining library specifications using inductive logic programming , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[10]  Meir M. Lehman,et al.  Program evolution: processes of software change , 1985 .

[11]  Renaud Pawlak,et al.  Spoon: Program Analysis and Transformation in Java , 2006 .

[12]  Roger Hillson,et al.  C++2MPI: a software tool for automatically generating MPI datatypes from C++ classes , 2000, Proceedings International Conference on Parallel Computing in Electrical Engineering. PARELEC 2000.

[13]  Eli Tilevich,et al.  Efficient automated marshaling of C++ data structures for MPI applications , 2008, 2008 IEEE International Symposium on Parallel and Distributed Processing.

[14]  Jeffrey G. Gray,et al.  DSMDiff: a differentiation tool for domain-specific models , 2007 .

[15]  Christopher W. Pidgeon,et al.  DMS®: Program Transformations for Practical Scalable Software Evolution , 2002, IWPSE '02.

[16]  Andrew Lumsdaine,et al.  Modernizing the C++ Interface to MPI , 2006, PVM/MPI.

[17]  Bruce P. Lester The art of parallel programming , 1993 .

[18]  Norman Wilde,et al.  Maintaining object-oriented software , 1993, IEEE Software.

[19]  James R. Cordy,et al.  The TXL source transformation language , 2006, Sci. Comput. Program..

[20]  Zhenmin Li,et al.  PR-Miner: automatically extracting implicit programming rules and detecting violations in large software code , 2005, ESEC/FSE-13.

[21]  Heiko Bobzin,et al.  Java Data Objects , 2002, Datenbank-Spektrum.

[22]  Sun Microsystems,et al.  RPC: Remote Procedure Call Protocol specification , 1988, RFC.

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

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

[25]  Lee L. Gremillion Determinants of program repair maintenance requirements , 1984, CACM.

[26]  Vincent Massol,et al.  JUnit in Action , 2003 .

[27]  Tao Xie,et al.  Automated detection of api refactorings in libraries , 2007, ASE '07.

[28]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[29]  Tom Tourwé,et al.  Automated Support for Framework-Based Software Evolution , 2003 .

[30]  Eleni Stroulia,et al.  Differencing logical UML models , 2007, Automated Software Engineering.

[31]  Ildar Khabibrakhmanov,et al.  On the Reusability and Numeric Efficiency of C + + Packages in Scientific Computing , 2003 .

[32]  Mary Beth Rosson,et al.  Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications , 2000, Conference on Object-Oriented Programming Systems, Languages, and Applications.

[33]  Frank Tip,et al.  Refactoring support for class library migration , 2005, OOPSLA '05.

[34]  Ralph E. Johnson,et al.  Automated Detection of Refactorings in Evolving Components , 2006, ECOOP.

[35]  Carlos José Pereira de Lucena,et al.  A Rule-Based Approach to Framework Evolution , 2006, J. Object Technol..

[36]  David Jordan,et al.  Java data objects , 2003 .

[37]  Wu-chun Feng,et al.  The design, implementation, and evaluation of mpiBLAST , 2003 .

[38]  J. Henkel,et al.  CatchUp! Capturing and replaying refactorings to support API evolution , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[39]  Christian Parrot,et al.  MPI pre-processor: generating MPI derived datatypes from C datatypes automatically , 2006, 2006 International Conference on Parallel Processing Workshops (ICPPW'06).

[40]  Risto Miikkulainen,et al.  Evolving Neural Networks through Augmenting Topologies , 2002, Evolutionary Computation.

[41]  Daniel M. Berry,et al.  Academic Legitimacy of the Software Engineering Discipline , 1992 .

[42]  Eelco Visser,et al.  Stratego/XT 0.16: components for transformation systems , 2006, PEPM '06.

[43]  Miryung Kim,et al.  Program element matching for multi-version program analyses , 2006, MSR '06.

[44]  Lee R. Nackman,et al.  Scientific and Engineering C++: An Introduction with Advanc , 1995, IEEE Computational Science and Engineering.

[45]  Susan L. Graham,et al.  Interactive transformation of java programs in eclipse , 2006, ICSE '06.

[46]  Dániel Varró,et al.  Automating model transformation by example using inductive logic programming , 2007, SAC '07.

[47]  John Brant,et al.  Tools for making impossible changes - experiences with a tool for transforming large Smalltalk programs , 2004, IEE Proc. Softw..

[48]  Carlos José Pereira de Lucena,et al.  Using refactoring and unification rules to assist framework evolution , 2003, SOEN.

[49]  Alessandro Orso,et al.  A differencing algorithm for object-oriented programs , 2004 .

[50]  Eelco Visser,et al.  A Survey of Strategies in Program Transformation Systems , 2001, WRS.

[51]  Thomas J. Mowbray,et al.  AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis , 1998 .

[52]  Todd L. Veldhuizen,et al.  Will C++ Be Faster than Fortran? , 1997, ISCOPE.

[53]  Roger Riggs,et al.  Pickling State in the Java(tm) System , 1996, COOTS.

[54]  Victor R. Basili,et al.  An empirical study to compare two parallel programming models , 2006, SPAA '06.

[55]  Miryung Kim,et al.  Automatic Inference of Structural Changes for Matching across Program Versions , 2007, 29th International Conference on Software Engineering (ICSE'07).

[56]  Ralph E. Johnson,et al.  How do APIs evolve? A story of refactoring , 2006, J. Softw. Maintenance Res. Pract..

[57]  Eelco Visser,et al.  Stratego: A Language for Program Transformation Based on Rewriting Strategies , 2001, RTA.

[58]  M. Petró‐Turza,et al.  The International Organization for Standardization. , 2003 .

[59]  J. Beall,et al.  Discovering and Representing Logical Structure in Code Change , 2007 .

[60]  Jason Maassen,et al.  Efficient Java RMI for parallel programming , 2001, TOPL.

[61]  Robert J. Walker,et al.  Determining detailed structural correspondence for generalization tasks , 2007, ESEC-FSE '07.

[62]  M A Branch,et al.  Software maintenance management , 1986 .

[63]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

[64]  Martial Michel,et al.  AutoMap and AutoLink: Tools for Communicating Complex and Dynamic Data-Structures Using MPI , 1998, CANPC.

[65]  Eli Tilevich,et al.  Annotation refactoring: inferring upgrade transformations for legacy applications , 2008, OOPSLA.

[66]  Michael Rudolf,et al.  Refactoring-based support for binary compatibility in evolving frameworks , 2007, GPCE '07.

[67]  Marti A. Hearst,et al.  Aligning development tools with the way programmers think about code changes , 2007, CHI.

[68]  Charlie Kindel,et al.  Distributed Component Object Model Protocol -- DCOM/1.0 , 1998 .

[69]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[70]  Shigeru Chiba,et al.  A metaobject protocol for C++ , 1995, OOPSLA.

[71]  Volker Kuttruff,et al.  Source-to-Source Transformation in the Large , 2003, JMLC.

[72]  Cristina V. Lopes,et al.  Adaptive Parameter Passing , 1996, ISOTAS.

[73]  Jennifer Widom,et al.  Change detection in hierarchically structured information , 1996, SIGMOD '96.

[74]  Robert Eckstein,et al.  Java Swing , 1998 .

[75]  Cédric Beust,et al.  Next Generation Java Testing: TestNG and Advanced Concepts , 2007 .

[76]  Zhenchang Xing,et al.  Refactoring Practice: How it is and How it Should be Supported - An Eclipse Case Study , 2006, 2006 22nd IEEE International Conference on Software Maintenance.

[77]  Eleni Stroulia,et al.  API-Evolution Support with Diff-CatchUp , 2007, IEEE Transactions on Software Engineering.

[78]  Harald C. Gall,et al.  Change Distilling:Tree Differencing for Fine-Grained Source Code Change Extraction , 2007, IEEE Transactions on Software Engineering.

[79]  Susan L. Graham,et al.  iXj: interactive source-to-source transformations for java , 2004, OOPSLA '04.

[80]  Eleni Stroulia,et al.  UMLDiff: an algorithm for object-oriented design differencing , 2005, ASE.

[81]  Jeff H. Perkins,et al.  Automatically generating refactorings to support API evolution , 2005, PASTE '05.

[82]  Ralph E. Johnson,et al.  Refactoring-Aware Configuration Management for Object-Oriented Programs , 2007, 29th International Conference on Software Engineering (ICSE'07).

[83]  David Notkin,et al.  Semi-automatic update of applications in response to library changes , 1996, 1996 Proceedings of International Conference on Software Maintenance.

[84]  Günter Kniesel,et al.  JMangler - a framework for load-time transformation of Java class files , 2001, Proceedings First IEEE International Workshop on Source Code Analysis and Manipulation.

[85]  William G. Griswold,et al.  Beyond refactoring: a framework for modular maintenance of crosscutting design idioms , 2007, ESEC-FSE '07.

[86]  Jason Maassen,et al.  An efficient implementation of Java's remote method invocation , 1999, PPoPP '99.

[87]  Wu-chun Feng,et al.  A Maintainable Software Architecture for Fast and Modular Bioinformatics Sequence Search , 2007, 2007 IEEE International Conference on Software Maintenance.

[88]  Stefan Roock,et al.  Refactoring Tags for automatic refactoring of framework dependent applications , 2002 .