| 11.00 am - 11.30 am |
|
Vanilla: an open language framework Simon Dobson, Paddy Nixon, Vincent Wade, Sotirios Terzis, John Fuller Department
of Computer Science A
trend in current research is towards component-based systems, where
applications are built by combining re-usable fragments or components.
In this paper we argue the case for building programming languages
from components. We describe Vanilla, a component-based architecture
for language tools. The core of Vanilla is a set of components,
each implementing the type checking and behaviour of a single language
feature, which are integrated within a well-structured framework
to provide a programming language interpreter. Features may be extensively
re-used across a variety of languages, allowing rapid prototyping
and simplifying the exploration of new constructs. We describe the
design and implementation of the system, and draw some general conclusions
from the experience of building with components. |
| 12.00 am - 12.30 pm |
|
AspectOriented Compilers Oege de Moor, Eric Van Wyk (Oxford University), Simon Peyton (Jones Microsoft Research Cambridge) Oxford
University Jones
Microsoft Research Cambridge Aspectoriented
programming provides the programmer with means to crosscut conventional
program structures, in par ticular the class hierarchies of objectoriented
programming. This paper studies the use of aspect orientation in
structur ing syntax directed compilers. Download |
| 2.00 pm - 2.30 pm |
|
Inner Classes For ComponentBased Programming Linda Seiter (Santa Clara University), Mira Mezini (University of Siegen), Karl Lieberherr (Northeastern University) Computer
Engineering Department, College of Engineering College
of Engineering and Computer Science College
of Computer Science Frameworks
elevate encapsulation and reuse to the level of largegrained components,
namely groups of collaborating classes. The abstract model defined
in a framework is easily customized into an applicationspecific
model through static subclassing and method overriding. However,
this implies nonindependent development of the application and
framework models and excludes the possibility of dynamically deploying
the framework within an application in multiple, potentially conflicting
ways. |
| 2.30 pm - 3.00 pm |
|
Recursive types and patternmatching in Java Remi Forax, Gilles Roussel Universite
de Marne la Vallee Recursive types definitions and patternmatching are two useful builtin features of functional languages. There is no such mechanism in the Java language. In this article, we investigate different implementations to support these features in Java. First, we review methods to define recursive types. Then, we expose several approaches allowing to simulate pattern matching on structures of these types. Finally, we present reuse techniques for algorithms featuring this mechanism. |
| 3.00 pm- 3.30 pm |
|
C++ Function Object Binders Made Easy Jaakko Järvi Turku
Centre for Computer Science A novel
argument binding mechanism is proposed to be used with STL algorithm
invocations. Binding can be applied directly, without any adaptors,
with non-member function pointers, const and non-const member function
pointers and STL unary and binary function objects. The types, as
well as the number of arguments in the functions to be bound can
be practically arbitrary, argument list lengths up to few dozens
of elements can be supported. |
| 4.00 pm - 4.30 pm |
|
Customizable Domain Analysis Joachim Bayer, Dirk Muthig, Tanya Widen Fraunhofer
Institute for Experimental Software Engineering (IESE) Generative
and component-based software engineering are approaches to reuse.
Within both approaches the scope of reuse can vary between general
purpose and application specific. We argue for scoping the reusable
assets based on a product line. Domain analysis methods provide
processes for deter-mining the common and varying requirements for
a product line. |
| 4.30 pm - 5.00 pm |
|
A GreyBox Approach to Component Composition Hans de Bruin Vrije
Universiteit Despite the obvious advantages of reuse implied by component technology, component based development has not taken off yet. Problems that inhibit general reuse include incomplete component contracts and (undocumented) dependencies of a component on the environment, which makes it hard to assess whether a component will behave in a particular setting as expected. In principle, a blackbox approach to component deployment should be favored. In practice, however, we require information that cannot be described solely in terms of externally visible properties of components. For instance, nonfunctional properties (e.g., space and time requirements), environmental dependencies, and variation points (e.g., places where a component may be adapted or extended) do require insight in the internal construction of a component. In this paper, a greybox approach to component deployment is discussed. It is based on a scenariobased technique called UseCaseMaps (UCM), which uses scenarios to describe how several components operate at a high abstraction level. UCM is an informal notation. Its strong point is to show how things work generally. In order to reason about component compositions, we have augmented UCMs with formal specifications of component interfaces. These interface specifications have been borrowed from the concurrent, objectoriented language BCOOPL (Basic Concurrent ObjectOriented Programming Language). A BCOOPL interface is more than just a set of operations, it also describes temporal orderings of operations and the parties that are allowed to invoke a particular operation. The combination of UCMs and BCOOPL interfaces gives us the opportunity to document intra and inter component behavior at a high, but formal abstraction level. Download |