| 1.45 pm - 2.15 pm |
|
Using Reflective Logic Programming to Describe Domain Knowledge as an Aspect Maja D'Hondt, Wolfgang De Meuter, Roel Wuyts System
and Software Engineering Laboratory Software applications, mostly consisting of an algorithm applied to domain knowledge, are hard to maintain and to reuse as a result of their hard coded combination. We propose to follow the principles of aspect-oriented programming, separating the domain from the algorithm and describing them in a logic and conventional programming language respectively. In this paper, we report on an experiment that was conducted to validate this hypothesis, and to investigate the requirements of a programming environment for this configuration. An already existing environment that uses a logic meta-language to reason about object-oriented systems, SOUL, is used as a starting point for this experiment. The result is a working implementation in SOUL, which validates our ideas, reveals mechanisms that require more re- search, and points to other features that should be included. Download |
| 2.15 pm - 2.45 pm |
|
Aspect Weaving by Graph Rewriting Uwe Assmann, Andreas Ludwig Institut
für Programmstrukturen und Datenorganisation AOP
(aspect-oriented programming) allows to specify parts and behaviors
of components using different views, i.e. with aspects. These aspects
can be specified independently from each other and are combined
to the final form by a weaver tool. This composition process yields
software that is better readable (since specifications are modular)
and better reusable (since aspects can be re-combined). Download |
| 2.45 pm - 3.15 pm |
|
Aspects in Distributed Environments Elke Pulvermüller, H. Klaeren, Andreas Speck WilhelmSchickardInstitut
für Informatik We
illustrate how to combine CORBA as a distributed system with aspect-oriented
programming (AOP) and the resulting positive impacts. In particular,
we focus on the question how AOP can be applied to a CORBA application
aiming at a better separation of concerns. |
| 3.45 pm - 6.15 pm |
|
Lightweight and Generative Components I: Source-level Components Sam Kamin, Miranda Callahan, Lars Clausen Computer
Science Department Current de of "software component" are based on abstract data types - collections of functions together with local data. This paper addresses two ways in which this de is inadequate: it fails to allow for lightweight components - those for which a function call is too inefficient or semantically inappropriate - and it fails to allow for generative components - those in which the component embodies a method of constructing code rather than actual code. We argue that both can be solved by proper use of existing language technologies. Suppose the type Code represents values of syntactic fragments of an imperative object language, and that the type is rich enough that values of compound fragments can be derived from the values of their sub-fragments (i.e. the semantic function is compositional). Then, embedding the Code type within a higher-order meta-language, and de a client as a function from a component to Code, we can de components at a very general level and without very heavy notational overhead. From this point of view, no specific definition for "component" is needed: it is any value in the meta-language that is useful in constructing values of type Code. In this paper, we illustrate this idea entirely at the source-code level, taking Code to be string. Operating at this level is particulary simple, and is useful when the source code is not proprietary. In a companion paper, we de Code as a set of values containing machine- language code (as well as some additional structure), allowing components to be delivered in binary form. Download |
| 4.15 pm - 4.45 pm |
|
Scoping Constructs for Program Generators Yannis Smaragdakis, Don Batory Department
of Computer Sciences The
University of Texas at Austin A well-known problem in program generation is scoping. When identifiers (i.e., symbolic names) are used to refer to variables, types, or functions, program generators must ensure that generated identifiers are bound to their intended declarations. This is the standard scoping issue in programming languages, only automatically generated programs can quickly become too complex and maintaining bindings manually is hard. In this paper we present generation scoping: a language mechanism to facilitate the handling of scoping concerns. Generation scoping offers control over identifier scoping beyond the scoping mechanism of the target programming language (i.e., the language in which the generator output is expressed). Genera-tion scoping was originally implemented as an extension of the code template operators in the Intentional Programming platform, under development by Microsoft Research. Subsequently, generation scoping has also been integrated in the JTS language extensibility tools. The capabilities of generation scoping were invaluable in the implementation of two actual software generators: DiSTiL (implemented using the Intentional Programming system), and P3 (implemented using JTS). Download |
| 4.45 pm - 5.15 pm |
|
Effcient ObjectOriented Software with Design Patterns Mario Friedrich (GMD FIRST), Holger Papajewski, Wolfgang SchröderPreikschat, Olaf Spinczyk, Ute Spinczyk (University of Magdeburg) GMD
FIRST University
of Magdeburg Reusable software based on design patterns typically utilizes "expensive" language features like object composition and polymorphism. This limits their applicability to areas where efficiency in the sense of code size and runtime is of minor interest. To overcome this problem our pa per presents a generative approach to "streamline" patternbased object oriented software. Depending on the actual requirements of the environment the source code is optimized with a transformation tool. The presented technique provides "scalable" software structures and thus reconciles reusability with efficiency of patternbased software. Download |