Declarative Meta-programming

Contents:

• Introduction and Motivation
• What is DMP?
• Achievements
• Ongoing Work
• Artifacts and Tools
• Workshops
• Tutorials, Lectures and Presentations
• Publications
• Dissertations
• People
• DMP Related Research

The software development process deals with many phases, such as: analysis, design, coding, maintenance, evolution, etc... Adopting the classic approach to software engineering (e.g., the waterfall model), all these phases are performed separately, where the results of one phase serve as a basis for the start of another phase (e.g., designs are used to start the implementation). But in most cases, phases that occur at a later time in the software development process will require to make changes to the results of earlier phases (feedback). For example, problems that only become apparant during the implementation phase, may require changes to the design. Or even worse: software programmers can deviate from the original design without notifying the designers or maybe even without knowing that they do so. But even if programmers are aware about the impact of their change to the design, updating the design may be a time-consuming process and therefore, they might not do it. All these factors lead to enormeous problems in the long run because the entire design documentation of a software artifact is no longer up-to-date with the actual implementation.

Our research on declarative meta-programming (DMP) investigates how this technique can be used to build state-of-the-art software development support tools that help overcome these problems. The aim is to try to capture and formally express the interaction between the higher phases of software development (design, analysis, etc...) and the actual implementation level. To express this interaction between the program code and the (higher-level) documentation of a software system, we believe that a declarative programming language is highly suited. This is because documentation has a declarative nature and because we can use meta-programming to link this information to the actual code. As such, the design-information of a system is meta-information of the program itself that can be actively used by the programming environment. The result is that we can automate the co-evolution of the different phases of software development. Besides actively guiding the co-evolution of phases such as design and implementation, we also conduct research on actively generating design from implementation and vice-versa. Or the use of high-level information to support higher-level software engineering tasks (such as refactoring, evolution, guiding reuse, aspect-oriented software development, generative programming, etc...)

Logic meta-programming is an instance of declarative meta-programming, where a logic programming language is used. Hence, we express all high-level information of a software artifact in logic facts and rules. As such, we use a logic meta-level language with a standard (object-oriented) base language. For this, we require that the logic meta-programming language lives in symbiosis with the object-oriented base language, allowing base level programs to be manipulated as terms, facts or rules in the meta level. This can be achieved in various ways. In the case of Java, which is a statically typed language, this meta layer might be implemented as a preprocessor or even an extension of the Java compiler itself. In the case of Smalltalk, we can use the reflection facilities to implement a logic meta layer on top of the Smalltalk meta-object protocol. A third approach is the use of a separate logic language and base language with provisions of the logic language to externally access the repository of the base language.

Here are some useful documents to read in order to learn more about declarative meta-programming in general:

• Theo D'Hondt, Kris De Volder, Kim Mens and Roel Wuyts. Co-Evolution of Object-Oriented Software Design and Implementation, Proceedings of SACT 2000 (International Symposium on Software Architectures and Component Technology), pages 207-224, Kluwer Academic Publishers. [Download]
• Kim Mens, Isabel Michiels and R. Wuyts. Supporting Software Development through Declaratively Codified Programming Patterns, Elsevier Journal on Expert Systems with Applications, volume 23, 2002, pages 405-413, Elsevier Science. [View]
• Some tutorials, Lectures and Presentations
• And of course, this entire web page :-)

In this section, we try to provide a more precise definition of what exactly we mean by DMP. DMP stands for Declarative Meta Programming. So the short, one-line, definition of DMP would be:

"Declarative Meta Programming is the use of a Declarative Programming language at Meta level to reason about and manipulate programs built in some underlying base language."

Of course, this definition does not help us out much. First of all, it doesn't make clear what we mean by "declarative" and secondly it doesn't tell us what kind of reasoning at meta level we are interested in: what is the goal we want to use DMP for? So let us elaborate on this definition a bit more.

1. To start with, we restrict the scope to
   1. those kinds of DMP that provide support for (building) tools that support or facilitate the software development process in one way or another;
   2. those tools that address source code.
   
   
2. The "MP" part of DMP should be quite clear now, especially in the light of 1.1:
   1. it is meta programming because the tools are at a meta level with respect to the source code they want to reason about or manipulate
   2. what we can and want to do at this meta level can be almost anything, but belongs to one (or more) of the following categories (this categorization is not supposed to be restrictive, though we hope its more or less complete):
      • verification of source code to some higher-level description (for example, conformance checking to coding conventions, design models, architectural descriptions and so on)
      • extraction of information from source code (for example, visualisation, software understanding, browsing, generation of higher-level models or documentation, measurements, quality control and so on)
      • transformation of source code (for example, refactoring, translation, re-engineering, evolution, optimization and so on)
      • generation of source code
   
   
3. The "D" of DMP is maybe the most difficult one to characterize, but let us make an attempt anyway. In general, what is understood by "declarative" programming is that it is focussed on what the program is supposed to do rather than on how it will achieve its tasks.
   Unfortunately, because of the large variety of possible DMP applications (even if we take the restrictions of 1.1 and 1.2 into account), this still does not clarify much. However, it does become a bit more clear when we refine the definition for each of the categories of 2.2 separately:
   • DMP for verification of source code to some higher-level description describes WHAT we want to verify rather than HOW we want to verify it.
   • DMP for extraction of information from source code describes WHAT we want to extract rather than HOW we want to extract it. (Therefore, pattern matching and unification approaches can be considered as DMP)
   • DMP for transformation of source code describes WHAT we want to transform into WHAT rather than HOW we have to transform something into something else. (Hence, an ordinary compiler or interpreter is obviously not DMP, unless it is written e.g. in a purely functional language like Gofer based on its denotational semantics. However, a medium in which you only have to specify the pattern of the input and the output, and where the derivation is done automatically, can be considered as DMP.)
   • DMP for generation of source code describes WHAT we want to generate rather than HOW we want to generate it. (For example, in the LMP approach to AOP we try to write the aspects down as general and declarative as possible, without needing to focus too much on HOW all these aspects need to be woven together into a base program. That is DMP.)

1. RESTRICTION: We only use dmP for building tools that
   1. support or facilitate the software development or maintenance process
   2. deal with source code
2. dMp = reasoning about and manipulation of source code in a meta language:
   • verification of source code to higher-level descriptions
   • extraction of information from source code
   • transformation of source code
   • generation of source code
3. Dmp = the meta language is declarative => focusses on WHAT the program does rather than on HOW it works:
   • WHAT needs to be verified (not HOW)
   • WHAT needs to be extracted (not HOW)
   • WHAT needs to be transformed into WHAT (not HOW)
   • WHAT needs to be generated (not HOW)

• In his Ph.D. dissertation on Type-Oriented Logic Meta Programming, Kris De Volder used logic meta programming as a way to extend the expressiveness of current type systems. The approach proved to be sufficiently general to handle aspect-oriented (meta)programming as well. De Volder essentially used a code generation approach where code was described at a declarative meta level including both high-level logic declarations and low-level pieces of Java source code. Based on these declarations his TyRuBa system then generated one or more Java programs satisfying these high level descriptions. Using the same TyRuBa system, a Master student conducted an experiment to generate the source code of an application by describing it at design level as a conguration of components. More information on the current status of this research can be found on http://www.cs.ubc.ca/~kdvolder/.
• The SOUL system, originally developed by Roel Wuyts, is a hybrid logic language implemented in and integrated with Smalltalk. It seems intuitively clear that design information and architectural concerns are best codified as logic constraints or rules. Using SOUL, experiments have been carried out to check, browse for, or enforce programming conventions, design patterns and styles, and to check conformance of source code to architectural constraints. More information on SOUL can be found this page.
• In his Ph.D. dissertation on Automating Architectural Conformance Checking by means of Logic MetaProgramming Kim Mens used a logic metaprogramming approach to describe multiple architectural views and their mapping to a software implementation. Each such views focuses on a different aspect of the structure of that system. Once defined, conformance of the source code to these architectural views can be checked automatically.
• In his Ph.D. dissertation on A Logic Meta-Programming Approach to Support Co-Evolution of Object-Oriented Design and Implementation, Roel Wuyts conducted some further experiments to synchronize higher-level design artefacts with source code artefacts.
• Despite the many advantages of adopting accepted design principles and techniques (such as idioms, programming conventions, design patterns and heuristics) when implementing software, often this results in some performance penalties. To allow for software systems with a clean design without compromising efficiency, Tom Tourwˇ proposed to do source to source transformation from well-designed implementations to more efficient ones. To achieve this, he used a combination of a logic and a functional meta language. The logic language is used to declare the role certain implementation artifacts play in specic design constructs. The functional language describes the optimization transformations for each specic design construct. These transformations can rely on the information contained in the logic declarations.
• Tom Tourwˇ and Tom Mens also performed some experiments to express evolution of design pattern instances at a high-level by expressing design patterns, their instances, and their typical evolutions in a declarative way. By reasoning about the software at such a high level of abstraction, evolution becomes more manageable and less error-prone. This research eventually led to Tom Tourwˇ's Ph.D. dissertation.

• Johan Brichau researches the use of Logic Meta-programming to support an aspect-specific language building-toolkit. He mainly focuses on the composition and interaction of aspects, possibly implemented in different aspect languages. More information on this can be found on the SOUL/Aop page
• Johan Fabry has created an add-on to SOUL: SOULJava, which allows SOUL to reason about base code written in Java. SOULJava is used to research advanced transaction manangement for middleware applications. We use information
  extraction from the Java code, and from declarative specifications by the application developer. More information on SOULJava is found on the DMP swiki at http://prog.vub.ac.be/swiki/DMP/13
• Tom Tourwˇ uses declarative meta programming to support framework-based development. He focuses on automatically generating source code for instances and evolutions of a framework, and reasons about this instantiation and evolution to detect possible conflicts. More information on his research can be found here.
• Kim Mens is currently investigating the abstraction of intentional source-code views to support co-evolution between software implementation and the design/architecture of a software system. It is a powerful yet intuitive, lightweight and non-intrusive means of modeling cross-cutting concerns. Intentional source code views increase our ability to understand, modularise and browse the implementation by grouping together source-code entities that address a similar concern. In addition, the formalism supports the declaration, verification and enforcement of relations among software views. As such, software evolution is facilitated by providing the ability to detect invalidation of important intentional relationships among concerns when the software is modified.
• Kris Gijbels is researching a tighter and more transparent language symbiosis and integration of a logic metalanguage and object-oriented base language.

Artifacts

The main artefacts and tools that have been produced in the context of this common research project are:

SOUL

SOUL is an acronym for Smalltalk Open Unification Language. It was originally developed by Roel Wuyts in VisualWorks/Smalltalk in the context of his PhD thesis (see above). It features a hybrid logic language which is integrated with the object-oriented language Smalltalk. SOUL is now used for most of the declarative meta-programming experiments at PROG/VUB and INGI/UCL.

• (2001) SOUL (second edition) is a re-implementation of the original SOUL by Johan Brichau, available for Visualworks 7. It used to be called QSOUL (as it provides support for Quasiquoted terms, a construct needed for generating Smalltalk code from logic declarations), but has since been re-baptised to SOUL.
• (1999) SOUL (first edition) was developed by Roel Wuyts in VisualWorks/Smalltalk in the context of his PhD thesis. It features a symbiosis between an object-oriented base language (Smalltalk) and a logic meta language.

LiCoR

(2001) SOUL comes with a set of primitive logic predicates that can be found in most Prolog-like logic languages. In addition to these logic primitives, specific logic predicates are needed for reasoning about (Smalltalk) source code. Together with the re-implementation of SOUL, this Library of predicates for Code Reasoning was factored out and baptised LiCoR. LiCoR is now provided as a separate package on top of SOUL. This allows one to use SOUL without LiCoR as just an ordinary logic language, or to use SOUL with an alternative library for code reasoning.

(2002) NewLiCoR, a through reimplementation and restructuring of LiCoR is currently underway, but a public release is probably not to be expected anytime soon.

SOULJava

(2002) SOULJava is an add-on to SOUL which allows SOUL to reason about Java code. It is implemented by Johan Fabry.

C2C (deprecated)

(2000) C2C is an acronym for "Classes To Clauses". It is a tool that generates logic clauses from Java bytecode, to allow declarative reasoning about Java code. The tool was implemented by Philippe Demaecker. Though promising, this research has been discontinued.

TyRuBa

(1999) TyRuBa is a logic-meta-programming system which was designed to be used for generating Java code. It was implemented as part of Kris De Volder's Ph.D. work as a system to experiment with the idea of type-oriented logic meta programming. TyRuBa's name derives from this origin, it is an acronym for 'Type Rule Base'. However, the system has no specific built-in features which make it focus on types. Rather it is a general, simple logic programming language with a few peculiarities to facilitate the manipulation of Java code for the purpose of code generation.

Soul/Aop - SoulWeaver - Babel (name should still be determined)

(2002) This is an almost finished experimental tool, implemented by Johan Brichau, to build and compose aspect-specific languages: SOUL/Aop page

JQuery

(2002) JQuery, developed by Kris De Volder and Gregor Kiczales, is a UBC research effort which provides developers with an effective means to navigate and explore source code using a flexible, query-based browser model. JQuery enhances a developer's ability to work with crosscutting concerns in code. An essential component of the JQuery tool is the TyRuBa logic query language, which has been integrated closely with the Eclipse API's.

Intentional View Browser

(2002) Kim Mens' Intentional View Browser is a browser that facilitates the browsing and editing source code that is classified using intentional source-code views. Because 'intentional views' can be seen as an advanced kind of 'software classifications', the intentional view browser is not offered as a stand-alone tool, but rather as a plug-in for Roel Wuyts' Star Browser. The integration of the Intentional View Browser in the Star Browser is joint work by Kim Mens and Roel Wuyts.
Here is a high-resolution screenshot of the Star Browser and Intentional View browser in action.

2002

• Kris De Volder, Kim Mens, Tom Mens and Roel Wuyts, Declarative Metaprogrammig Workshop, In conjunction with the ASE Conference, September 2002, Edinburgh. [dedicated webpage]

2002

• Johan Brichau and Kim Mens. One-week intensive course on Logic Meta-programming with hands-on exercises in SOUL for the international EMOOSE program (2002-2003), December 2002,Ecole des Mines de Nantes, France. [Download not available]
• Kim Mens, Tom Mens and Michel Wermelinger. Intentional Source-code Views. Paper presentation at the SEKE 2002 Software Engineering and Knowledge Engineering Conference, July 19, 2002, Ischia, Italy. [Download]
• Johan Brichau and Kim Mens.Logic Metaprogramming in SOUL, FNRS meeting on Applications of Logic in Computer Science, Wednesday 22 May, FUNDP, Namur, Belgium. [Download]
• Kim Mens, Tom Mens and Michel Wermelinger. Intentional Source-code Views. Presentation at the IWPSE 2002 International Workshop on Principles of Software Evolution, May 20, 2002, Orlando, Florida, USA. [Download]
• Tom Tourwˇ. Automated Support for Framework-Based Software Evolution. Invited presentation for a course "Sˇminaire de conception de logiciel" (theme: design patterns), May 2002, Universitˇ catholique de Louvain, Louvain-la-Neuve, Belgium. [Download]
• Johan Brichau and Kim Mens. A hands-on tutorial on SOUL, March 2002, Vrije Universiteit Brussel, Belgium. [dedicated webpage]
• Kim Mens. Declarative Metaprogramming. CERTI seminar, February 8, 2002, Universitˇ catholique de Louvain, Louvain-la-Neuve, Belgium. [Download]
• Johan Brichau and Kim Mens. One-week intensive course on Logic Meta-programming with hands-on exercises in SOUL for the international EMOOSE program (2001-2002), January 2002,Ecole des Mines de Nantes, France. [Download not available]
• Kim Mens. Intentional Software Classifications. Presentation at a meeting of the FWO Research Network on Formal Foundations of Software Evolution, January 18, 2002, Brussels, Belgium. [Download]
• Kim Mens. Research Overview. Internal presentation at the Dˇpartement d'ingˇnierie informatique (INGI) of the Universitˇ catholique de Louvain, January 10, 2002, Louvain-la-Neuve, Belgium. [Download]

2001

• Kim Mens. Architectural Aspects. Presentation for the 1st Belgian AOSD Workshop, Brussels, November 8, 2001. [Download]
• Isabel Michiels, Kim Mens and Roel Wuyts. Supporting Software Development through Declaratively Codified Programming Patterns. Paper presentation at the SEKE 2001 Software Engineering and Knowledge Engineering Conference, June 14, 2OO1, Buenos Aires, Argentina. [Download]
• Johan Brichau. Declarative Meta Programming. Lecture for the course on Principles of Object-Oriented Languages, May 2001, Department of Computer Science, Vrije Universiteit Brussel, Belgium. [Download]
• Kim Mens. Research Topics of the Programming Technology Lab. Invited lecture, May 30, 2001, Universidade de Lisboa, Lisbon, Portugal. [Download]

2000

• Kim Mens. Automating Architectural Conformance Checking by means of Logic Metaprogramming. Public defense of Ph.D. dissertation, October 23, 2000, Vrije Universiteit Brussel, Brussels, Belgium. [Download]
• Tom Mens, Roel Wuyts, Kim Mens, Tom Tourwˇ, Johan Brichau and Wolfgang De Meuter. Declarative Meta Programming, 6 October 2000, Programming Technology Lab, Brussel, Belgium. [Download part 1] [Download part 2]

1999

• Kim Mens. Declaratively Codifying Software Architectures Using Virtual Software Classifications, June 1999, TOOLS Europe '99, Nancy, France. [Download]

An extensive (but not necessarily complete) list of papers related to DMP can be found in the list below. You can also search the publications of the PROG lab or the publications of the INGI department.

Journals

2002

• Kim Mens, Isabel Michiels and Roel Wuyts. Supporting Software Development through Declaratively Codified Programming Patterns, Elsevier Journal on Expert Systems with Applications, Volume 23, November 2002, pages 405-431. [URL]

Proceedings

2002

• Johan Brichau, Kim Mens and Kris De Volder. Building Composable Aspect-specific Languages with Logic Metaprogramming, Proc. of Conference on Generative Programming and Component Engineering (GPCE), Pittsburgh, 2002. [Download]

• Kim Mens, Tom Mens and Michel Wermelinger. Maintaining Software through Intentional Source-code Views, In Proceedings of Conference on Software Engineering and Knowledge Engineering (SEKE 2002), Ischia, Italy, 2002. ACM. [Download]

• Kim Mens, Tom Mens and Michel Wermelinger. Supporting Software Evolution with Intentional Software Views, Proc. of the 5th International Workshop on Principles of Software Evolution (IWPSE), pages 138-142, Orlando, Florida, 2002. ACM. [Download]

2001

• Tom Mens, Tom Tourwe. A Declarative Evolution Framework for Object-Oriented Design Patterns, In Proceedings of International Conference on Software Maintenance (ICSM 2001), Barcelona, 2001. [Download not yet available]
• Kim Mens, Isabel Michiels, Roel Wuyts. Supporting Software Development Trough Declaratively Codified Programming Patterns, In Proceedings of International Conference on Software Engineering and Knowledge Engineering (SEKE 2001), pages 236-243, Buenos Aires, June 2001. Knowledge Systems Institute. [Download]
• Wolfgang De Meuter, Maja DÕHondt, Sofie Goderis, Theo DÕHondt. Reasoning with Design Knowledge for Interactively Supporting Framework Reuse, Proc. SCASE Õ01, 2001. [Download not yet available]

2000

• Theo D'Hondt, Kris De Volder, Kim Mens and Roel Wuyts. Co-Evolution of Object-Oriented Software Design and Implementation, In Proceedings of SACT 2000 (International symposium on Software Architectures and Component Technology), pages 207-224, January 2000. Kluwer Academic Publishers. [Download]

1999

• Kim Mens, Roel Wuyts. Declaratively Codifying Software Architectures using Virtual Software Classifications, In Proceedings of TOOLS 29 --- Technology of Object-Oriented Languages and Systems, pages 33-45, Nancy, France, June 7-10, 1999. IEEE Computer Society. [Download]
• Maja D«Hondt, Wolfgang De Meuter, Roel Wuyts. Using Reflective Logic Programming to Describe Domain Knowledge as an Aspect, Proc. 1st Int. Symp. Generative and Component-Based Software Engineering (GCSE'99). [Download]
• Tom Tourwe, Wolfgang De Meuter. Optimizing Object-Oriented Languages through Architectural Transformations, Proc. 8th Int. Conf. Compiler Construction, Amsterdam, The Netherlands, March 1999. [Download not yet available]
• Kris De Volder, Theo D'Hondt. Aspect-Oriented Logic Meta Programming, Proc. 2nd Int. Conf. Meta-Level Architectures and Reflection, LNCS 1616, pp. 250-272, Springer-Verlag, 1999. [Download]

1998

• Roel Wuyts. Declarative Reasoning about the Structure of Object-Oriented Systems, Proc. TOOLS USA '98, pp. 112-124, 1998. [Download]

Workshops

2002

• Johan Brichau, Kris Gybels, Roel Wuyts. Towards Linguistic Symbiosis of an Object-oriented and a Logic Programming Language. Workshop on Multi-paradigm Programming in OO at ECOOP 2002. [Download]

2001

• Johan Brichau, Ragnhild Van Der Straeten. Feature Interactions in Software Engineering using Logic. Workshop on Feature Interactions in Composed Systems at ECOOP 2001. [Download]
• Roel Wuyts and Stéphane Ducasse. Symbiotic Reflection between an Object - Oriented and a Logic Programming Language. In ECOOP 2001 International workshop on MultiParadigm Programming with Object - Oriented Languages, 2001. [Download from SCG - Bern]
• Roel Wuyts, Stéphane Ducasse and Gabriela Arévalo. Applying Experiences with Declarative Codifications of Software Architectures on COD. In Ecoop 6 th International Workshop on Component - Oriented Programming, 2001. [Download from SCG - Bern]
• Roel Wuyts and Stéphane Ducasse, Composition Languages for Black - Box Components, In First OOPSLA Workshop on Language Mechanisms for Programming Software Components, 2001. [Download from SCG - Bern]
• Roel Wuyts, Synchronising Changes to Design and Implementation using a Declarative Meta - Programming Language, In International Workshop on (Constraint) Logic Programming for Software Engineering, dec, 2001.[Download from SCG - Bern]

2000

• Johan Brichau. Declarative Composable Aspects, OOPSLA 2000 Workshop on Advanced Separation of Concerns. [Download]
• Johan Brichau. Declarative Meta Programming for a Language Extensibility Mechanism, ECOOP 2000 Workshop on Reflection and Meta Level Architectures, Cannes, France, 2000. [Download]
• Tom Mens, Kim Mens and Roel Wuyts, On the Use of Declarative Meta Programming for Managing Architectural Software Evolution, In Proceedings of the ECOOP'2000 Workshop on Object - Oriented Architectural Evolution, jun, 2000. [Download]
• Kris De Volder, Johan Fabry, Roel Wuyts. Logic Meta Components as a Generic Component Model, ECOOP 2000 Workshop on Component-Oriented Programming, Cannes, France, 2000. [Download]
• Tom Tourwˇ, Kris De Volder. Using software classifications to drive code generation, ECOOP 2000 Workshop on Objects and Classification: A natural convergence, Cannes, France, 2000. [Download]
• Kim Mens, Tom Mens. Codifying High-Level Software Abstractions as Virtual Classifications, ECOOP 2000 Workshop on Objects and Classification: A natural convergence, Cannes, France, 2000. [Download]
• Kim Mens. Multiple Cross-Cutting Architectural Views, Second Workshop on Multi-Dimensional Separation of Concerns in Software Engineering (ICSE 2000), Limerick, Ireland, February 2000. [Download]

Tech reports

• Roel Wuyts and Kim Mens. Codifying Structural Regularities of Object-Oriented Programs, Unpublished technical report. [Download]
• Kim Mens and Michel Wermelinger. On the use of knowledge representation techniques for modeling software architectures, Unpublished technical report. [Download]
• Tom Mens and Kim Mens. A Uniform Declarative Framework for Automated Software Merging, Unpublished technical report. [Download]
• Roel Wuyts, Kim Mens, Theo D'Hondt. Explicit Support for Software Development Styles throughout the Complete Life Cycle, Unpublished technical report. [Download]
• Kris De Volder. Type-Oriented Logic Meta Programming for Java, Unpublished technical report. [Download]

PhD Theses

• Tom Tourwˇ. Automated Support For Framework-Based Software Evolution, Phd Thesis, Programming Technology Lab, Vrije Universiteit Brussel, October 2002. [DOWNLOAD]
• Roel Wuyts. A Logic Meta-Programming Approach to Support the Co-Evolution of Object-Oriented Design and Implementation, Phd Thesis, Programming Technology Lab, Vrije Universiteit Brussel, January 2001. [DOWNLOAD]
• Kim Mens. Automating Architectural Conformance Checking by means of Logic Meta Programming, PhD Thesis, Programming Technology Lab, Vrije Universiteit Brussel, September 2000. [DOWNLOAD]
• Kris De Volder. Type-Oriented Logic Meta Programming, PhD thesis, Programming Technology Lab, Vrije Universiteit Brussel, September 1998. [DOWNLOAD]

Masters Theses

• Maria Jose Presso.
• David Zulu. A Declarative Framework for Reasoning about Object-Oriented Programming Languages, Masters Thesis, Dept. Computer Science, Vrije Universiteit Brussel, 2001. [Download not available]

Graduation Theses

• Johan Brichau. Syntactic Abstractions for Logic Meta Programming, Graduation Thesis, Dept. Computer Science, Vrije Universiteit Brussel, 1999.[Download not yet available]
• Isabel Michiels. Using Logic Meta Programming for Building Sophisticated Development Tools, Graduation Thesis, Dept. Computer Science, Vrije Universiteit Brussel, 1997. [Download not yet available]
• Johny Vanhentenryk. Graduation Thesis, Dept. Computer Science, Vrije Universiteit Brussel, 2000.[Download not available]

Here is a list of people that is currently actively involved with DMP:

• Pr. Kris De Volder. After obtaining his Ph.D. dissertation on type-oriented logic metaprogramming at the Vrije Universiteit Brussel (Brussels, Belgium), Kris moved to Canada to become an assistant professor at the University of British Columbia (Vancouver, Canada), where he continues his research on declarative metaprogramming: http://www.cs.ubc.ca/~kdvolder/.
• Pr. Kim Mens. After obtaining his Ph.D. dissertation on architectural conformance checking by means of logic metaprogramming at the Vrije Universiteit Brussel (Brussels, Belgium), Kim was assigned as a post-doctoral assistant at the same university for one year, before becoming a computer science professor at the universitˇ catholique de Louvain (Louvain-la-Neuve, Belgium), where he currently continues his research on declarative metaprogramming: http://www.info.ucl.ac.be/people/cvmens.html.
• Dr. Roel Wuyts. After obtaining his Ph.D. on logic metaprogramming for co-evolution of design and implementation at the Vrije Universiteit Brussel (Brussels, Belgium), Roel became a post-doctoral researcher at the university of Bern, where he continues his research on declarative metaprogramming: http://iamwww.unibe.ch/~wuyts/.
• Dr. Tom Mens is a post-doctoral fellow of the Fund for Scientific Research, Flanders at the Vrije Universiteit Brussel (Brussels, Belgium), and uses the technique of declarative metaprogramming for some of his research efforts.
• Dr. Tom Tourwˇ. After obtaining his Ph.D. on declarative metaprogamming for framework-based software evolution at the Vrije Universiteit Brussel (Brussels, Belgium), Tom became a post-doctoral assistant at the same university: http://prog.vub.ac.be/~ttourwe
• Johan Brichau is a Ph.D. student at the Vrije Universiteit Brussel (Brussels, Belgium), conducting research on the use of logic metaprogramming to support aspect-oriented programming: http://prog.vub.ac.be/~jbrichau
• Johan Fabry is a Ph.D. student at the Vrije Universiteit Brussel (Brussels, Belgium), and uses the technique of declarative metaprogramming in his research efforts.
• Kris Gybels is a Ph.D. student at the Vrije Universiteit Brussel (Brussels, Belgium) conducting research on declarative metaprogramming.
• Sofie Goderis is a Ph.D. student at the Vrije Universiteit Brussel (Brussels, Belgium), and intends to use the technique of declarative metaprogramming in her research efforts.
• Ellen Van Paesschen is a Ph.D. student at the Vrije Universiteit Brussel (Brussels, Belgium), and intends to use the technique of declarative metaprogramming in her research efforts.

• Michele Lanza's Codecrawler is a language independent reverse engineering tool which combines metrics and software visualization. CodeCrawler is based on Moose, an implementation of the FAMIX metamodel. CodeCrawler is written in VisualWorks Smalltalk and runs on every major platform.
• Moose is a tool environment to reverse engineer and reengineer object-oriented systems. It consists of a repository to store models of software systems, and provides query and navigation facilities. Models consist of entities representing software artifacts such as classes, methods, etc. Moose is based on the FAMIX metamodel.
• The FAMIX model provides a language-independent representation of object-oriented source code and is used by the FAMOOS tool prototypes as a basis for exchanging information about object-oriented software systems.
• FAMOOS is the name of ESPRIT Project 21975. FAMOOS is an acronym for Framework-based Approach for Mastering Object-Oriented Software Evolution. The goal of the FAMOOS Esprit project was to support the evolution of first generation object-oriented software, built with current analysis and design methods and programming languages, to frameworks -- standard application architectures and component libraries which support the construction of numerous system variants in specific domains. Methods and tools were be developed to analyse and detect design problems with respect to flexibility in object-oriented legacy systems and to transform these systems efficiently into frameworks based on flexible architectures.
• The goal of Roel Wuyts' Star Browser is to allow you to browse your Smalltalk environment and classify anything you encounter while doing so. Therefore it has full drag and drop support to allow you to classify software elements such as classes and methods while you are browsing. It is based on the underlying Lightweight Classification Model.
• Naftaly Minsky's Law-Governed Architectures allow the explicit and formal declaration of certain regularities for a given system. These declarations form the 'law' of the system and can be enforced by the environment in which the system is developed. A regularity is similar to an architectural constraint: it is a 'global property of a system; that is, a property that holds true for every part of the system, or for some significant and well-defined subset of its parts'. A well-known example of a regularity in software is a layered architecture.
• Gail Murphy's Software Reflexion Model technique enables a software developer to summarize interactions in a large body of source code in terms of a selected, high-level, structural view of the system. The technique has been shown to scale for use with large systems: a developer at Microsoft applied the technique to aid an experimental reengineering of the Excel code base.
• Gail Murphy's Conceptual Modules are logical modules that can be overlayed on an existing system. The logical module can include snippets of code from multiple parts of a system. Tool support is available to create conceptual modules, report the interface to a conceptual module, to report on the data and control interactions between conceptual modules, and to report on the data and control interactions between conceptual modules and the existing source. This approach has been used to help support reengineering tasks.
• Darius Blasband's Raincode is a product that allows you to perform powerful meta-operations on your programs. These operations include identifying pieces that do not comply to certain project-wide standards; gather metrics; identify pieces of code that would not be portable to a new platform you wish to use; scan your code for specific patterns; perform various patches on the analyzed source, including but not restricted to insertions of new statements, new variable declarations, commenting out or invalidating for compilation some piece that has been found to be non-conformant, non-portable or too complex.
• Even when developers have recurring computer-readable metadata to process and a clear idea of how code should be structured, they can still find themselves in need of a technique to automatically generate the code to avoid the drudge work of repeatedly writing and tweaking it. Krisztof Czarnecki's Generative programming is a technique that addresses this problem. Using generative programming techniques, you can solve software engineering problems in families, rather than individually, saving time and coding effort.
• Amnon Eden's LePUS language for Patterns' Uniform Specification. The language can be used for, among other things, validation of architectural specifications; reasoning and proving relations between specifications and design patterns; implementation of patterns by support tools; documenting concrete architectures of class libraries and of application frameworks.
• Michel Tilman's Dynamic Object-models. Michel's interests include reflective architectures for real-life frameworks, model-driven architectures, software evolution, multi-paradigm and aspect-oriented programming, distributed computing and 'smart' development tools.
• Gert Florijn is a staff member at SERC - the Software Engineering Research Centre. Among other things SERC does interesting internal research work on topics like software quality, analysing design models, reverse engineering, performance analysis and distributed systems. Also, they're working on (tools for) checking and improving (OO) software designs. Specifically, we're experimenting with a tool called RevJava (formerly known as Anaja) that does design critiqueing on compiled Java code (byte code). In a previous life, Gert also worked on a design tool for patterns and software architectures.
• Yann-Ga‘l Guˇhˇneuc is, among other things, working on Caffeine, a system for the dynamic analysis of Java programs. Caffeine is made of a Prolog engine that analyzes the execution of a Java program on a remote virtual machine.
• Yann-Ga‘l Guˇhˇneuc is, among other things, working on Caffeine, a system for the dynamic analysis of Java programs. Caffeine is made of a Prolog engine that analyzes the execution of a Java program on a remote virtual machine.
• Yann-Ga‘l Guˇhˇneuc is interested in meta-modelling, logic programming, and explanation-based constraint programming for pattern description and detection. He is currently in the process of writing his Ph.D. thesis, the goal of which is the formalisation of bad design patterns to detect them in random Java code, and then to improve the corresponding code. In this context, he is currently working at some enhancements of a meta-model to describe design patterns.
• Toacy Oliveira, Paulo Alencar, Donald Cowan (University of Waterloo, Canada) are working on a declarative approach to framework instantiation. (For more information, see our ASE 2002 workshop Declarative Meta Programming to Support Software Development.)
• Gopal Gupta (University of Texas, Dallas, USA) adopts a language-centric approach to software engineering where domain specific languages meet software components. (For more information, see our ASE 2002 workshop Declarative Meta Programming to Support Software Development.)
• Description logics are considered the most important knowledge representation formalism currently available. We are considering using it in some of our DMP research, for example as a means to describe architectural views on a software system.
• Stanley M. Sutton's COSMOS is a concern-space modeling schema, the goal of which is to provide a global concern-space model including concerns and their interrelationships, to enable concern spaces to be represented systematically and independently of particular artifacts, formalisms, tools, and methods, and to allow concerns to be represented consistently and comprehensively. Concern-space modeling should enable concerns to be treated uniformly across the life cycle and range of work products, should facilitate reasoning about concerns in general, and should provide a common foundation for concern-oriented tools and methods.

Page last modified on Wednesday, 15 January, 2003 16:24 by KM