Research Page

Prof. Dr. Uwe Aßmann

Prof. Dr. Uwe Assmann http://www.inf.tu-dresden.de/~ua1
PELAB http://www.ida.liu.se/~pelab
RISE http://www.ida.liu.se/~rise
Linköpings Universitet

Version Rev: Last Edited Date: 2004/01/27 10:13:40

This page describes ongoing and Open Research Projects, Collaborations of Dr. Uwe Assmann http://www.inf.tu-dresden.de/~ua1. These projects go on in the context of the Research Center for Integrational Software Engineering (RISE) http://www.ida.liu.se/~rise.
Software composition and software integration include the following research areas in software engineering:
  1. aspect-oriented development

  2. architecture languages

  3. view-based development

  4. generative programming

  5. intensional programming

Hence, the topics on this page are relevant for all of these areas.

1  Web Engineering: Integration Techniques for Active Documents and Uniform XML Composition

Uniform composition develops composition techniques for all kinds of documents, also software components.

1.1  Uniform Composition in the EASYCOMP Project

The EU FET project on uniform composition. ((short description) Projects/Descriptions/easycomp-short.htmlshort description) www.easycomp.org http://www.easycomp.org
Open Masters Thesis
Active Document Case Study (short description) http://www.inf.tu-dresden.de/~ua1/Projects/Descriptions/case-study-active-documents.html
Consulted PhD
Protocol checking of box components (using logics)
Open PhD
Very complex protocols (common intermediate languages)
Open PhD
Constructing Multimedia Learning courses with XML-based active documents
Open Masters Thesis
Constructing a C++ crash course for the Web

1.2  The UniComp Composition Framework and Ontology

Composition Ontology.
EASYCOMP is constructing a composition ontology for uniform composition. This will unify several software composition techniques, from event-based AOP to static invasive software composition.

1.3  Semantic Descriptions for Compositions in the XWizard Project

XWizard develops semantic descriptions of XML (a CENIIT project of Linköping University) (short description) Projects/Descriptions/xwizard.html
Open Master's Thesis
(short description) MasterTheses/compost-xml-java.htmlAttaching COMPOST to a Java XML schema
Open PhD
DAML++ - a new mechanism to describe XML semantics (short description) Projects/Descriptions/xml++.html(short description)
Semantic integration
of slicing and overlay languages [Open PhD]
The
TIF family of languages of translate-ifs in DAML+OIL
Schema Translations
and Intersections. DAML and other semantic specifications (including language models such as database schemata) need to be intersected, unioned, and mapped to each other. Building on the work in databases, we develop tooling for COMPOST to intersect and map different languag models together.'
Semantic Checking Tools
(DAML, RML, RAG, Optimix) for COMPOST and Java
Open PhD
Building a fast DAML checker with dynamic transitive closure
Open Masters
Comparing semantic description mechanisms with respect to composition (DAML, RML, RAG, Optimix, AG/Eli, AG/Cocktail, AG/Laemmel)

1.4  The Graph Rewriting Tool and Generator OPTIMIX

OPTIMIX (short description) Projects/Descriptions/optimix-short.html (main page) optimix.html is a generator for graph rewrite systems, and transformations of all kinds of documents and programs. The goal of this package is to develop it to a full fledged XML based tool. Version 2.5 comes now with Java support! Optimix has now moved to sourceforge (optimix.sourceforge.net), thanks to Stefan Kain!
Open Masters
Speeding up graph rewrite systems with dynamic transitive closure. Exploiting the Reps/Ramalingan theorem for graph rewriting
OpenMasters
Porting Optimix to Java and C#
OpenMasters
Generate parsers from graph rewrite specifications. The thesis should design and implement
OpenProject
The OPTIMIX library. At the moment, Optimix is a standalone tool. This project moves it to a library.
OpenProject
A simpler backend with XSLT.
Open_Masters
Attaching Optimix to XML. Integration of an XML generic parser into Optimix. Defining a XML schema for the Optimix language (Rules, rule sets, rewrite systems). Reading that from file. Investigate GXL (Graph Exchange Language).
RuleML
Investigate a connection to RuleML
OptimixDDL
Optimix has a DDL which should be ported to DAML and UML.
OpenMasters
Optimization Framework. Define an abstract control flow graph, SSA and other things. Define dominator information and other things. This thesis should deliver a general framework for optimization.
Open Masters
From UML-based design to implementations with graph rewrite systems
Open Masters
Semantic Diffs: Applying program analysis and graph rewriting to virus checking
Open Masters
Realizing lattices in Optimix
Open Masters
Realizing abstract interpretation in Optimix

1.5  Specific Component Models

This task develops specific component models in a component model hierarchy. Alternatively, it can be said that it develops an ontology for component models.

2  Software Integration Techniques: Software Composition and Architecture

2.1  Invasive Software Composition with the COMPOST System

The invasive software composition system for Java. (short description) Projects/Descriptions/compost-short.html (COMPOST main page) http://i44w3.info.uni-karlsruhe.de/~compost COMPOST is a meta-program library for composition of Java programs.
PhD, Robert Kaminski
Developing a common data model for COMPOST. Developing the XML recoder system.
Masters
A set of ontologies for email-based workflows, in connection with the XML recoder of Robert Kaminski.
PhD Adrian Pop
Developing a fast evaluator for DAML+OIL, coupled to XML-Compost, and compiling to RML.
Open_Masters
Representation of the C preprocessor macros as meta-programs
Open Masters
A DAML ontology for Java
Open Masters
A DAML ontology for C. This Masters develops a visual description formalism for DAML, based on UML, and specifies C semantics with it.
Open Masters
An Xschema for the common model of COMPOST
Open Student Project
Attaching an XML pretty printer to COMPOST
Open Masters
A DAML-based environment for semantic checking of XML documents

2.2  The COMPOST Component Model, the Boxology

The Boxology is a gray box component model for all sorts of program and specification fragments.
Conformance
checking of boxes and aspect boxes
Extensibility
Safe extension of boxes
Open Masters
Implementation of boxology for C++, with C++ templates
Open Masters
Analyzing composition programs in FIRM, an extended value dependency graph
Open Masters
Developing an XSchema for COMPOST composition programs

2.3  Software Architecture Tools

The goal of this workpackage is to bring software architecture concepts into practice.
Skeletons On Components
Skeletons are so far coodination functions in functional languages, but they can be generalized to coordinators. And coordinators can be regarded as invasive composition operators. This masters thesis designs and implements a set of skeleton composers.
XSTL Generator
A generator for XSLT and XQuery scripts.
Open Masters: BeanConnectors
The master thesis should design and develop a set of connectors for Java Beans, working invasively on Bean source code and byte code.

2.4  Program Analysis and Software Composition

Slicing and other program analysis techniques help to check compositions. This area develops some techniques.
Slicing for sound compositions
this master thesis builds a program dependency analyser with OPTIMIX

2.5  Other Invasive Composition Systems

GCC Hook Matcher
Matches hooks in gcc.
HookReplacer
Develop a hook replacer for masked hooks in html documents and simple files, based on GREP/Replace/Pike/tm.
XSLTHookReplacer
Develop a hook replacer for masked hooks in html and XML documents

2.6  Efficient Transclusion Systems

This project builds efficient transclusion systems in the tradition of OLE, Kparts, and Bonobo.

3  Dynamic Composition

3.1  Software Integration with Dynamic Composition and Architecture

JDRUMS-2.0
[PhD, Jens Gustavsson] JDRUMS Meets COMPOST: Composition Programs which are scalable between system generation and system run-time
Run-time boxology
 
Open Masters
Optimization of Agent-based systems

3.2  C-Drums Dynamic Composition System for C

PhD, Morgan Eriksson, Vaxjo
C-Drums and Optimization of Address Spaces.
The
TIF/C language. Repairing C to TIF/C.

3.3  Componentification

In legacy software or legacy active documents, components must be identified, isolated, and semantically described. This work package investigates methods to semi-automize this.
In our view, componentification is the materialization of hooks from implicit knowledge by program analysis. Hooks are indirection objects which form composition points.
Semantic Componentification [Open Masters]
How can we extract semantic knowledge for components? Starting from some tools, such as the GOOSE Laboratory or the Ontoknowledge environment a semantic componentifier has to be developed.
Semantic Component Descriptions for Variants [Open Masters]
For configuraiton management, versioning and varianting on ontologies must be tried. As a tool, cvs should be applied.

4  Meta-Composition

4.1  Aspect-Oriented Integration

PhD, T. Panas
Aspect-oriented Editors
Consulted PhD, C. Alexander
Aspect-oriented Design with Graph Rewrite Systems.
Open Masters
A Peer2Peer approach to master the Linkoeping Heart Model
Open Masters
Aspect weaving with graph rewriting
Open Phd
Dynamic aspect weaving. MVC programming with event based AOP
Open PhD
Beaver Construction
Super-IP
Construction for High-Level Language Constructs (Super-Intensional Programming). Lowering, Highering as inverse processes.
Specific Aspects
How to treat special aspects, such as Checking Aspect or Security Aspect
Open PhD
Aspect Composition Languages
Composition
with Inject/J http://injectj.fzi.de
Aspect-oriented
Design of UML
Integrational
Documentation

4.2  Intentional Programming

Intentional Programming used to be an initiative of Microsoft labs for domain specific languages. In an advanced editing environment users could interactivly develop new language constructs, and specific reductions to standard languages. Our goal is to improve it substantially, by reducing it to more systematic principles.

4.3  Composition Languages (Architecture Languages)

Uniform composition develops composition techniques for all kinds of documents, also software components.
COMPOST-ArchitectureML
 
3-d
Visual Construction of Software Architecture

4.4  Software Integration with Feature Unification

This work package investigates feature unification as software integration method.
Software Cocktails:
an algebraic model for composition
Open PhD
Feature-logic based composition
Open Masters
How to generate composition programs with feature logic and the Flora tool
Planning Compositions
How to plan compositions from a set of constraints? Use feature logic.

4.5  Software Integration with Concept Lattices

Concept lattices are a powerful means to extract communalities and variabilities. They also can integrate things that are distributed.
Concept lattice based design (CLD)
A design method for communality and variability analysis.

4.6  Symbolic Delaying Systems

A symbolic delaying system is an interpreter framework which is very efficient in space and time since it delays computations as long as possible. It unifies model checking, program analysis, abstract interpretation.

4.7  Multi Stage Programming for Tool Technology

Multi Stage Languages allow for static meta-programming, i.e., the production of programs from other programs. Since the programs are produced before they are run the languages are called multi stage or multi level. Multi stage languages will substitute compiler generators, software tools, and domain specific languages.
Open Masters
From UML-based design to implementations with graph rewrite systems
Open Masters
A generator toolbox based on meta-objects and boxology
Open Masters
Comparing Multi Stage Languages
Open Masters
Extending Pike for Semantic Macros.
Open Masters
Implement a simple pattern match language for XML.

4.8  Systematic Transformation Systems (STS)

Systematic Transformation Systems realize the next generation compiler and transformation systems. Since the major problem of kind of composition technology is how to develop transformations and compilations quickly, STS are the most important tool.
Case Study: PELAB Compiler Framework
This framework is about how to transform intermediate representations to each other. All transformations should be ontology based, and work with MVCP. The central IR is called Firm (Flexible intermediate representation mesh), an extended form of SSA for pointers.
OpenMasters
lcc2Firm Builder. How to generate Firm graphs from the lcc compiler?
Masters[Open]
GCC2Firm Builder. Connect gcc 3.0 to Firm.
Masters-Open
Graph rewriting based optimizations on Firm. Think how to optimize Firm graphs with OPTIMIX. Based on the Advanced Compiler Construction, realize the rewrite rules for Induction Variables, Partial redundancies, etc.
Open Masters: Parser Generation
Generation of fast parsers by regular grammars.
Open Masters
A generator toolbox based on meta-objects and boxology
GraphLab
The graph lab builds tools to manipuate graphs of all kinds.
sol library
C library for sets, lists, and graphs of different kinds
Open Masters: GrammarLab
A laboratory for grammar specifications. XML based. Developing an Xschema for grammars
Open Masters
Semantic Diffs: Applying program analysis and graph rewriting to virus checking

5  Semantic Web - Semantics for Integrational Software Engineering

5.1  Advanced Modelling

Facet-based Ontologies
 
Concept Analysis
and Ontologies

5.2  Ontology Engineering

Ontology Composition
How to transfer the Box component model to ontologies?
Ontology differencing
How to differenciate ontologies?

5.3  Applications

Semantic
Email
Semantic
Workflows
Web
Services with DAML-S

5.4  Pike - The Semantic Web Scripting Language pike.ida.liu.se

In 2002, Pike is going to be hosted by RISE. Pike will be developed to be the first script languages to support first class support for the Semantic Web and composition of active documents.
Semantic Web Support
Pike will read and write DAML+OIL ontoloties as Pike classes and constraints.§
Language Connectors
Build a framework of connectors between modules written in different languages. Language connectors influence linkers and loaders to connect access to data in different heaps.
Semantic Macros
A semantic macro is a macro that is type safe because it has access to the semantics of the program, accessing the type table of the compiler.
Multi Stage Language
How can we make Pike to a multi stage language?

6  Former Projects

6.1  Compost, C-Recoder and SawMill Linux

(short description) Projects/Descriptions/compost-sawmill.html in collaboration with IBM Watson, New York, and University of Karlsruhe, Germany
Consulted PhD, Dirk Heuzeroth
Coordinators as invasive composers. Also developing a C model, to work with SawMill Linux project.

6.2  The Java Recoder

Student Project, Rufus Burschart
C pretty printer MasterTheses/compost-c-prettyprinter.htmlAttaching a C pretty printer to COMPOST. This student project normalizes some of the Java language constructs to C, and builds a pretty-printer to C source code. The normalizations map certain parts of the Java abstract syntax tree to other parts, such that C compatibility is achieved.
Masters Thesis, Johan Jaxner
Fast Incremental Processing in an Interactive Environment. For COMPOST, a fast information re-analysis technique is necessary. This Masters develops one on top of the COMPOST data structures, with semi-naive evaluation, wavefronts, and dynamic transitive closure.


File translated from TEX by TTH, version 3.40.
On 13 Aug 2004, 12:08.