Language-Parametric Program Restructuring
-- NWO Research Project (Software Engineering) --

Vrije Universiteit and Centrum voor Wiskunde en Informatica

Project approved per July 17, 2003, 2 PhD students for 4 years


Program restructuring is the key technology for achieving scalability of various processes and methods in software maintenance, or, more specifically, in software reengineering. Program restructuring is used to revitalise legacy software by migrations and conversions, to perform mass changes as batch jobs, and to interactively refactor code. Program restructuring or program transformation is crucial in other contexts of software development as well; it is at the heart of current trends for 'intentional programming', 'aspect weaving', `aspect mining', `open compilers', and others.

While previous work is normally geared towards specific languages and specific restructuring scenarios, the present project aims at a general approach to program restructuring that abstracts from language and application specifics in a well-defined manner. This means that operator suites for program restructuring can be reused for different languages (be it for Java and Cobol and Haskell), and for different restructuring tasks. It also means that the derivation of restructuring tools can be further automated.

The project is centred around the following deliverables:

An approach to the executable specification for language-parametric program restructuring.
A framework with analyses and transformations for language-parametric program restructuring.
Properties of language-parametric functionality and their validation.
Framework instantiations for specific languages and specific usage scenarios.
Reusable dialogue models for interactive program restructuring.
We bundle expertise in program transformation, formal language definition, executable specification, interactive language environments, and software re-engineering. Our approach pays attention to challenges that are posed by the application of transformation technology in the context of software re-engineering. These challenges include the multitude of languages that are subject to re-engineering, the component-based nature of restructuring tools, correctness and reliability requirements, and realities like incomplete or complex language semantics. We address these challenges with designated specification constructs, reuse methods, formal methods, as well as generic and generative programming concepts.

Research Team

Name Affiliation Phone  
NN1 NWO OiO (at CWI)    
NN2 NWO OiO (at VU)    
Dr. M. van den Brand CWI & VU 020 592 4213  
J. Heering CWI 020 592 4130  
Prof. Dr. P. Klint CWI & UvA 020 592 4126 supervisor NN1
Dr. R. Lämmel VU & CWI 020 444 7824 principal Investigator
Prof. Dr. C. Verhoef VU 020 444 7760 supervisor NN2

The team involves two research groups, namely Prof. P. Klint's group at CWI, which specialises in Interactive Software Development and Renovation (Dept. Software Engineering), and Prof. C. Verhoef's group at VU, which specialises in Information Systems and Software Maintenance (Dept. Information Management and Software Engineering). The project application asks for two funded researchers, i.e., one for each group. The assembled research team joins efforts and expertise in executable specification (to `implement' operators and suites for formal restructuring), program transformation (the notion underlying program restructuring), formal methods (to enable formal reason about framework and instantiation properties), formal language definition (to transpose semantic concepts to the restructuring context), generic programming (to provide a concise specification of restructuring), software re-engineering (as the primary application domain), and interactive language tools (to enable complete automation of program restructuring). The precursor NWO project 612.014.006 -- ``Generation of Program Transformation Systems'' -- delivered key publications.

Scientific Problem

The situation in program restructuring is comparable to the situation in formal language definition in the early 1980ies: little is known about the fundamental building blocks of restructuring environments. They are usually designed and implemented for both a specific language and a specific usage scenario. This is in contrast to the desired situation where such specific environments are derived from reusable building blocks using appropriate forms of modular composition. The present project will work out methods, specification constructs, and further concepts to supply a notion of LANGUAGE-PARAMETRIC PROGRAM RESTRUCTURING. In this course, we will identify and organise restructuring notions that apply to many different languages and usage scenarios. As a result, one can reason about restructuring in the abstract. We will capture the restructuring notions in a language-parametric framework, which is complemented by a method for deriving specific restructuring environments in a well-defined manner.

Major deliverables

An approach to the executable specification for language-parametric program restructuring.
A framework with analyses and transformations for language-parametric program restructuring.
Properties of language-parametric functionality and their validation.
Framework instantiations for specific languages and specific usage scenarios.
Reusable dialogue models for interactive program restructuring.
This development will naturally involve the integration and reconciliation of so far scattered research results and applications scenarios for program restructuring. Here are few examples. Firstly, there are fundamental notions of program transformation which are often spelled out in a specific context, e.g., the beautiful notion of stepwise enhancement [Lak89,PS90,SS94,KMS96], which is geared towards logic programming. This is an `obvious' candidate to be lifted to the language-parametric level. Secondly, today's software development landscape has created many application scenarios for transformation, e.g., refactoring [Opd92,Fow99], component composition [Aßm98], aspect weaving [KLM$^+$97,FS98,Aßm97,Läm99,AL99], and legacy software renovation [ABFP86,SSV02,Sne98]. The speed at which these scenarios pop up truly calls for a more language-parametric approach. Also, such often pragmatic results invite for an extraction of concerns that can be formally captured in a language-parametric setup, e.g., means of abstraction to account for the lack of a full language semantics in re-engineering.

Research Method

There are the following cornerstones of a research method:

Significance of the research project

The overall contribution of the project can be stated as follows. Previous research results on program restructuring are integrated by capturing the key notions in a manner that they are normative for performing restructuring for the full range of programming languages, and in the different application contexts. This is a normal, genuine process in science.

The current situation is different. For example, beautiful theoretical results, even if they are relevant for program restructuring, are not accessible in the often rather applied contexts of program transformation. Examples of the former include work by Pettorossi et al. [PP96], or by Sheard, Taha, et al. [TS97,She01], or by Cousot and Cousot [CC02]. There is nothing worse than theory which is not applied although its potential applications are just there, e.g., in the context of aspect weaving and refactoring. This distance problem also backfires in the other direction. Software re-engineering, as an applied discipline, so far triggered only little basic research on program transformation, but this is very well possible and eligible. There are, for example, original ideas for reasoning about correctness of transformations, without insisting on a full semantics. These ideas of abstraction would need to be formally worked out. It is similar but not identical to the formal notion of abstract interpretation [CC02]. Our project is dedicated to the integration of research results on program restructuring. This includes decreasing the gap between theory and practice.

At a more concrete level, the significance of the project can be stated in terms of the following added value for program restructuring with immediate benefits for software re-engineering:

This is challenging, interdisciplinary subject. We are confident that this is the right time for such an endeavour because a large body of foundations on program transformation, program analysis, meta-programming, formal specification, and programming language semantics has been accumulated while important application domains of program restructuring call for improved reuse, reliability, scalability, and automation.

Related Work

Throughout this text, we pointed out that program restructuring is typically studied in the context of a particular paradigm or even a specific programming language, and then normally in the context of a certain application scenario. There is an enormous amount of related work. Here are some indications grouped per language: object-oriented programs [Opd92,Moo96,RBJ97,Sne98,Fow99], logic programs [PS90,PP96], (higher-order) functional programs [PP96,Bel95,Läm00,TR01], grammars or syntax definitions [Pep99,Läm01], preprocessor macros [Fav96,KR01], and so on.

There is a perception of program transformation, which is less applicable for our purposes, namely the mathematical calculation of programs. In this area, one typically aims at deriving efficient programs from high-level specifications [Par90,dRE98]. We share with this perception the interest in preservation properties such as semantics preservation. In our case, semantics preservation is often constrained by structural properties to make given restructuring goals feasible, to be able to check for correctness, or to take characteristics of a given code portfolio into account. In the re-engineering context, program restructuring relies on weaker properties than conservative semantics preservation.

The idea of reusable building blocks for program analyses and transformations is not new. Relevant elements play a role in related work on language processing and language implementation. For example, the Stratego project [VBT98,Vis00,Vis01] advocates generic traversal schemes for analysis and transformation, which can be instantiated by language-specific ingredients. A good example is a free variable analysis with arguments for the declaring and referring constructs. Similar ideas have been proposed on the basis of extensions of the attribute grammar formalisms, most notably in [FMY92,KW94,SS99]. There are ingredients of our project that are not addressed by such related work, in particular:

In the terminology of meta-programming [She01], program transformations for restructuring are meta-programs on object programs. The present project poses a challenge for meta-programming in that the object language has to be viewed as a parameter. Contrast that with the common situation where meta-language and object language are fixed [BK82,Bow98,TS00,ER02,SP02], and they are normally even amalgamated. Nevertheless, research on meta-programming has revealed a number of notions that are valuable in our project. To give a concrete example, in the Ergo project, higher-order abstract syntax [PE88] is used for the representation of object programs. Higher-order abstract syntax allows to capture the binding constructs of a language, which implies that meta-programs immediately respect this part of the language semantics. Further examples of the relevance of meta-programming include the following:

Detailed deliverables

We will now elaborate on the major deliverables [a]-[e] that were stated earlier. The detailed deliverables will be arranged in categories ``Inventory'', ``Foundations'', and ``Automation''.

Deliverables in the category Inventory:

Modular semantics. The different approaches to formal semantics support modularity in some way or another. That is, the different language concepts can be specified in separation, and the corresponding constructs can be combined in different language designs. These techniques are analysed in depth to identify what ideas can be transposed to the program restructuring context.
Abstraction mechanisms in program transformation. Some work on program transformation and analysis attempts to cover an entire class of languages. Also, the idea of the ultimate intermediate representation is ubiquitous. A well-organised inventory of these techniques including their limitations regarding a seamless, and general language-parametric restructuring approach is needed.
Operators suites for program restructuring. In the various specific contexts of program restructuring, many different operator suites have been proposed with completely different designs, usage scenarios, and targeted applications. All such operator suites will be systematically categorised to use this existing know-how in our language-parametric approach.
Principles of tool support. Program restructuring is either performed in an interactive manner or in batch jobs. Looking at academic as well as commercial setups, we will make an inventory of the principles underlying such tool support. For example: what kind of dialogs are offered, what forms of consistency checking are used, what kind of mechanisms for evolution and feedback are provided.
Semi-automatic user interface design. In the area of graphical user interface design, it is an established approach to generate semi-automatically interfaces or prototypes thereof from analysis and design artifacts, e.g., from process models or work-flows. An inventory of these approaches will be of use to link interactive program restructuring and the underlying specifications in a similar way.
Deliverables in the category Foundations:
Abstraction and modularity mechanisms. We will identify and integrate all forms of polymorphism and modular composition that are relevant for language-parametric restructuring. For example, it is clear that generic traversal is indispensable to handle complex syntactical or other structures. At the same time, provisions are needed to abstract from the specific static and dynamic semantics of a language.
Properties of restructuring operators. In a naive sense, operators should preserve well-typedness and semantics. In order to be scalable, and to cover all scenarios of program restructuring, the provision of well-founded weaker properties is a main goal of this project. This deliverable is challenged by the aspiration to be language-parametric.
Properties of operator suites. The design space of properties, and the methods to enforce them need to be identified. Typical properties of suites are completeness (e.g., `editing' completeness), orthogonality, implementability, scalability, usability, most general abstraction, and relations between operator suites.
Obligations for framework instantiation. The instantiation of language-parametric program transformations for a specific language is more than `parameter passing' because we want to retain abstract properties of the framework in the obtained instantiation. So the obligations for the instantiation process need to be identified, and the process needs to be set up in a way to enforce the obligations.
An executable specification language. This is the culmination point of the development. The ultimate specification language should not just cover the actual transformation rules based on seamless support for the needed abstraction mechanisms, but also all kinds of formal aspects related to the properties of the operators, properties of the operator suites, and the obligations for the instantiation.
Deliverables in the category Automation:
Encoding schemes. Using existing specification or programming languages like ASF+SDF, Haskell, Stratego and Prolog the executable specification of language-parametric transformations is attempted. This will uncover the trade-offs of using such technology, it will trigger suggestions for extensions, and it will lead to familiarity with the programming idioms in the area of program restructuring.
Extension of the Meta-Environment. The ASF+SDF Meta-Environment [Kli93,BDH$^+$01] is our primary setup for providing specification and tool support for language-parametric restructuring. Its component-based architecture will allow us to integrate external components whenever necessary, taking advantage of standard components, e.g., for parsing, and pretty printing. We will extend our Meta-Environment technology to support the specification language as of [F5].
Language-specific restructuring tools. Using the developed methods, the designed specification language, and the prototyped technology, we will derive actual language-specific restructuring tools in the framework as a proof-of-concept. We will reconstruct a refactoring browser for Java, a goto-elimination tool for Cobol, and maybe tools for one or two other languages.
Semi-automated browser derivation. The ASF+SDF Meta-Environment supports the development of interactive language tools. For example, this is automated for structure editors, but there is little support for the automated derivation of interactive restructuring tools. So we need to complement our specification approach in a way to enable a semi-automatic derivation of such tools.
Integration of proof checkers and theorem provers. The automated verification of properties and obligations necessitates the employment of proof checkers or theorem provers. These encodings need to be defined: the program transformations, the properties of operators and suites, the abstractions of the object language semantics, and the obligations for instantiation.

Key publications

The following publications by the applicants lay out relevant results that will contribute to the conception of language-parametric program restructuring:
This paper proposes the notion of ``generic refactoring'', which is a special case of language-parametric program restructuring. The paper demonstrates the feasibility of a generic approach to certain program transformations using a specific technical setup based on generic functional programming. The present project aims at the following generalisation:
These two papers develop central expressiveness for the executable specification of generic program analyses and transformations. The central idea is to support a clear separation of problem-specific functionality and otherwise generic traversals.
This paper accomplishes a tool-oriented approach to the semantics of programming languages. Restructuring tools are among the many tools that can be derived from executable semantics specifications, maybe using ``language design assistants'' which incorporate large parts of language knowledge that can effectively assist tool development. A good example is the specification of scope rules of a language that can be used in many tools.
This paper discusses a powerful program restructuring approach for the challenging Cobol language. Certain elements of language parametricity are present. For example, most of the Cobol syntax and semantics is irrelevant for this approach. There is ongoing work on proving the correctness of the transformations using an abstract semantics as opposed to the full Cobol semantics.
This paper develops a formal transformational toolkit (i.e., an equational logic) for tools that analyse and manipulate programs. The language underlying the logic is a (so to say language-parametric) intermediate language which can be naturally targeted from many specific programming languages. The paper proves completeness of the setup in the sense that, in particular, all semantics-preserving transformations can be derived in the logic.
There are several other publications by the applicants that will be of use in this project that seeks integration of research results on program transformation: [BHK89,Kli93,DHK96,BKV96,BKV97,BSV97,BK98,Läm98,DKV99,Läm99,DKV00,Läm00,BSV00,BDH$^+$01,LV01,BHKO02,LV02,Läm02a,LV03].


G. Arango, I. Baxter, P. Freeman, and C. Pidgeon.
TMM: Software maintenance by transformation.
IEEE Software, 3(3):27-39, May 1986.

U. Aßmann and A. Ludwig.
Aspect weaving by graph rewriting.
In U.W. Eisenecker and K. Czarnecki, editors, Generative Component-based Software Engineering (GCSE), volume 1799 of Lecture Notes in Computer Science, pages 24-36. Springer-Verlag, October 1999.

U. Aßmann.
AOP with design patterns as meta-programming operators.
Technical Report 28, Universität Karlsruhe, October 1997.

U. Aßmann.
Meta-programming composers in second-generation component systems.
In J. Bishop and N. Horspool, editors, Systems Implementation 2000 - Working Conference IFIP WG 2.4, Berlin, February 1998. Chapman and Hall.

J. A. Bergstra, T. B. Dinesh, J. Field, and J. Heering.
Toward a complete transformational toolkit for compilers.
ACM Transactions on Programming Languages and Systems, 19(5):639-684, September 1997.

M.G.J. van den Brand, Deursen, A. van, J. Heering, H.A. de Jong, M. de Jonge, T. Kuipers, P. Klint, L. Moonen, P.A. Olivier, J. Scheerder, J.J. Vinju, E. Visser, and J. Visser.
The ASF+SDF Meta-Environment: a Component-Based Language Development Environment.
In R. Wilhelm, editor, Compiler Construction (CC '01), volume 2027 of Lecture Notes in Computer Science, pages 365-370. Springer-Verlag, 2001.

F. Bellegarde.
Notes for Pipelines of Transformations for ML.
Technical Report 95-021, Oregon Graduate Institute, 1995.

J.A. Bergstra, J. Heering, and P. Klint.
The algebraic specification formalism ASF.
In J.A. Bergstra, J. Heering, and P. Klint, editors, Algebraic Specification, ACM Press Frontier Series, pages 1-66. The ACM Press in co-operation with Addison-Wesley, 1989.

M.G.J. van den Brand, J. Heering, P. Klint, and P.A. Olivier.
Compiling language definitions: the ASF+SDF compiler.
ACM Transactions on Programming Languages and System, 24(4):334-368, 2002.

R. Backhouse, P. Jansson, J. Jeuring, and L. Meertens.
Generic programming -- an introduction.
In Swierstra et al. [SHO99], pages 28-115.

K.A. Bowen and R.A. Kowalski.
Amalgamating Language and Metalanguage in Logic Programming.
In K.L. Clark and S.-A. Tarnlund, editors, Logic programming, volume 16 of APIC studies in data processing, pages 153-172. Academic Press, 1982.

J. Bergstra and P. Klint.
The discrete time ToolBus - a software coordination architecture.
Science of Computer Programming, 31(2-3):205-230, 1998.

M.G.J. van den Brand, P. Klint, and C. Verhoef.
Core technologies for system renovation.
In K.G. Jeffery, J. Král, and M. Bartosek, editors, SOFSEM'96: Theory and Practice of Informatics, volume 1175 of LNCS, pages 235-255. Springer-Verlag, 1996.

M.G.J. van den Brand, P. Klint, and C. Verhoef.
Re-engineering needs generic programming language technology.
ACM SIGPLAN Notices, 32(2):54-61, 1997.

M.G.J. van den Brand, P. Klint, and J.J. Vinju.
Term rewriting with traversal functions.
Technical Report SEN-R0121, CWI, July 2001.
Submitted for journal publication.

A. Bowers.
Effective Meta-programming in Declarative Languages.
PhD thesis, Department of Computer Science, University of Bristol, January 1998.

M.G.J. van den Brand, M.P.A. Sellink, and C. Verhoef.
Generation of components for software renovation factories from context-free grammars.
In I.D. Baxter, A. Quilici, and C. Verhoef, editors, Proceedings Fourth Working Conference on Reverse Engineering, pages 144-153, 1997.

M.G.J. van den Brand, M.P.A. Sellink, and C. Verhoef.
Generation of Components for Software Renovation Factories from Context-free Grammars.
Science of Computer Programming, 36(2-3):209-266, 2000.

P. Cousot and R. Cousot.
Systematic design of program transformation frameworks by abstract interpretation.
In Conference Record of POPL'02: The 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 178-190, Portland, Oregon, January 16-18, 2002.

R. Cartwright and M. Felleisen.
Extensible denotational language specifications.
In M. Hagiya and J.C. Mitchell, editors, Theoretical Aspects of Computer Software: International Symposium, volume 789 of LNCS, pages 244-272. Springer-Verlag, April 1994.

R. Cytron, J. Ferrante, B.K. Rosen, M.N. Wegman, and F.K. Zadeck.
Efficiently computing static single assignment form and the control dependence graph.
ACM Transactions on Programming Languages and Systems, 13(4):451-490, October 1991.

J.R.B. Cockett and D. Spencer.
Strong categorical datatypes I.
In R.A.G. Seely, editor, Proceedings Int. Summer Category Theory Meeting, Montréal, Québec, 23-30 June 1991, volume 13 of Canadian Mathematical Society Conf. Proceedings, pages 141-169. American Mathematical Society, Providence, RI, 1992.

Deursen, A. van, J. Heering, and P. Klint, editors.
Language Prototyping, volume 5 of AMAST Series in Computing.
World Scientific, 1996.

Deursen, A. van, P. Klint, and F. Tip.
Origin tracking.
In 217, page 48. Centrum voor Wiskunde en Informatica (CWI), ISSN 0169-118X, December 31 1992.

Deursen, A. van, P. Klint, and C. Verhoef.
Research issues in software renovation.
In J.-P. Finance, editor, Fundamental Approaches to Software Engineering (FASE '99), pages 1-21. LNCS, 1999.

Deursen, A. van, P. Klint, and J. Visser.
Domain-specific languages: An annotated bibliography.
ACM SIGPLAN Notices, 35(6):26-36, June 2000.

W.-P. de Roever and K. Engelhardt.
Data Refinement: Model-Oriented Proof Methods and their Comparison, volume 47 of Cambridge Tracts in Theoretical Computer Science.
Cambridge University Press, New York, NY, 1998.

U.W. Eisenecker and K. Czarnecki.
Generative Programming: Methods, Tools, and Applications.
Addison-Wesley, 2000.

M. Erwig and D. Ren.
A rule-based language for programming software updates.
In Proceedings of the 2002 ACM SIGPLAN workshop on Rule-based programming, pages 67-78. ACM Press, 2002.

M. Erwig and D. Ren.
Type-Safe Update Programming.
In Proc. of 12th European Symp. on Programming (ESOP'03), 2003.
To appear.

J. Favre.
Preprocessors from an abstract point of view.
In Proc. of the International Conference on Software Maintenance, pages 329-339, Washington, November 4-8 1996. IEEE Computer Society Press.

R. Farrow, T.J. Marlowe, and D.M. Yellin.
Composable Attribute Grammars.
In Proc. of 19th ACM Symposium on Principles of Programming Languages (Albuquerque, NM), pages 223-234, January 1992.

J. Ferrante, K.J. Ottenstein, and J.D. Warren.
The Program Dependence Graph and Its Use in Optimization.
ACM Transactions on Programming Languages and Systems, 9(3):319-349, July 1987.

M. Fowler.
Refactoring: Improving the Design of Existing Code.
Addison Wesley, 1999.

P. Fradet and M. Südholt.
AOP: towards a generic framework using program transformation and analysis.
In Position papers of the Aspect-Oriented Programming Workshop at ECOOP'98, July 1998.

Y. Gurevich.
Evolving Algebras 1993: Lipari Guide.
In E. Börger, editor, Specification and Validation Methods, pages 9-36. Oxford University Press, 1995.

G. Hedin.
An Overview of Door Attribute Grammars.
In P. Fritzon, editor, Compiler Construction, 5th International Conference, volume 786 of Lecture Notes in Computer Science, pages 31-51, Edinburgh, U.K., 7-9 April 1994. Springer.

R. Hinze.
A New Approach to Generic Functional Programming.
In T.W. Reps, editor, Conference record of POPL '00: the 27th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 119-132. ACM Press, January 2000.

J. Heering and P. Klint.
Semantics of programming languages: A tool-oriented approach.
ACM SIGPLAN Notices, 35(3):39-48, March 2000.

J.-L. Hainaut, C. Tonneau, M. Joris, and M. Chandelon.
Schema Transformation Techniques for Database Reverse Engineering.
In Proc. of the 12th Int. Conf. on ER Approach, Arlington-Dallas, 1993. E/R Institute.

C.B. Jay.
Distinguishing data structures and functions: the constructor calculus and functorial types.
In S. Abramsky, editor, Typed Lambda Calculi and Applications: 5th International Conference TLCA 2001, Kraków, Poland, May 2001, Proceedings, volume 2044 of LNCS, pages 217-239. Springer-Verlag, 2001.

P. Jansson and J. Jeuring.
PolyP - a Polytypic Programming Language Extension.
In Conference record POPL '97: the 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 470-482. ACM Press, 1997.

J. Kort and R. Lämmel.
A Framework for Datatype Transformation.
Technical Report cs.PL/0204018, arXiv, December 2002.
23 pages; 2nd edition.

P. Klint.
A meta-environment for generating programming environments.
ACM Transactions on Software Engineering and Methodology, 2(2), pages 176-201, 1993.

G. Kiczales, J. Lamping, A. Mendhekar, C. Maeda, C. Lopes, J.-M. Loingtier, and J. Irwin.
Aspect-oriented programming.
In M. Aksit and S. Matsuoka, editors, Proc. of ECOOP'97--Object-Oriented Programming, 11th European Confernce, volume 1241 of LNCS, pages 220-242, Jyväskylä, Finland, 9-13 June 1997. Springer-Verlag.

M. Kirschenbaum, S. Michaylov, and L.S. Sterling.
Skeletons and Techniques as a Normative Approach to Program Development in Logic-Based Languages.
In Proceedings ACSC'96, Australian Computer Science Communications, 18(1), pages 516-524, 1996.

B. Kuhlbach and V. Riediger.
Folding: An Approach to Enable Program Understanding of Preprocessed Languages.
In E. Burd, P. Aiken, and R. Koschke, editors, Proc. of Eighth Working Conference on Reverse Engineering; WCRE'01, pages 3-12. IEEE Computer Society, 2001.

U. Kastens and W.M. Waite.
Modularity and reusability in attribute grammars.
Acta Informatica 31, pages 601-627, 1994.

A. Lakhotia.
A Workbench for Developing Logic Programs by Stepwise Enhancement.
PhD thesis, Case Western Reserve University, 1989.

R. Lämmel.
Functional meta-programs towards reusability in the declarative paradigm.
PhD thesis, Universität Rostock, Fachbereich Informatik, 1998.
Published by Shaker Verlag, ISBN 3-8265-6042-6.

R. Lämmel.
Declarative aspect-oriented programming.
In O. Danvy, editor, Proc. of 1999 ACM SIGPLAN Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM'99), San Antonio (Texas), BRICS Notes Series NS-99-1, pages 131-146, January 1999.

R. Lämmel.
Reuse by Program Transformation.
In Greg Michaelson and Phil Trinder, editors, Functional Programming Trends 1999. Intellect, 2000.
Selected papers from the 1st Scottish Functional Programming Workshop.

R. Lämmel.
Grammar Adaptation.
In J.N. Oliveira and P. Zave, editors, Proc. Formal Methods Europe (FME) 2001, volume 2021 of LNCS, pages 550-570. Springer-Verlag, 2001.

R. Lämmel.
The Sketch of a Polymorphic Symphony.
In B. Gramlich and S. Lucas, editors, Proc. of International Workshop on Reduction Strategies in Rewriting and Programming (WRS 2002), volume 70 of ENTCS. Elsevier Science, 2002.
21 pages.

R. Lämmel.
Towards Generic Refactoring.
In Proc. of Third ACM SIGPLAN Workshop on Rule-Based Programming RULE'02, Pittsburgh, USA, October5 2002. ACM Press.
14 pages.

R. Lämmel.
Typed Generic Traversal With Term Rewriting Strategies.
Journal of Logic and Algebraic Programming, 54:1-64, September 2002.

S. Liang, P. Hudak, and M.P. Jones.
Monad transformers and modular interpreters.
In ACM, editor, Conference record of POPL '95, 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages: papers presented at the Symposium: San Francisco, California, January 22-25, 1995, pages 333-343, New York, NY, USA, 1995. ACM Press.

R. Lämmel and W. Lohmann.
Format Evolution.
In Proc. of 7th International Conference on Reverse Engineering for Information Systems (RETIS 2001), volume 155 of OCG, 2001.

R. Lämmel and S. Peyton Jones.
Scrap your boilerplate: a practical design pattern for generic programming.
In Proc. of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation, pages 26-37. ACM Press, 2003.

R. Lämmel and G. Riedewald.
Reconstruction of paradigm shifts.
In Proc. of Second Workshop on Attribute Grammars and their Applications, WAGA 99, pages 37-56, March 1999.
Published as INRIA Technical Report, ISBN 2-7261-1138-6.

R. Lämmel and C. Verhoef.
Cracking the 500-Language Problem.
IEEE Software, pages 78-88, November/December 2001.

R. Lämmel and J. Visser.
Typed Combinators for Generic Traversal.
In S. Krishnamurthi and C.R. Ramakrishnan, editors, Proc. of Practical Aspects of Declarative Programming PADL 2002, volume 2257 of LNCS, pages 137-154. Springer-Verlag, January 2002.

R. Lämmel and J. Visser.
A Strafunski Application Letter.
In V. Dahl and P. Wadler, editors, Proc. of Practical Aspects of Declarative Programming 2003 (PADL'03), LNCS. Springer-Verlag, January 2003.
To appear; 18 pages.

E. Moggi.
Notions of computation and monads.
Information and Computation, 93(1):55-92, July 1991.

I. Moore.
Automatic Inheritance Hierarchy Restructuring and Method Refactoring.
In OOPSLA '96 Conference Proc.: Object-Oriented Programming Systems, Languages, and Applications, pages 235-250. ACM Press, 1996.

P.D. Mosses.
Action Semantics.
Number 26 in Cambridge Tracts in Theoretical Computer Science. Cambridge University Press, 1992.

P.D. Mosses.
Foundations of Modular SOS.
Technical Report RS-99-54, BRICS Report Series, December 1999.

W.F. Opdyke.
Refactoring Object-Oriented Frameworks.
PhD thesis, University of Illinois at Urbana-Champaign, 1992.

H.A. Partsch.
Specification and Transformation of Programs.
Springer-Verlag, 1990.

F. Pfenning and C. Elliot.
Higher-order abstract syntax.
ACM SIGPLAN Notices, 23(7):199-208, July 1988.

P. Pepper.
LR Parsing = Grammar Transformation + LL Parsing.
Technical Report CS-99-05, TU Berlin, April 1999.

Frank Pfenning.
Elf: A language for logic definition and verified meta-programming.
In Fourth Annual Symposium on Logic in Computer Science, pages 313-322, Pacific Grove, California, June 1989. IEEE Computer Society Press.

A. Pettorossi and M. Proietti.
Rules and Strategies for Transforming Functional and Logic Programs.
ACM Computing Surveys, 28(2):360-414, June 1996.

A.J. Power and L.S. Sterling.
A Notion of Map Between Logic Programs.
In D. Warren and P. Szeredi, editors, Proc. of 7th International Conference on Logic Programming (ICLP), pages 390-404. The MIT Press, 1990.

D. Roberts, J. Brant, and R.E. Johnson.
A Refactoring Tool for Smalltalk.
Theory and Practice of Object Systems (TAPOS), 3(4):253-263, 1997.

S. Doaitse Swierstra, P. R. A. Alcocer, and J. Saraiva.
Designing and implementing combinator languages.
In Swierstra et al. [SHO99], pages 150-206.

T. Sheard.
Accomplishments and Research Challenges in Meta-programming.
In Workshop on Semantics, Applications, and Implementation of Program Generation (SAIG 2001), volume 2196, pages 2-44, 2001.
Invited talk.

S.D. Swierstra, P.R. Henriques, and J.N. Oliveira, editors.
Advanced Functional Programming, Third International School, AFP '98, volume 1608 of LNCS, Braga, Portugal, September 1999. Springer-Verlag.

H.M. Sneed.
Objektorientierte Softwaremigration.
Addison-Wesley, 1998.
In German.

T. Sheard and S. Peyton Jones.
Template meta-programming for haskell.
In Proceedings of the workshop on Haskell workshop, pages 1-16. ACM Press, 2002.

L.S. Sterling and E.Y. Shapiro.
The Art of Prolog.
MIT Press, 1994.
2nd edition.

J. Saraiva and D. Swierstra.
Generic Attribute Grammars.
In D. Parigot and M. Mernik, editors, Second Workshop on Attribute Grammars and their Applications, WAGA'99, pages 185-204, Amsterdam, The Netherlands, March 1999. INRIA rocquencourt.

M.P.A. Sellink, H.M. Sneed, and C. Verhoef.
Restructuring of COBOL/CICS Legacy Systems.
Science of Computer Programming, 45(2-3):193-243, 2002.

D. Swierstra and H. Vogt.
Higher Order Attribute Grammars.
In Henk Alblas and Borivoj Melichar, editors, Attribute grammars, Applications and Systems, Proceedings of the International Summer School SAGA, Prague, Czechoslovakia, volume 545 of LNCS, pages 256-296. Springer-Verlag, June 1991.

S. Thompson and C. Reinke.
Refactoring Functional Programs.
Technical Report 16-01, Computing Laboratory, University of Kent at Canterbury, October 2001.

W. Taha and T. Sheard.
Multi-stage programming.
In Proceedings of the ACM SIGPLAN International Conference on Functional Programming (ICFP-97), volume 32,8 of ACM SIGPLAN Notices, pages 321-321, New York, June 9-11 1997. ACM Press.

W. Taha and T. Sheard.
MetaML and multi-stage programming with explicit annotations.
Theoretical Computer Science, 248(1-2):211-242, October 2000.

E. Visser, Z. Benaissa, and A. Tolmach.
Building Program Optimizers with Rewriting Strategies.
In International Conference on Functional Programming (ICFP'98), volume 34.1 of ACM Sigplan Notices, pages 13-26. ACM Press, September 1998.

E. Visser.
Language Independent Traversals for Program Transformation.
In J. Jeuring, editor, Proc. of WGP'2000, Technical Report, Universiteit Utrecht, pages 86-104, July 2000.

E. Visser.
Stratego: A Language for Program Transformation based on Rewriting Strategies. System Description of Stratego 0.5.
In A. Middeldorp, editor, Rewriting Techniques and Applications (RTA'01), volume 2051 of LNCS, pages 357-361. Springer-Verlag, May 2001.

About this document ...

Language-Parametric Program Restructuring
-- NWO Research Project (Software Engineering) --

This document was generated using the LaTeX2HTML translator Version 2002 (1.62)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html abstract.tex -split 0 -nonavigation -html_version 4.0 -lcase_tags

The translation was initiated by Vadim Zaytsev on 2005-01-26

Vadim Zaytsev 2005-01-26