A pattern language for extensible program representation

For the last 15 years, implementors of multiple view programming environments have sought a single code model that would form a suitable basis for all of the program analyses and tools that might be applied to the code. They have been unsuccessful. The consequences are a tendency to build monolithic, single-purpose tools, each of which implements its own specialized analyses and optimized representation. This restricts the availability of the analyses, and also limits the reusability of the representation by other tools. Unintegrated tools also produce inconsistent views, which reduce the value of multiple views. This paper describes a set of architectural patterns that allow a single, minimal representation of program code to be extended as required to support new tools and program analyses, while still maintaining a simple and uniform interface to program properties. The patterns address efficiency, correctness and the integration of multiple analyses and tools in a modular fashion.

[1]  David W. Binkley,et al.  Program slicing , 2008, 2008 Frontiers of Software Maintenance.

[2]  Prashant Jain,et al.  Pattern Oriented Software Architecture: Patterns for Resource Management , 2007, 2007 Working IEEE/IFIP Conference on Software Architecture (WICSA'07).

[3]  Gary T. Leavens,et al.  MultiJava: Design rationale, compiler implementation, and applications , 2006, TOPL.

[4]  Oscar Nierstrasz,et al.  Traits: A mechanism for fine-grained reuse , 2006, TOPL.

[5]  Kim Mens,et al.  Co-evolving code and design with intensional views: A case study , 2005, Comput. Lang. Syst. Struct..

[6]  Yanhong A. Liu,et al.  Incrementalization across object abstraction , 2005, OOPSLA '05.

[7]  Olin Shivers,et al.  Demand-Driven Type Inference with Subgoal Pruning: Trading Precision for Scalability , 2004, ECOOP.

[8]  Nathanael Schärli,et al.  Traits: tools and methodology , 2004, Proceedings. 26th International Conference on Software Engineering.

[9]  Nathanael Schärli,et al.  A browser for incremental programming , 2004, Comput. Lang. Syst. Struct..

[10]  Daniel Vainsencher,et al.  MudPie: layers in the ball of mud , 2004, Comput. Lang. Syst. Struct..

[11]  Michael Kirchner,et al.  面向模式的软件体系结构. 卷3, 设计系列 = Pattern-oriented software architecture. Volume 3, Patterns for resource management , 2004 .

[12]  Andrew P. Black,et al.  The Case for Multiple Views , 2004, ICSE 2004.

[13]  Kent Beck,et al.  Contributing to Eclipse - principles, patterns, and plug-ins , 2003, The Eclipse series.

[14]  Oscar Nierstrasz,et al.  Traits: Composable Units of Behaviour , 2002, ECOOP.

[15]  Als-Nscort.  Eclipse Platform Technical Overview , 2003 .

[16]  Michael L. Van de Vanter,et al.  The documentary structure of source code , 2002, Inf. Softw. Technol..

[17]  Richard P. Gabriel,et al.  Foundation for a C++ Programming Environment , 2002 .

[18]  Linda Rising.  Design patterns in communications software , 2001 .

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

[20]  Stéphane Ducasse,et al.  Towards a Methodology for the Understanding of Object-Oriented Systems (Vers une méthodologie pour la compréhension d'applications objets) , 2001, Tech. Sci. Informatiques.

[21]  Ron Jeffries,et al.  Extreme Programming Installed , 2000 .

[22]  Gary T. Leavens,et al.  MultiJava: modular open classes and symmetric multiple dispatch for Java , 2000, OOPSLA '00.

[23]  John Maloney,et al.  Back to the Future The Story of Squeak, A Practical Smalltalk Written in Itself , 1997 .

[24]  Erich Gamma.  Extension object , 1997 .

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

[26]  B. F. Castro.  Buschmann, Frank; Meunier, Regine; Rohnert, Hans; Sommerlad, Peter; Stal, Michael. Pattern-oriented software architecture: a system of patterns, John Wiley & Sons Ltd, 1996 , 1997 .

[27]  Kent Beck,et al.  Kent Beck's Guide to Better Smalltalk: SIMPLE SMALLTALK TESTING , 1997 .

[28]  Chris Marlin.  Multiple views based on unparsing canonical representations—the MultiView architecture , 1996, ISAW '96.

[29]  Kent L. Beck.  Smalltalk best practice patterns , 1996 .

[30]  Kent Beck,et al.  Lazy optimization: patterns for efficient Smalltalk programming , 1996 .

[31]  Scott Meyers,et al.  More Effective C++: 35 New Ways to Improve Your Programs and Designs , 1995 .

[32]  Dirk Riehle,et al.  A pattern language for tool construction and integration based on the tools and materials metaphor , 1995 .

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

[34]  Ralph E. Johnson,et al.  Design Patterns: Abstraction and Reuse of Object-Oriented Design , 1993, ECOOP.

[35]  Robert B. Murray,et al.  C++ Strategies and Tactics , 1993 .

[36]  Steven P. Reiss,et al.  An empirical study of multiple-view software development , 1992, SDE 5.

[37]  Steven P. Reiss,et al.  A system for multiparadigm development of software systems , 1991, Proceedings of the Sixth International Workshop on Software Specification and Design.

[38]  S. Meyers.  Difficulties in integrating multiview development systems , 1991, IEEE Software.

[39]  Richard P. Gabriel.  Lisp : Good News Bad News How to Win Big , 1990 .

[40]  David Garlan,et al.  Views for Tools in Integrated Environments , 1986, Advanced Programming Environments.

[41]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[42]  Thomas Reps,et al.  Programming Techniques and Data Structures , 1981 .

[43]  Tim Teitelbaum.  The Cornell Program Synthesizer: a syntax-directed programming environment , 1979, SIGP.