Supporting Software Development Tools with An Awareness of Transparent Program Transformations

Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in transparently introducing various concerns, including persistence, distribution, and security. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program’s runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code. This research presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware.

[1]  Shinji Kusumoto,et al.  Debugging support for aspect-oriented program based on program slicing and call graph , 2004, 20th IEEE International Conference on Software Maintenance, 2004. Proceedings..

[2]  James R. Larus,et al.  Reflective program generation with patterns , 2006, GPCE '06.

[3]  Alfred V. Aho,et al.  Debugging Aspect-Enabled Programs , 2007, SC@ETAPS.

[4]  Julia L. Lawall,et al.  Towards easing the diagnosis of bugs in OS code , 2007, PLOS '07.

[5]  Gregor Kiczales,et al.  Aspect-oriented programming , 1996, CSUR.

[6]  Yannis Smaragdakis,et al.  J-Orchestra: Automatic Java Application Partitioning , 2002, ECOOP.

[7]  Craig Chambers,et al.  Debugging optimized code with dynamic deoptimization , 1992, PLDI '92.

[8]  Barbara G. Ryder,et al.  Blended analysis for performance understanding of framework-based applications , 2007, ISSTA '07.

[9]  Alonso Marquez,et al.  Implementing Orthogonally Persistent Java , 2000, POS.

[10]  Oege de Moor,et al.  JunGL: a scripting language for refactoring , 2006, ICSE.

[11]  Miguel Castro,et al.  Safe and efficient sharing of persistent objects in Thor , 1996, SIGMOD '96.

[12]  John L. Hennessy,et al.  Symbolic Debugging of Optimized Code , 1982, TOPL.

[13]  Malcolm P. Atkinson,et al.  An orthogonally persistent Java , 1996, SGMD.

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

[15]  Éric Tanter,et al.  Extending omniscient debugging to support aspect-oriented programming , 2008, SAC '08.

[16]  Michael Philippsen,et al.  JavaParty – transparent remote objects in Java , 1997 .

[17]  Thomas R. Gross,et al.  Dynamic Updating of Software Systems Based on Aspects , 2006, 2006 22nd IEEE International Conference on Software Maintenance.

[18]  Ken Friis Larsen,et al.  Incremental execution of transformation specifications , 2004, POPL.

[19]  Shane Markstrum,et al.  A framework for implementing pluggable type systems , 2006, OOPSLA '06.

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

[21]  Mary Lou Soffa,et al.  Tdb: a source-level debugger for dynamically translated programs , 2005, AADEBUG'05.

[22]  Y. Smaragdakis,et al.  Binary refactoring: improving code behind the scenes , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[23]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[24]  Steve Simmons,et al.  A new approach to debugging optimized code , 1992, PLDI '92.

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

[26]  James R. Larus,et al.  Cache-conscious structure definition , 1999, PLDI '99.

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

[28]  Michal Antkiewicz,et al.  Framework-Specific modeling languages with round-trip engineering , 2006, MoDELS'06.

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

[30]  Peter Fritzson A systematic approach to advanced debugging through incremental compilation (Preliminary Draft) , 1983, SIGSOFT '83.

[31]  Eelco Visser,et al.  Building program optimizers with rewriting strategies , 1998, ICFP '98.

[32]  Mary Lou Soffa,et al.  An approach for exploring code improving transformations , 1997, TOPL.

[33]  Christian Bauer,et al.  Hibernate in action , 2005 .

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

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

[36]  Jan F. Prins,et al.  Debugging programs after structure-changing transformation , 1998 .

[37]  Alessandro Orso,et al.  A technique for dynamic updating of Java software , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[38]  Alessandro Orso,et al.  Selective capture and replay of program executions , 2005, WODA '05.

[39]  Max Copperman Debugging optimized code without being misled , 1994, TOPL.

[40]  Markus Dahm,et al.  Byte Code Engineering , 1999, Java-Informations-Tage.

[41]  James C. King,et al.  Symbolic execution and program testing , 1976, CACM.

[42]  David S. Munro,et al.  The Napier88 Persistent Programming Language and Environment , 2000 .