Verzeichnis aller Vorträge:

The theory and application of agents and multiagent systems is now experiencing a new surge in interest. As a result, a cacophony of modeling notations is beginning to emerge. Based on experience with previous software modeling disciplines, such as databases and object-orientation (which developed nearly a seventy-five different notations), it would be wise to standardize now -- before a tower of modeling-language Babel is built.
This presentation discusses the issues involved in using the OMG_s UML 2.0 as a possible starting point. However, we do not want to be restricted by UML; we only want to capitalize on it where we can. The general philosophy, then, is: When it makes sense to reuse portions of UML, then do it; when it doesn't make sense to use UML, use something else or create something new. This presentation discussed the work already underway and the work that still needs to be addressed.

The FX-Agents project consisted of members of the Stanford Logic Group and industrial visitors from NEC and Intec Web & Genome working together to develop new technologies based upon the combination of Web services and techniques from artificial intelligence, using our experience in AI-based software agents. This two-year project ran from April 2001 until March 2002 and explored the then emerging functionality of Web services. This paper is a result of our findings. In particular, this paper discusses the shortcomings of current Web service standards like WSDL and how logical AI techniques like declarative constraints, agents, and planning can be used to address some of these shortcomings. The primary problems that we address are automated Web service discovery and composition of Web services.

Ontology is the centerpiece of the most prevalent approaches for realizing the Semantic Web. Ontology-driven techniques and systems have already enabled new generation of Semantic Applications in such markets as bioinformatics, financial services, business intelligence, and national security. The applications of semantic technologies, in increasing sophistication, range from
· semantic search and browsing,
· semantic integration of heterogeneous enterprise-wide and pan-web
content, and
· analytics and discovery, leading to actionable information and
insights.

We take the example of LSDIS Lab’s SCORE technology that was licensed, extended and commercialized as Semagix’s Freedom product, and the requirements observed from its initial applications. Correspondingly, we outline core functional capabilities to create and maintain large domain and task ontologies (with description base of mulit-million objects), automatic classification, automatic semantic metadata extraction and enhancement, and high performance semantic query processing. From a research perspective, we outline the shift from documents and entities to simple and complex relationships and current investigations in semantic association discovery from heterogeneous data.

Background information for this talk can be found at:

http://www.semagix.com/download.html
http://lsdis.cs.uga.edu/proj/SAI/
http://lsdis.cs.uga.edu/lib/download/SAK02-TM.pdf

Adaptive coordination is a key requirement in many large-scale distributed systems operating in complex dynamic environments (e.g. Internet, grids, virtual enterprises). In such environments the systems and their individual components need to adapt to continuous changes in the presence of incomplete and uncertain information in a coherent and coordinated manner. Agent technology has been recognised as an important enabler for adaptive coordination based on the collective actions of the agents without centralised control of the system. The agents can collectively sense, make decisions and respond to changes in the environment in order to meet their individual and system objectives. It includes both cooperation where the agents act together in order to achieve a common goal (e.g. offering different capabilities) and competition when the agents have different goals or competing needs (e.g. competing for the same resources, offering the same services). Adaptive coordination with agents can be achieved through direct communication and interactions between the agents (e.g. negotiation) and indirect communication through agent interactions with the environment (e.g. responsive learning). This talk will discuss the opportunities and problems associated with adaptive coordination in complex distributed systems with agents. In particular it will focus on selected coordination mechanisms in different settings and illustrate them with some examples.

Der Vortrag beschäftigt sich mit den technologischen Angeboten von Microsoft für Service orientierte Architekturen.

We review a simple sequence of steps to stage a programming-language
interpreter into a compiler and virtual machine. We illustrate the
applicability of this derivation with a number of existing virtual
machines, mostly for functional languages. We then outline its relevance
for today's language development~\cite{Consel-Marlet:PLILP98}.

The work is joint with Mads Sig Ager, Dariusz Biernacki, and Jan
Midtgaard~\cite{Ager-al:RS-03-14,Ager-al:RS-03-13,Ager-al:RS-03-24,%
Biernacki-Danvy:RS-03-25}.

We envision a world in which we can develop, synthesize, adapt, integrate, and
evolve software based on high-quality, perpetually flexible pieces. New
pieces may be produced by generation, adaptation of existing pieces, or integration of pieces, and this process of "pieceware" engineering
continues--statically or dynamically--until a piece with the desired
capabilities and properties is synthesized. The pieces themselves may
comprise fragments of requirements, models, architectures, patterns, designs,
code, tests, and/or any other relevant software artifacts. Many technologies
are critical to achieving pieceware engineering; some have been developed in
this community and elsewhere, and others are still required.

Despite the progress in this field, we have encountered two major problems
along the way towards realizing the pieceware vision. First, what paradigms,
technologies, and methodologies are required to enable full-lifecycle
pieceware engineering? Second, how do we provide the necessary tool support?

Our inability to address the second problem has seriously compromised our
ability to address the first. The development of tools to realize different
pieceware engineering approaches represents a huge investment of time and
effort. This is largely because each one must be built from scratch or from
low-level abstractions. Consequently, the tools themselves represent isolated
point solutions, and rarely have any ability to interoperate or be integrated.
This has impeded the development and validation of full-lifecycle pieceware
engineering paradigms, technologies, and methodologies.

The Concern Manipulation Environment (CME) represents the first effort to
define an open, extensible set of components and abstractions to promote the
rapid development and integration of tools that support pieceware engineering.
The initial focus is on tools for aspect-oriented software development (AOSD),
an emerging technology area that is key to pieceware engineering. This talk
describes the pieceware engineering vision, the major issues to be addressed,
and the technologies required to achieve it. It then discusses how the CME
helps to address many of these issues--illustrated by the use of the CME to
enable the evolution of a real-world system--and how it can be leveraged by
researchers and developers to produce, experiment with, validate, and
integrate new pieceware techologies and paradigms. Finally, we identify some
of the key challenges remaining to achieve the vision of pieceware
engineering.

UML's not just for sketching any more, and in these days of highly distribruted network objects, sketching wouldn't be good enough anyway.  What we need is a way to state exactly what needs to be done in a concurrent language--a language that assumes the system will be distributed.  In addition, the language must be complete, not just a framework or a blueprint to be filled in by programmers, so that a "specification" is, in fact, an executable.
 
This  presentation outlines the need for a complete concurrent specification using UML, shows what the specification language needs, and how it must work.  Such a language does exist, and we;'ll showhow it fits into a broader framework of software development today and tomorrow.

The World Wide Web of today has already a high impact on e-business.
However, due to its syntactic nature the support for business is still
rather limited. The Semantic Web as the next generation of the World Wide
Web addresses this problem by adding semantic information to the content we
find on the Web. Thus Web content becomes machine interpretable. In this
talk the concepts and methods will be discussed that build the kernel of
the Semantic Web. Special focus will be put on ontologies and related
metada. The talk will further address the role of ontologies for peer-to-peer and agent systems. Finally, I will discuss various application scenarios.

Paneldiskussion zu den Net.ObjectDays 2003 am 24. September in Erfurt mit
Vertretern von SUN, Tiscali, DaimlerChrysler und CIOForum

Authors: Das sind die fest zugesagten Teilnehmer am Panel:

· Prof. Dieter Rombach, Direktor des Fraunhofer Institutes IESE (Institut
für experimentelle Software Engineering) rombach@iese.fhg.de

· Dr. Klaus Täubig Leiter des Referats Forschung von Thüringer Ministerium
für Forschung (e-mail über Bogdan Franczyk)

· Wilfried Reimann, Senior Manager - Software Development Environments ITM,
Telecommunication & Strategic Planning, Wilfried.Reimann@DaimlerChrysler.com

· Martin Häring, Director Marketing und Produktmarketing, Sun Microsystems
Deutschland, Martin.Haering@Sun.COM

· Carl Mühlner, Vorstand TISCALI Deutschland, Carl.Muehlner@de.tiscali.com

. Günter H. Köster, CIOForum, guenter.koester@web.de

The value of a software engineering experience repository like for any other experience-based information systems tends to degrade with time.
To keep the value of such a system, evaluation and maintenance is an essential.
While evaluation monitors the "value" over time, maintenance has to preserve or improve this "value". Evaluation and maintenance should not simply happen ad hoc but systematically and based on specific quality and maintenance knowledge, which is linked to base maintenance on evaluation.
As a jump-start for evaluation and maintenance, the respective knowledge
should be available right from the start of continuous operation. This paper
describes how to acquire and develop such maintenance knowledge during
system buildup to use and improve this knowledge during continuous operation
for combined human- and computer-based maintenance. The described approach has been successfully applied in several projects. The method is illustrated with examples from two of these projects as case studies.

In this paper, we build on previous work that combines ideas from visual component-based software development and aspect-oriented software development. In our visual component-based methodology PacoSuite, developed in earlier work, we introduced composition adapters to modularize crosscutting concerns. A composition adapter is visually applied onto a composition pattern and the changes it describes are automatically inserted in that pattern using finite automata theory. The expressive power of a composition adapter is however limited to concerns that alter the exterior behavior of a component as only the glue code of a component based application is altered. To overcome this limitation, we propose in this paper invasive composition adapters, able to express concerns that require more than mere filtering and re-routing. The changes dictated by an invasive composition adapter are automatically inserted into components and composition patterns.
To realize these invasive composition adapters we use JAsCo, an aspect-oriented
implementation language that is tailored for the component-based context. The approach is validated using a small case-study that successfully modularizes three crosscutting concerns as composition adapters in an e-commerce
application.

Component markets, which facilitate the exchange of components between sellers and buyers, are a key prerequisite for the emergence of componentbased software engineering. Subsequently, numerous market forecasts have prophesied component marketplaces to quickly evolve and gain in profitability. However, a longterm observation indicated a rather leisure development until today and proved that only very few marketplaces managed to successfully establish themselves. To investigate possible reasons, this paper analyzes the maturity of today_s component markets. Based on the analysis results, it devises critical success factors to counter identified immaturities and provides solutions to transform them into marketplace features. Thereafter, it describes the architectural design of CompoNex, a model marketplace that builds upon the devised critical success factors to facilitate component trading in immature markets.

The proliferation of devices with the ability to deliver information
anywhere at any time has increased the users_ flexibility and the quality of ser-vices.
It has also caused the need for development and deployment of new in-frastructures
supporting multiple platforms. As a result, new techniques for de-livering
content according to device features and even specific languages such
as User Interface Markup Language (UIML) emerged. This paper discusses an
innovative approach for device-dependent content delivery based on JSP tag li-braries.
A special tag library that generates appropriate markup elements de-pending
on the markup language supported by a specific device was developed
and is described in detail. A comprehensive example illustrates the proposed
technique.

The paper contributes to research on component and multi-agent
systems by presenting a practical approach to the development of
modular and reusable middleware. We address the problem of the con-struction
of the core of a middleware for MAS. Then we introduce two
case studies for two different application domains: biological data inte-gration
and quality assurance in manufacturing. Our experience proves
that the component-based approach provides several benefits, such as the
facilitation of refactoring and increase reuse, but also introduces some
pitfalls, such as excessive reuse. We acknowledge that reuse exploits its
potential in the lower layers of a system, because components are quasi-free
of business level concepts.

The concept of dynamic class methods in Java, constituting a special-ization
of a general new programming language concept called dynamic rou-tines, is introduced and described in detail. Simply speaking, dynamic class methods are class methods (i. e., “static” methods in Java terminology) which can be overridden or redefined in other classes (and therefore are actually not “static”). By that means, they constitute a generalization of both class and in-stance methods, and even “virtual constructors” can be implemented with them.
In addition to conceptual particulars, an implementation of dynamic methods as
a precompiler-based language extension to Java is described in detail.

Dynamic Web service applications, e.g. querying product information from different suppliers for the purpose of a price comparison, can only run automatically if, beside the technical interface, the semantics of the data are
standardized. Several XML vocabularies, which, among other things, address
the exchange of product data, have been developed independent of Web services
(e.g. BMEcat, cXML, and xCBL, just to name a few). However, to our knowledge, these standards have hardly been mentioned in conjunction with Web services for querying product information. This article examines how BMEcat, as an example for such a standardized _business language_, can be used within a Web service interface. By using specific program code examples a _procedure-oriented_ and a _document-oriented_ approach are compared.

This papers describes the concept of higher order server pages, which allows for passing server pages as actual parameters to a targeted typed server page.It is explained how the higher order server pages concept can e exploited to foster system maintain-ability and system part reusability. An operational semantics of the resulting typed server pages technology is given as a transformation of the language features to proven object-oriented technology.

The design of distributed applications based on a fragmented object model has many benefits. Unlike traditional middleware with a RPC-based client-server interaction, the implementation of a fragmented object may be distributed over an arbitrary number of fragments, without restrictions on internal structure or interaction, while maintaining a transparent, standardized interface on the outside.
In this paper we describe a middleware system that integrates the concept of fragmented objects into a CORBA environment. Our fragmented objects support implicit binding using the ORB's marshalling mechanism by defining customized IOR profiles, while full interoperability with traditional CORBA applications is maintained. Furthermore, we show that a broad range of tasks in distributed systems can be solved elegantly using a fragmented object approach. Our own CORBA middleware AspectIX implements the described functionality.

Currently, Java in traditional embedded systems is not very widely adopted due to the required resources and the lack of realtime capabilities. The Kertasarie VM was designed to get a feature rich implementation with a small memory footprint. In this paper we present a typical scenario from which we derive the requirements for a Java virtual machine implementation. The concept and features of the Kertasarie VM are presented in detail. It is related to other
VMs by a comparison of speed and code size. Overall, the Kertasarie VM turns
out be a perfect choice for Java in embedded systems.

Component-based software development technique and its intensive use in the industry has led to the wide research in various aspects of component-based systems (CBSs). Dependence analysis is an useful technique that has many applications in software engineering activities including software understanding, testing, debugging, maintenance, and evolution. In this paper, we propose a matrix-based approach to analyzing dependences in CBSs.
1
By further investigating the application of matrix to analyzing dependences in component-based system, we find that it is a good way to manage dependences in a CBSs. To make it possible, we first discuss something about a dependence-based
representation called the component dependence graph (CDG) and then construct the dependence matrix (DM) t Based on the CDG and DM, we build a mathematical basis for managing and analyzing dependences in a CBS. Finally, we discuss some possible applications of our dependence analysis technique in component-based system understanding, testing, maintenance, and evolution.

Open electricity market requires a dramatic increase in the exchange of information between the market participants. Exchange of information and data in heterogeneous IT_s environment of the market participants is very diffi-cult due to different information, data, files, databases and application or calculation model. It is only through the concepts of domain objects that a unified, application independent, and consistent data models can be created and main-tained.
In this paper, a concept of object-oriented model of the information ex-change
network in open electricity market is proposed. Open electricity infor-mation
exchange network is realised with object-oriented software development process. The presented concept makes use of Unified Modelling Language, and its suitability in real system is presented using Germany liberalised electricity
market.

Product Lines are developed by people. Winning them for product line development is a key issue in successfully introducing and institutionalizing product line development in an organization. This makes people issues a key concern in technology transfer. Based on our experience in technical transfer in the product line area we developed some hypotheses on how these people issues can be formed in a way favorable to product line development. In particular, we focus on the relation between the mind set of people, com-munication patterns, and the organizational structure. We then give concrete rules based on our own industrial experience as well as industry reports that support instutionalizing product line development.

The application of refactorings during an object-oriented development process improves the design and therefore the quality of software. Aspect-orientation
is a new programming paradigm that increases the modularity of software. Hence, it seems natural to apply both aspect-orientation as well as refactoring during a software development process since both techniques permit to increase the modularity and comprehensibility of software. However, on the one hand existing object-oriented refactoring techniques cannot directly be applied to aspect- oriented software because object-oriented refactoring and aspect-orientation somehow seem to contradict each other. On the other hand, since the new features of aspect-oriented languages permit to modularize software in different ways than known in the object-oriented world there is a large
variety of new refactorings based on these features. This paper discusses the relationship between object-oriented refactoring and aspect-orientation. We show
what aspect-oriented elements conflict with existing refactorings and propose
solutions for these conflicts for the aspect language AspectJ. Furthermore, we
introduce a number of new aspect-oriented refactorings which help on the one
hand to migrate from object-oriented to aspect-oriented software and on the
other hand to restructure existing aspect-oriented code.

The basic programming elements in object-oriented programming (OOP)are objects that interact with each other by sending messages to and receiving messages from other objects. This principle is realized differently in various OOP
languages, but the most commonly used approach is the definition of methods and classes which are subsequently used to instantiate objects. Typically, object references are used to bind and call methods on an object. In this paper, we
present a new approach to remote object binding and method calling by introducing so called method streaming. Caller and callee objects are not directly bound using object references but by binding to a method stream. This approach decouples caller and object instances, enabling flexible message routing between distributed objects and dynamic composition of binding aspects. In contrast to existing approaches, method streams enable the transparent and
customizable interconnection of remote Java object implementations on top of conventional network middleware. Thus, method streams do not replace but supplement existing solutions like RMI and CORBA by providing an easy-to-use
framework for Java-based distributed applications. The feasibility of the approach is illustrated within the middleware platform ODIN by customizably reconnecting migrating objects and intercepting remote method calls.

Keywords: Java Remote Object Binding, Network Middleware, Object Interconnection, Method Streaming, Distributed and Migrating Objects, Java Dynamic Proxy, Java Reflection

Reuse of experience and solutions for recurring development problems is of the utmost importance for a pragmatic software engineering discipline. The earlier in the development process reuse is achieved, the larger its positive impact on the project. This paper reports on reuse approaches that are applicable during the requirements analysis phase.

This work describes a method to make the Java RMI subsystem secure in heterogenous and distributed systems.The approach is based on conserving the access control context of the Java Security Architecture.Our framework uses pure Java functionality only and can be integrated unobtrusively into existent server applications.

Electronic business processes and distributed data interchange are no longer limited to particular organizations and customer groups.
With Web connectivity becoming a standard in most organizations and
households, governments seek rationalization of public services (like health
care) by using Web-based information integration. Inherently, such So-ciety
Information Grids require large-scale and asynchronously evolving
distributed object networks of interoperating organizations. Many such
applications also require information privacy and strict auditability of
information ow. This paper describes an approach to realizing such a
mediation technology based on the idea of auditable Peer-to-Peer networks.
The behavior of this middleware is determined by a formalization based on Petri-net theory. An implementation prototype has been created based on the Microsoft .NET framework. The described research is carried out in tight collaboration of two academic departments with industry and public organizations primarily in the application domain of Health Care.

Einer der treibenden Faktoren für die Verbreitung der objektorientierten Software-Technologie in den neuziger Jahren war das Versprechen, durch
erleichterten Software Reuse schneller und billiger zu qualitativ guter Software zu kommen.
Die Wiederverwendung von Software war und ist dabei meist eingebettet in einen traditionellen, dokumentengestützten Software-Entwicklungsprozess.
Neben diesen machen seit einigen Jahren nun so genannte leichtgewichtige
oder Agile Prozesse von sich reden, die eine grössere Flexibilität angesichts sich ständig verändernder Anforderungen und Prioritäten erlauben.
Das vorliegende Papier beleuchtet die bislang wenig erörterte Frage, ob Software Reuse auch in einem Agilen Projektumfeld möglich ist und die
erwarteten positiven Effekte bringt. Wir beschreiben, dass und wie Software Reuse in Agilen Prozessen erfolgversprechend eingesetzt werden kann und zeigen, welche Chancen sich dadurch eröffnen und welche Risiken beachtet werden müssen.

In this paper we presen the unconven ional architecture of JOSH, an interpreter for Java code fragmen s. It consists of a parser hat accepts Java code fragments,a code generator hat embeds he fragments into Java classes and exploits inheritance and serialization o preserve state. The classes are then compiled and executed by external processes.
To propagate state from the execution of one code fragmen o he next, state is serialized and written in o and read from temporary files. The major advan age of this approach compared to other Java in erpreters is stability, i.e.its ability o recover from errors.We conclude the paper by comparing our approach o previous ones.

Although information hiding is widely recognised as a key strategy for well engineered software systems, its use is not encouraged by standard object
oriented programming languages. The paper explores a fundamental aspect of this issue, namely the idea that a programmer should be free to implement a module in any way which fulfils its specification. We show how taking this freedom seriously creates problems for the conventional object oriented dot notation,
and we present a solution which permits client programmers to continue to use this notation without restricting the freedom of implementors.

A domain-specific language provides domain experts with a familiar abstraction for creating computer programs. As more and more domains embrace computers, programmers are tapping into this power by creating their own languages fitting the particular needs of the domain. Graphical domain-specific modeling languages are even more appealing for non-programmers, since the modeling language constructs are automatically transformed into applications through a special compiler called a translator. The Generic Modeling Environment (GME) at Vanderbilt University is a meta-programmable modeling environment. Translators written to interface with GME models typically use a domain-independent API. This paper presents a tool called ANEMIC that generates a domain-specific API for GME translators using the same metamodel that generates the language.

This paper describes a technique for improving separation of concerns at the level of domain modeling. A contribution of this new approach is the construction of support tools that facilitate the elevation of crosscutting modeling concerns to first-class constructs in a type-system. The key idea is the application of a variant of the OMG Object Constraint Language to models that are stored persistently in XML. With this approach, weavers are generated from domain-specific descriptions to assist a modeler in exploring various alternative modeling scenarios. The paper examines several facets of Aspect-Oriented Domain Modeling (AODM), including: domain-specific model weavers, a language to support the concern separation, an overview of code generation issues within a meta-weaver framework, and a comparison between AODM and AOP. An example of the approach is provided, as well as a description of several future concepts for extending the flexibility within AODM.

Domain specific languages (DSLs) have proven to be a very adequate mechanism to encapsulate and hide the complex implementation details of component-based software development. Since evolution lies at the heart of any software system the DSLs that were built around them must evolve as well. In this paper we identify important issues that cause a DSL implementation to be very rigid in which all phases are tightly coupled and highly dependent upon one another. To increase the poor evolvability of current day DSL development environments a new development environment Keyword based programming (KBP) is proposed where DSLs are built by using a language specification to compose and glue loosely coupled and independent language components (called keywords).

Concepts - sets of abstractions related by common requirements--have a central role in generic programming. This paper proposes a general framework for using concepts to control polymorphism in different ways. First, concepts can be used to constrain parametric polymorphism, as exemplified by type classes in Haskell. Second, concepts can be used to provide fine-grained control of function and operator overloading. Finally, generic functions can be overloaded (specialized) based on concepts, rather than simply on types. We describe a C++ implementation of a new mechanism, which we call enable_if, and its role in concept-controlled polymorphism.

Architecture description languages deal with the description, analysis and reuse of software architectures. This paper describes DAOP-ADL, a component- and aspect-based language to specify the architecture of an application in terms of components, aspects and a set of plug-compatibility rules between them. With the aim of connecting the specification of the application architecture to the implementation, we describe our language using XML and XML Schemas. The DAOP-ADL language was designed to be interpreted by DAOP, our own dynamic component- and aspect-oriented platform. DAOP provides a composition mechanism that plugs aspects into components dynamically at runtime. The software architect will use the DAOP-ADL language at design time to describe the architecture of the application. Later this architectural information is loaded into the DAOP platform, which needs it to establish the dynamic connections between autonomous components and aspects. Therefore, the use of DAOP-ADL closes the gap between design and implementation of component- and aspect-based applications.

This paper presents our toolkit for developing a Java-bytecode translator. We adopted the reflective architecture for our toolkit but the previous implementation technique of this architecture involves serious runtime penalties whereas this arcihtecture makes it easy to develop a translator. To address this problem, our toolkit uses a custom compiler so that the runtime penalties are minimized. Since a previous version of our toolkit called Javassist has been presented in another paper, this paper focuses on this new feature for performance improvement by compiler support. This feature was not included in the previous version.

This paper presents techniques for the formal specification and efficient incremental implementation of spreadsheet-like tools. The spreadsheets are specified by strong attribute grammars. In this style of attribute grammar programming every single inductive computation is expressed within the attribute grammar formalism. Well-known attribute grammar techniques are used to reason about such grammars. For example, ordered scheduling algorithms can be used to statically guarantee termination of the attribute grammars and to derive efficient implementations. A strong attribute grammar for a spreadsheet is defined and the first incremental results are presented.

This paper describes the OBS Instantiation Environment, which demonstrates a generative approach to automating the instantiation process of a component-based framework. The process is automated in the sense that designers configure and assemble the framework components using intuitive visual operations in a GUI-based environment. Their configuration actions are then used to automatically generate the framework instantiation code. Generative techniques for framework instantiation are not new but tend to rely on domain-specific languages or on bespoke specification encoding and compilation techniques. Though effective and powerful, they are comparatively complex and present a high barrier to entry for general users. The distinctive feature of the approach proposed here is instead its simplicity and its reliance on mainstream technology and tools.

The hardware description language TDL has been designed with the goal to generate machine-dependent postpass optimizers and analyzers from a concise specification of the target processor. TDL is assembly-oriented and provides a generic modeling of irregular hardware constraints that are typical for many embedded processors. The generic modeling supports graph-based and search-based optimization algorithms. An important design goal of TDL was to achieve extendibility, so that TDL can be easily integrated in different target applications. TDL is at the base of the PROPAN system that has been developed as a retargetable framework for high-quality code optimizations at assembly level. For two contemporary microprocessors, the Analog Devices SHARC 2106x, and the Philips TriMedia TM1000, significant improvements of the code produced by production-quality compilers could be achieved with short retargeting time. TDL has also been used for implementing postpass optimizations for the Infineon C16x/ST10 processor that are part of a commercial postpass optimizer. TDL specifications are concise and can be produced in short time.

This paper describes Hume: a novel domain-specific language whose purpose is to explore the expressibility/costability spectrum in resource-constrained systems, such as real-time embedded or control systems. Hume provides a number of high level features including higher-order functions, polymorphic types, arbitrary but sized user-defined data structures, asynchronous processes, lightweight exception handling, automatic memory management and domain-specific metaprogramming features, whilst seeking to guarantee strong space/time behaviour and maintaining overall determinacy.

The paper addresses theoretical and practical aspects of implementing multi-stage languages using abstract syntax trees (ASTs), gensym, and reflection. We present an operational account of the correctness of this approach, and report on our experience with a bytecode compiler (called MetaOCaml) based on this strategy. Current performance measurements reveal interesting characteristics of the underlying (OCaml) compiler, and illustrate why this strategy can be particularly useful for implementing domain-specific languages (DSL) in a typed, functional setting.

Design patterns have been a useful tool for a better understanding of the collaboration between several classes and objects in a program. One drawback of this approach is the lack of an explicit representation of the patterns used in a program, as the collaboration between classes normally is expressed in the code of the class itself. In this paper, we present a method for explicitly representing patterns in a program with the help of metaprogramming techniques. The method presented has benefits compared to traditional approaches with respect to documentation and reusability of the program, as well as providing a better separation of the protocol contained in the pattern.

We describe the problems associated with the creation of high performance code for mathematical computations. We discuss the advantages and disadvantages of using a high level language like MATLAB and then propose partial evaluation as a way of lessening the disadvantages at little cost. We then go on to describe the design of a partial evaluator for MATLAB and present results showing what performance increases can be achieved and the circumstances in which partial evaluation can provide these.

More and more generator techniques and products become available. Some of them, such as frame-based generator systems, are appropriate for performing ambitious generation tasks. However, most commercial projects use generators for rather low-level, non-critical purposes and are skeptical about their wider use. In particular, there is a popular argument that the effort needed to use a generator technique outweighs its advantages. In several projects, Delta
Software Technology Group has gained experience disproving this argument.

The report starts with a short introduction to frame technologies. As a first reference concerning the practical usage of frame-based generators, we discuss our experience in a project at an insurance company located in Switzerland. As it turned out, the solutions implemented in this project were sufficient for the project, but could not be generalized.
With this experience and the mentioned anti-generator argument in mind, a second
commercial project was undertaken; this time using improved generation tools and an improved solution architecture. We present the lessons of
this second project: among others, a special kind of meta-programming, which
played an important role. The report concludes with a discussion of the
pros and cons of the practical usage of generators.

Reactive behavior is rapidly becoming a key feature of modern software systems in such diverse areas as ubiquitous computing, autonomic systems, and event-based supply chain management. In this paper we analyze the convergence of techniques from aspect oriented programming, active databases and asynchronous notification systems to form reactive middleware. We identify the common core of abstractions and explain both commonalities and differences to start a dialogue across community boundaries. We present existing options for implementation of reactive software and analyze their run-time semantics. We do not advocate a particular approach but concentrate on identifying how the various disciplines can benefit from each other. We believe that AOP can solve the impedance mismatch found in reactive systems that are implemented through inherently static languages, while AOP can benefit from the active database community's experience with event detection/composition and fault tolerance in large scale systems. The result could be a solid foundation for the realization of reactive middleware services.

Dynamic AOP (Aspect-Oriented Programming)is receiving growing interests in both the academia and the industry. Since it allows weaving aspects with a program at runtime, it is useful for rapid prototyping and adaptive software. However, the previous implementations of dynamic AOP systems suffered from serious performance penalties.
This paper presents our new efficient dynamic AOP system in Java for
addressing the underlying problem. This system called Wool is a hybrid of two approaches. When a new aspect is woven in, the programmers can select to reload into the JVM a modi fied class file in which hooks for executing advice are statically embedded,or they can insert hooks as breakpoints in the JVM. Since the two approaches have different performance characteristics, the programmers can select the best one for each join point. Our experimental result shows, under a certain circumstance, Wool runs dynamic AOP application about 26%faster than a traditional static code translation approach.

Multimedia stream processing is a rapidly evolving domain which requires much software development and expects high performance. Developing a streaming application often involves low-level programming, critical memory management, and finely tuned scheduling of processing steps. To address these problems, we present a domain-specific language (DSL) named Spidle, for specifying streaming applications. Spidle offers high-level and declarative constructs; compared to general-purpose languages (GPL), it improves robustness by enabling a variety of verifications to be performed. To assess the expressiveness of Spidle in practice, we have used it to specify a number of standardized and special-purpose streaming applications. These specifications are up to 2 times smaller than equivalent programs written in a GPL such as C. We have implemented a compiler for Spidle. Preliminary results show that compiled Spidle programs are roughly as efficient as the compiled, equivalent C programs.

A staged computation is a computation organized in a cascade of stages: each stage produces code for its successive stage; the final stage produces the desired output. An off-line procedure called binding time analysis (BTA) is often used to pre-convert unstaged code into staged code, i.e., code annotated with stage labels, which can guide online staged computation. For dynamic re-optimization purposes, it is advantageous forthe order of stages in the cascade for a staged code to change during runtime; however, the staged code may not support all permutations of stage sequences. Thus, it is both a fundamental and practical question to efficiently decide whether a specific stage sequence is valid for a staged code. Our approach is to encode the set of valid stage sequences for a staged code off-line in a \emph{stage ordering encoding language} (SOEL) to facilitate fast online decision. Contrary to the intuition that we only need a single generic SOEL (such as the language of partially ordered sets of stage labels) to sufficiently and efficiently encode the set of valid stage sequences for any staged code in any staged language, we may need different SOELs for different staged languages. We analyze several staged languages and then present a metatheory on validating a SOEL for a given staged language. Our result reveals the relationship between SOELs and semantic properties of staged languages, and can influence the design of staged languages and BTA.

Recent work proposed defining type-safe macros via interpretation into a multi-stage language. The utility of this approach is illustrated with a language called MacroML, in which all type checking is carried out before macro expansion. Building on the this work, the goal of this paper is to develop a macro language that makes it easy for programmers to reason about terms locally (i.e., without reference to context information). This paper argues that viewing ``macros as multi-stage computations'' helps in developing and verifying not only type systems for macro languages but also equational reasoning principles. However, such results are not easily established with the MacroML calculus. We therefore present calculus of staged notational definitions (SND) that eliminates ad hoc features of MacroML but retains its phase distinction, and incorporates the generality of Griffin's account of notational definitions. We exhibit a formal equational theory for such a calculus and prove its soundness.

We present a compositional meta-level language for coordination of distributed objects. The design of the language is based on the principle of separation of concerns, namely separation of the coordination from computational aspects. The language can be used in combination with any object language capable of expressing sequential behaviors of objects. The language, which is inspired by Petri nets, has a simple syntax and semantics, but is expressive enough to express many of the commonly used coordination patterns. The level of abstraction provided by this language allows tools and techniques developed for Petri nets to be readily applied for analysis and verification of the specified coordination patterns.

A primary goal of generative programming and model-driven development is to raise the level of abstraction at which designers and developers interact with the software systems they are building. During initial development, the bene- fits of abstraction are clear. However, during testing and maintenance, increased distance from the implementation can be a disadvantage. We view test cases and test harnesses as an essential bridge between the high-level speci fications and the implementation. As such,the generation of test cases for fully generated components and test harnesses for partially generated components is
of fundamental importance to model-driven systems. In this paper we present our experience with test-case and test-harness generation for a family of model-driven, component-based distributed systems. We describe our development tool, MODEST, and motivate our decision to invest the extra effort needed to generate test code. We present our approach to test-case and test-harness generation and describe the bene fits to developers and maintainers of generated systems. Furthermore, we quantify the relative cost of generating test code versus application code and find that the artifact templates for producing test code are simpler than those used for application code. Given the described bene fits to developers and maintainers and the relatively low cost of test-code de-
velopment, we argue that test-code generation should be a fundamental feature of model-driven development efforts.

Families of independent classes, where each class represents a separate, orthogonal concern are highly attractive for implementing collaboration-based design. However, required subtype relationship between such families cannot be expressed in many programming languages. This paper presents a framework to handle collaborating groups of classes using template metaprogramming based on standard C++ features in the style of Loki::Typelist. Our solution provides tailor-made implicit conversion rules between appropriate groups, inclusion polymorphism and a tool for dynamic binding.

In this paper we introduce a new approach,the so-called AgentComponent (AC)approach which combines component and agent technology. A multi agent system (MAS)is composed of AC instances, each AC instance consists of a knowledge base, storing the beliefs of an AC instance,of slots,storing the communication partners of an AC instance,of a set of ontologies,that represent domain speci- fic languages for certain contexts,and of so-called ProcessComponents (PC)representing the behaviours of an AC instance. The AC is a generic component
that can be reused (instantiated ACs)and parametrized by customizing the communication partners (slots),the ontologies and the behaviours (PCs)that can be added and removed from any AC instance. Hereby we achieve added value for agents and components.Agents can be easily composed, customized and reused whereas components get enhanced communication and interaction facilities from agents.We present this approach in detail, show how to construct a component-based MAS by a simple example and present a graphical tool for composing systems of AgentComponents.

Designing, operating and maintaining industrial plants require extensive
and complex engineering processes. An integrated engineering process
considering all different aspects, data and workflow of plant automation design
as well as interoperability to other systems is the key to more efficiency and
lower costs of engineering tasks in the plant life cycle. There exists no comprehensive and satisfying solution to this problem today. However, an agent-oriented view can lead to fundamentally new and promising approaches to an
integrated plant engineering process. The goal of this paper is to clearly identify the specific goals and challenges in engineering industrial plants and to show that agents are a beneficial approach to meet them. To this end, an agent-oriented solution for integrated engineering of automation systems is presented, applying the advantages of agent concepts while considering the constraints of existing automation structures.

The basic concepts in agent negotiation are negotiation object, negotiation protocol and reasoning process. While aiming to transfer sociological concepts into multi-agent systems, where agents coordinate themselves by negotiation, we recognized the need for a more detailed structure.Therefore we developed C-IPS, which is presented in this article. It distinguishes between external constraints and internal reasoning processes. The reasoning process covers decisions regarding the negotiation issue, the partner, and a particular step. Its modularization supports the development of agents with different degrees of autonomy. The components of the C-IPS architecture are modeled according to the BDI approach. As an example for the application of C-IPS we consider agents
that are required for the INKA project.

This paper focuses on the features of belief change in a multi-agent context. Agents have to consider information received from the other agents and the ability of how to change beliefs after receiving a message is a prerequisite for many multi-agents problems.The agents are embedded in an environment where they are communicating and they have to prevent potential internal con flicts in their beliefs.We study the belief change operators in that context. Our approach is to consider that agents ’belief state is a set of pairs (belief, origin of the belief)combined with a preference relation over the agents embedded in the multi-agent system. The belief revision procedure for handling received messages is a syntactic approach which aims at selecting the minimal subsets of the belief base in con flict with the received information and, according to the reliability of the sources of the con flicting beliefs,removing the less reliable beliefs in order to handle the received message. The proposed
belief change operators ensure that an agent makes as few changes as possible but also handle iterated belief changes by preserving the order on the beliefs.

Design and construction of multi-agent systems is a challenging but an intriguing problem. It is because of the intrinsic distribution of the intelligent components. In such environments the interaction and communication between the constituent parts extends the complexity since appropriate coordination methods need to be designated and employed. In this paper a successful experiment in designing and implementing such an environment is presented 1). The test bed for this research is the rescue simulation environment.The architecture of the implemented heterogeneous agents takes advantage of various algorithms.These algorithms make the agents act intelligently by themselves albeit they happen to act quite in coordination with each other. The implemented algorithms for the sake of cooperation between the heterogeneous agents enhance the overall pay off of the system. The autonomy of the agents is guaranteed by means of some methods such as reinforcement learning, decision trees and some sort of heuristic functions.
In order to settle the agents in coordination with each other and make them act cooperatively, some other methods have been applied. Among these methods, combinatorial auctions, coalition formation, function approximation for evaluating the value of cooperation,and some probabilistic and heuristic methods can be named.

1) The implemented agents won the first place award in RoboCup Rescue Simulation
league in Fukuoka,Japan,2002.

We present an improvement to evolutionary learning of cooperative behavior which incorporates some accountability measure for strategy components into the evolutionary learning process. Our evolutionary approach is based on evolving sets of prototypical situation-action pairs (strategies)that together, with the nearest-neighbor rule, represent the decision making of our agents.The basic idea of our improvement is to collect data for each pair showing the results of its applications. We then choose those pairs in the parent strategies that had
positive results for the construction of new sets of pairs for our strategies.
Our experiments within the OLEMAS system show that the incorporation of accountability results in substantial improvements of both on- and off-line learning when compared to the basic evolutionary approach. In nearly all experiments, either the agent teams required less learning time or found better strategies. In many cases both were observed.

Multiagent systems (MAS) have found their way into industrial applications
in recent years and appear to be one of the most promising technologies that
originated in AI research in recent years. However, evaluation standards as they
are common e.g. in the scheduling or database systems communities are largely
amiss. In this paper, we propose communication-based performance measurement
(CBPM) as a new method that is particularly suitable for open, communication-intensive MAS, and argue that it can be used as to design indicators for self-diagnosis by the MAS itself. The ability of such self-diagnosis is a prerequisite for MAS with self-repairing and self-optimising properties required by the autonomic computing view. CBPM is based on the idea that important aspects of the external behaviour of a MAS can be measured in terms of the communication processes within them. We present different levels of communication-based performance measurement: frequency analysis of performatives and analysis of complex message patterns. Several examples of analyses of inter-agent communication based on FIPA-ACLand the contract-net protocol in implemented, complex, market-oriented MAS demonstrate the usefulness of our approach. We conclude that these performance measures provide useful information about MAS and pave the way for devising autonomic self-improvement methods for these systems.

The main focus of multi-agent research so far has been on concepts and techniques to analyze and specify multi-agent systems. Much less attention has been devoted to the implementation of the concepts and techniques. This paper intends to bridge the gap between the mere concept of simultaneous actions and its implementation. Simultaneous actions are actions that are executed by different agents at the same time. We study simultaneous actions in the context of situated multi-agent systems where agents and objects have an explicit position in the environment. To clarify the concept of simultaneous actions, first we propose a classi fication for simultaneous actions and illustrate each type with examples. Then we present a generic model for simultaneous actions
that is independent of the applied agent architecture.Support for simul-
taneous actions involves two aspects: first it must enable agents to act together and second, it must ensure that the outcome of a combination of
simultaneously performed actions is in accordance with the domain that
is modeled. In the model, acting together is established through synchro-
nization, while the domain requirements are ensured through rei fication of actions and subsequently combining the simultaneously performed actions in accordance with the valid laws. We used the model to implement the Packet –World with centralized as well as with regional synchronization. In the paper we illustrate the model for both approaches and discuss the implications for the complexity of implementation, the autonomy of agents and the scalability of the multi-agent system.

E-medicine covers the whole range of medical process and service.
Multi-agent approach is suitable for the development of e-medicine systems. In
this paper, firstly the requirements of e-medicine are analysed, and a taxonomy
is proposed for e-medicine systems. Secondly multi-agent approach is
introduced for developing e-medicine systems, and the design of agents and the
design of multi-agent structure are presented for e-medicine systems. Finally a
case study is presented on a telemedicine for diabetes to illustrate the
development of e-medicine systems.

A matching is a (one-to-one)mapping between two sets, satisfying some given constraints. In a multiagent scenario, i.e.in a setting where at least one of the sets corresponds to a group of agents, a number of interesting facets are added to this general matching problem. Therefore, in this paper, we discuss several different matching criteria, where preference between elements is based on their distance (not on rankings), and state their relationship to well-known criteria, e.g.Pareto efficiency. We also introduce algorithms for computing matchings. The first one (LocalMatch ), a decentralized algorithm, requires only communication between pairs of agents. The second algorithm (GlobalMatch )
with a central control agent, called coach, computes a globally maximal matching, i.e., where the maximal distance in the matching is minimized not only for the whole set of elements, but also for each submatching, in O (n 2 .5 log n )time. Especially this kind of matching has applications in multiagent systems for solving transportation problems, coordination of rescue robots, and marking in (simulated) robotic soccer, which is addressed in this paper.

Providing services within multiagent systems, an agent has to register itself with a distinct description of its main capabilities in yellow page services. If another agent is requesting to solve a speci fic task, it has to be decided whether or not the requested agent is capable of performing the task successfully. We are assuming that task requirements as well as capabilities are specified using ontologies. Decision is easy if the concepts of requested task requirements are directly mapping to concepts of provided capabilities. However, concept inequality may occur. Especially in production engineering with its increasing concern of knowledge about sophisticated manufacturing processes, relying on simple concept equality is not suitable to ful fill demands of current industrial applications.Thus,enhanced methods like ontology-based capability management presented in this paper have to be established to
address this problem.For the case of indifferent concepts we are introducing a con flict-based approach for capability negotiation as well as an application scenario for this approach in the manufacturing domain.

In this paper, we describe an ontology for a hierarchically organized
production control system in semiconductor manufacturing. The semiconductor
manufacturing domain is characterized by reentrant product flows, sequence de-pendent setup-times, prescribed due-dates, a diverse product mix, a mix of dif-ferent process types including batch processes and preventive maintenance is-sues because of complex technological processes. Starting from a hierarchical
decomposition of the manufacturing system, we use an agent-based architecture
for implementing the resulting production control system. In order to coordinate
the autonomous entities of the hierarchy, we suggest an ontology that is appro-priate to the hierarchical control approach. We illustrate the use of the suggested ontology.

We advocate the event-based communication genre for mobile agent
communities, which is useful for exchanging and disseminating large volumes
of small lightweight messages. We propose that the publish-subscribe model
complements the proprietary or standard agent communication languages. We
describe how we implemented the event notification mechanism for mobile
agents, and analyse experiments that demonstrate the Elvin-based event notifi-cation mechanism for communication between heterogeneous agents, in particular,
Grasshopper agents and Aglets. We also discuss experiments for measuring
message losses due to agent migration.

This paper presents our integrated hotel reservation service. Using it as a case study,we discuss the design and implementation of agent-based information systems. Taking a system as a whole, we consider not only information agents but also their interface to human users and external information sources. In particular, our focus is on the interaction behavior, which can be observed both in interactions between agents and in interactions between agents and these interface components. We show that both kinds of interaction are coordinated by the same protocol. Using our implemented hotel reservation service system, we illustrate exemplarily how this understanding can be used to systematically design and validate interaction mechanism. We explore the
possibility to facilitate the rapid prototyping of information agent systems using an interaction behavior editor. Moreover, by giving insight into some details of our hotel service system, we exemplify where the difficulties in implementing information agent systems are and thus infrastructural support are desirable.

A key to an optimal assortment of goods and pricing of individual items in a store is the knowledge about potential customer’s behaviour. In this paper we present the simulation of individual customers based on a multiagent system which models the important elements and external influences as single agents. An agent can be member of several agent groups which are represented as holons. We model each individual customer as an agent which behaves according the customer’s individual preferences. These preferences are extracted from real world data, such as customer cards, sales data and interviews. The customer’s shopping behaviour is represented in behaviour networks (Bayesian nets) which are stored in the customer agents’ knowledge bases. The behaviour of a representative group of customers induces the overall sales figures, which
support decisions what to sell at which price. The presented concepts are based
on ideas of Joachim Hertel from DACOS and Jörg Siekmann from the DFKI.
They are implemented as a prototype, which provides, after further evaluation,
the basis for a new and final system to be used by retailers.

In this paper we want to show the possibilities to use agent-based modeling and simulation for software development. Therefore we present the integrated environment SeSAm and recent extensions, that allow creating simulated environments for agent based software as well as actually developing and deploying software agents.

In order to design and implement multiagent systems, the specification method should be as expressive and comprehensive as possible. Statecharts, which are capable of describing dynamic systems and are widely accepted in the computer science community, are applied and investigated for this objective. In this paper, multiagent systems are studied in the domain of robotic soccer, where the behavior of agents including collaboration is specified by means of UML statecharts [7,8 ]. This method is also applicable to industrial software applications. For example, a network application can be designed and specified by means of the same method (see [1 ]). The approach enables not only standardized design of multiagent systems, but also almost automatic translation of the speci fication into a running implementation.
As a natural extension of this methodology for designing multiagent systems, formal system analysis and verification should be possible, in order to investigate important system properties. In this paper, we will show how speci- fications of multiagent systems based on UML statecharts can be verified, by employing model checking techniques. Hence, the proposed specification technique can be used for both,automated multiagent system implementation and analysis.

The design of artificial agents that are meant to model behavioral, cognitive, economic or social structures asks for tools that aid in layout and implemen-tation of agent architectures. To implement agents based on Dörner’s Psi theory of emotion and cognition, our group has introduced a toolkit that assists in designing modular architectures, as well as representational structures, such as semantic networks, control scripts and connectionist structures by means of a graphical editor. At the same time, the framework supports the inclusion of functionality written in a native programming language. This paper gives an overview over the implementation of agents according to Dörner’s theory, and while it also aims at giving an insight into the functioning of these agents (which we call “MicroPsi” agents), its main purpose is the explanation of the use of the toolkit.

Web service adaptation is an important feature for mission critical Web services. It is widely recognized that thrashing and crashes occur in system saturation for many statically adaptive resource management algorithms,including CPU,memory,and network congestion. Service adaptation supports alternative responses to saturation control, maintaining service and server system stability and progress, instead of thrashing. In this paper,we present a design framework for developing adaptive web services. The core of this framework is the adaptation space model,which is based on the concepts of adaptation space and adaptation case. An adaptation space is de fined by a use
context and a partial order of adaptation cases. Each adaptation case describes a speci fic adaptation of a program or component of a web service. There are three main thrusts of the adaptation space approach.
First,it de fines a multi-dimensional adaptation context for capturing and coordinating different kinds of adaptation at different levels of a web service. Second,it provides a uniform way for representing and viewing a collection of alternative adaptations for a given web service component. Third,it promotes a declarative and incremental approach to adaptation speci fication,allowing the incorporation of new adaptation behavior of a web service in terms of existing adaptation cases. We evaluate the adaptation space approach using Ginga, an adaptive query processing service for handling queries over multiple data sources with diverse capabilities across the Internet. Our experimental results show that Ginga query adaptation can achieve signi ficant performance improvements (up to 40%of response time gain)for processing
distributed queries over the Internet in the presence of end-to-end delays.

Web services are expected to become the foundation of highly-dynamic distributed business computing architectures. By building upon
the Internet-based technologies that changed the face of business com-
puting over the last decade, web services are a significant step towards
a truly universal infrastructure for e-business. Focusing on the case of
opportunistic virtual enterprises, this paper first considers the widely-
held view that they can be modelled by web service federations and then
highlights the fact that, in that case, similar problems to those faced in
attempts to federate databases will also stand in the way of virtual en-
terprise formation. A lightweight, unobtrusive approach is described to
improve the chances that web service federations can be formed unim-
pededly, thereby reducing the cost of virtual enterprise formation and
operations. Therefore, the paper contributes an enabling technology to
facilitate an important, and highly dynamic, kind of e-business.

Todays information systems are built using various component models such as Enterprise Java Beans, JavaBeans, Microsoft COM+, and CORBA distributed objects. In this paper we argue that it is crucial for designers of information systems to interactively build and test systems constructed from (a)components (enabling interoperability across component models) and (b)Web services at the same time.
The contribution of this paper is threefold: Firstly, we introduce a visual tool the Component Workbench -for designing information systems
out of components from different component models (e.g.EJB,COM+, CORBA)and combine them with Web services. Secondly, we show how component compositions can be turned into Web services using SOAP as a communications protocol. Thirdly, we show how to interactively test compositions before creating the actual Web services out of components.

Asynchronous invocations are an important functionality in the context of
distributed object frameworks, because in many situations clients should not block during remote invocations. There should be a loose coupling between clients and remote services. Popular web service frameworks, such as Apache Axis, offer only synchronous invocations (over HTTP). An alternative are messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation
styles used within the same application. In this paper we build a framework using patterns for asynchronous invocation of web services. The framework design is based on the asynchrony patterns and other patterns from the same pattern language.

Web service technologies accelerate application development by allowing
the selection and integration of third-party web services, achieving high modularity, flexibility and configurability. However, current approaches only allow this integration by hard wiring the references to concrete web services into the client applications. Moreover they do not provide any management support, which is fundamental for achieving robustness. We observe the need for the application to be independent of specific services and present the WSML, a management layer placed in between the application and the world of web services. In this paper we identify the requirements for this layer to realise the dynamic selection and integration of services, client-side management of services, and support for rules that govern the selection, integration and composition. We show how dynamic AOP is ideally suited to implement the core functionality of the WSML using the JAsCo dynamic aspect-oriented language to conduct the experiments.

Web pages from a web site can often be associated with concepts in an ontology, and pairs of web pages can also be associated with relationships between concepts. With such associations, web pages can be searched, browsed or even reorganized based on their concept and relationship labels. In this paper, we investigate the problem of extracting link information of relationship instances from a web site. We define the notion of link chain and formulate the link chain extraction problem. An extraction method based on sequential covering has been proposed to solve the problem. This paper presents the proposed method and the experiments to evaluate its performance. We have applied the method to extract link chain information from the Yahoo! Movie Web Site with very promising results.

Integrating applications and resources using Web Services increases the exposure of critical resources. Consequently, the introduction of Web Services requires that additional effort be spent on assessing the corresponding risks and establishing appropriate security mechanisms. This paper explains the main challenges for securing Web Services and summarizes emerging standards. The most important of these, WS-Security, defines a message-based security model for SOAP that is suitable for achieving end-to-end security in environments with multiple trust domains. We propose one particular, gateway-based approach to implementing Web Services security, and compare it to other approaches.

As more and more companies provide their services over the Internet, the need to better understand and manage the normative context of composite services (including rights and responsibilities of all parties involved) becomes evident. Unfortunately the normative perspective of both individual and composite services seems to be left out from current e-service research and
practice. Yet, this perspective of e-service provision is very important not only because of the possible legal consequences but also because of its implications on customer’s trust. The main objective of this paper is to investigates the normative perspective of a composite e-service offered by independent as well as affiliated service providers. It proposes a formal model of the normative context, investigates the problem of its management and define the requirements for a value-added service that could be used both by customers
and providers of composite e-services.

Semantic Web technology has a vision to define and link Web data in a way that it can be understood and used by machines for automation, integration and reuse of data across various applications. Ontological definition of every resource as it is assumed in Semantic Web, along with new techniques for semantics processing and new vision Intelligent Web Services is expected to bring Web on its new level. At present, Web Services technology is stressed by the search of a right way for further development. Combination of Semantic Web and Web Services concepts may address many of difficulties of existing technology. It is not a question of whether Semantic Web is coming or not, but a question of when it will come. However without mature standards, proof and actually working industrial cases Semantic Web has small chances to be
adopted by industry. In this paper a survey of Web Services recent needs is
made, state of the art of Semantic Web technology is discussed in the context
of EAI and e-business solutions. Some new challenges brought by Semantic
Web were observed and the industrial maintenance case of these challenges
implementation was considered.

In this paper we present a case study where an e-business platform
(OPERATIONS) has to be built in order to manage the operational strategies of
a high volume coastal company. The platform is intended to support multiple
operational scenarios that have to be executed when emergency situations or
sudden changes of scheduled events unfold. In order to properly integrate all
the involved parties that may take part in such a scenario, the system must
support multiple interaction patterns according to the communication channel
and the device that is used. Thus, its design must take into account multi-channel
delivery of functionality and information. The design of the system
follows a Service Oriented Architecture (SOA) in order to properly integrate
back-office data sources and legacy systems with new required application
extensions providing a complete e-business platform. The core business logic
tier of the system is a Process Oriented Platform (POP) that is able to
dynamically generate the appropriate workflows, to orchestrate the constituent
services and to execute complex operational scenarios interacting with involved
users and systems in a multi-channel fashion. Finally, appropriate knowledge
bases have been defined to support the storage, evaluation, and evolution of the
executed scenarios and to provide valuable Business Activity Monitoring
information to the company’s administration.

Dynamic inter-organizational business processes are necessary to enable the flexible creation of partnerships in areas such as e-commerce and supply-
chain-management. Although many information system architectures for the support of static inter-organizational business processes exist, such archi-tectures are still not available for supporting dynamic inter-organizational business processes. In this paper the special requirements created by dynamic inter-organizational business processes will be analyzed and the contributions of existing approaches and web services evaluated. Based on the paradigm of the
composite application, an architecture designed to support dynamic inter-organizational business processes has been developed and will be introduced.

Security is a crucial aspect in any modern software system. We consider in this article the speci fication and the management of access control in in-house business applications which are coupled over the Internet using Web services.In-house business applications are usually built on a middleware in which security is an established aspect and security management tools are available.The integration of security in SOAP,however,is still an ongoing activity.
Therefore,we propose an access control model for Web services which originates from CORBA-based applications.This integration has the advantage of a unique access control policy for both the CORBA-based in-house application and the Web services.We implemented an infrastructure to enforce the access control policy and a comprehensive set of powerful XML based management tools.

Presented is the vision of the authors on how diverse web services may be composed, mediated by dynamic task coalitions of agents performing tasks for service requestors. Main focus and contribution of the paper is the proposal of the layered service mediation architecture. Middle Agent Layer is introduced to conduct service request to task transformation, agentenabled cooperative task decomposition and performance. Presented are the formal means to arrange agents’ negotiation, to represent the semantic structure of task-activity-service hierarchy and to assess fellow-agents’ capabilities and credibility factor. Finally, it is argued that the presented formal technique is applicable to various application domains. Presented are the prospects of building agent-based layered architecture for intelligent rational information and document retrieval mediation. This work in progress is performed in frame of the RACING 1 project.

1 RACING: Rational Agent Coalitions for Intelligent Mediation of Information Retrieval on the Net. Project funded by Ukrainian Ministry of Education and Science. http://www.zsu.zp.ua/racing/

This paper presents an architecture and functional design of Uni-Grid
P&T, a toolkit for building customizable Grid portals for different
application domains in a typical university environment in China. Based on a
layered architecture, the functions of the toolkit are designed on top of the
new Open Grid Services Architecture (OGSA) and based on the standards of
Web services. We particularly address the issues of collaborative portals and
portlet implementations of the toolkit. The development of the toolkit is part
of the initiative of the ChinaGrid project launched in 2002 by the Ministry of
Education of China that is aimed to build a China national education Grid to
link more than 100 major universities across China.

Web Services allow collaboration of different systems independent of their operating system or the programming languages being deployed. They enable also the integration of legacy systems and grant access to external partners to those systems. Therefore, it is necessary to implement protection against misuse. Such an addition should be achieved transparently for users and
developers. This paper illustrates how to integrate important security features into corporate firewalls or proxies.

In this paper we propose an XML-based adaptive multiagent system for handling
e-commerce activities. More speci fically, our system aims at supporting a customer,visiting an e-commerce site, in the search of products and/or services present therein and appearing to be appealing according to her/his past interests and behaviour. The system is adaptive w.r.t.the pro file of both the customer and the device she/he is exploiting for visiting the site.Finally, the system is XML-based since XML is exploited for both storing the agent ontologies and handling the agent communication.

This paper proposes a software agent based framework for developing mobile commerce applications. We will commence by analysing the requirements of developing mobile commerce applications, which are brought about by advantages and disadvantages of mobile devices and infrastructures. We will describe the benefits of multi-agent systems where agents are able to move around from one host machine to another and explain how such a system can be used as the basis of a software framework fulfilling the requirements for mobile commerce applications. We’ll finally present a case study and a framework on using software agents to transform an existing mobile commerce application.

OO-Analytiker betrachten Use Cases oft als das Allheilmittel zur Erhebung von
Anforderungen an ein Softwaresystem. Der Use Case-Ansatz verspricht, das uralte
Kommunikationsproblem zwischen Fachbereichen und IT endgültig zu lösen. Endlich
werden ehrfurchterregende Diagramme durch triviale (selbst für Fachbereiche
verstehbare) Strichmännchen und Ellipsen verbannt und die Worthoheit durch
Verwendung von natürlichsprachlichen Texten dorthin verlagert, wo die
Anforderungen entstehen und verstanden werden müssen _ nämlich auf die
Fachseite. Sind wir IT-ler nicht gnädig, dass wir unseren Weißkittelstatus dafür
aufgeben? Und doch scheinen die Fachbereiche unsere genialen Use Cases
trotzdem nicht zu mögen. Oder sind wir unfähig sie richtig zu beschreiben? Oder
haben sich die Fachbereiche gerade an die Welt der (scheinbar so ungeeigneten
Fachkonzepte) gewöhnt und müssen erst wieder _umerzogen_ werden?
Dieser Beitrag beleuchtet das Dilemma und zeigt Lösungen zu folgenden Fragen auf:
- Was zeichnet Use Cases wirklich aus?
- Primäre und sekundäre Use Cases
- Was gibt es sonst noch so für Anforderungen?
- Wie werden Anforderungen in Großprojekten verwaltet?
- Wo entstehen Probleme bei der Organisation von Anforderungen?
- Was zeichnet eigentlich Fachkonzepte aus?
- Was sind eigentlich Features?
- Primäre und sekundäre Features
- Die Use Case-Feature-Orthogonalität
- Und wie spielen Use Cases und Features zusammen?

Modern web applications require effective access to web services, robust and scalable architecture, responsive and rich user interfaces and minimal usage of network resources. SAP, a leading e-business provider has dealt with web applications in many projects for many years. This talk will address the experiences made so far and draw conclusions on Dos and Don_ts. You will also learn how a model-driven approach combined with the use of generative techniques can help to minimize the effort of building and maintaining MVC-style web applications. We will explain how to:
* Effectively manage the consummation of web services in the model layer
* Effectively build controllers to incorporate application logic
* Use pattern-based GUI development to achieve a consistent view-layer

Today's sophisticated software applications are developed using ob-ject-
oriented techniques. On the side of the database the object-oriented ap-proach
hasn't established _ the usage of relational databases is still state of the
art. There are a couple of tools that bridge this so called "impedance mismatch".
These tools allow the usage of relational database systems with an object-oriented approach. This is achieved in extending the object-oriented language
with an object-oriented database model, often called persistency model. This
persistency model translates all requests written by the developer in his object-oriented environment to appropriate database operations, i.e. SQL-statements.
But the transparent usage of such a persistency model often leads to unaccept-able slow systems. This paper describes how, and why this can occur. It will
then introduce different categories of design patterns to prevent certain per-formance problems when using an object-relational mapping. Finally, it gives
examples for each of these categories, pointing out their application area and
their advantages and disadvantages.

Nowadays almost all companies, public authorities or other institutions have developed some kind of web-application to present their information to dedicated end users. The different implementations range from simple static HTML pages to dynamically information generated for each request at runtime. A lot of applications additionally need to integrate spatial data. As these kind of information are somehow different from other data, the integration, administration and presentation is not as easy as in traditional web applications. This paper gives an overview how we handle spatial information in the MobiHarz project.
As this architecture completely consists of free software, parts of the system can easily be adopted to other spatial applications on the web.
Especially public authorities shall be encouraged by this article to use freely available software in spatial information systems.

In diesem Vortrag wird dargestellt welche Moeglichkeiten der Oracle 9i Application Server TopLink hinsichtlich der Persistenz von Java-Objekten bietet. Neben den bekannten Entity-Beans koennen auch "normale" JavaObjekte aus SessionBeans, JSP's oder Servlets persistiert werden. Desweiteren wird die Ablage von JavaObjekte als XML-Struktur angeboten.Duerch diese flexible Handhabung der Persistenz kann die für das Projekt beste Persistenzvariante gewählt werden.
Durch verschiedenste Performance-Schalter (Just in Time Reading, Caching ...) kann durch TopLink die Performance der Applikation stark verbessert werden.
Diese Themen werden durch Erfahrungsberichte aus laufenden Projekten untermauert.

JDragon is a J2EE application generator. It enables its users to generate whole applications based on database schemata. The application generated allows its users to read dates from the database, insert new database entries or to update existing entries. The whole application is generated without writing one single line of source code. Once generated, the application may be enhanced to integrate with other applications and additional business logic may be introduced. In this paper we describe the JDragon application and compare it to
other approaches that generate J2EE applications.

Um welches System handelt es sich?
Die HHLA (Hamburger Hafen- und Lagerhaus AG) hat den Container Terminal Altenwerder (CTA) 2002 in Betrieb genommen. Seit Anfang 2003 arbeitet CTA an der Kapazitätsgrenze der ersten Ausbaustufe.

Was ist an der SW für CTA besonders?
1. HHLA hat mit CTA den ersten Schritt zur Ablösung der Alt-SW in M (Mumps) durch neue SW in Java getan.
2. Eine Migrationsstrategie erlaubt die Koexistenz von alter (M-) und neuer (Java-) SW. Über die Java-M-Kopplung wurde auf der NOD 2000 berichtet.
3. Mit der neuen SW wird eine Host-Architektur (M) durch eine n-tier Client/Server Architektur (Java) ersetzt.
4. Mit CTA wurde vollautomatische Umschlagstechnik eingeführt, die durch ein Java-Programm (mit moderaten Echtzeitanforderungen) gesteuert wird. Die Architektur dieser Gerätesteuerung ist Message-basiert. Dadurch wird die SW fast beliebig verteilbar und damit skalierbar. Die Geräteschnittstellen wurden in XML nachspezifiziert, um den Code dafür generieren zu können.
5. Mit CTA wurde ein Informationssystem in portabler J2EE Technologie implementiert. Über die Zielhardware konnte deshalb sehr spät entschieden werden. Ein eigenes GUI-Framework sorgt für uniformes Look&Feel.
6. Die CTA-SW besteht aus mehreren Teilsystemen, die mit einer MOM (JMS) verbunden sind. Alle Messages wurden in XML spezifiziert, was syntaktische Fehler (im Test) ausschließt.
7. Die CTA-SW enthält eingekaufte Teilsyssteme, deren Socket-Schnittstellen erfolgreich mit JMS-Adaptoren gewrappt wurden. Die Schnittstellen wurden damit lokal testbar und das Gesamtsystem blieb dank konstanter Einstellungen der lokalen Teilsystem-Konfiguration und dank des Wrappers dennoch fern-konfigurierbar.
8. Die Vorgehensweise im Projekt weist folgende Highlights auf: -vorgeschaltete Architekturstudie zur Risikominimierung (Machbarkeit und Performanz von n-tier C/S und Gerätesteuerung, M-Anbindung) sowie für die wichtigsten Architektur-entscheidungen: MOM, J2EE, messagebasierte Gerätesteuerung. - durch regelmäßige Workshops organisierte inkrementelle Entwicklung parallel zur Konkretisierung der Anforderungen (Architektur-zentriert). - begleitende Simulationen für die Algorithmen der Gerätesteuerung und -optimierung. Nur so konnten 2 Mio LOC in der Rekordzeit von 2,5 Jahren selbst neu entwickelt und zusammen mit geänderter M-SW und zugekauften Teilsystemsn von ca. 1 Mio LOC integriert, getestet und in Betrieb genommen werden.

Spätestens seit die 1995 verabschiedete "EU-Direktive zum Schutz des Individuums bei automatisierter Verarbeitung seiner persönlichen Daten und deren Austausch" endgültig ihren Weg in die deutsche Gesetzgebung gefunden hat, stellt sich die Frage nach Möglichkeiten zur Umsetzung der verschärften
Datenschutzanforderungen. Die informationstechnische Realisierung soll dabei i.d.R. größtmögliche Flexibilität bei möglichst hoher Transparenz für die Zielanwendung gewährleisten.
Durch die Etablierung der Java 2 Enterprise Edition als Standard für die Entwicklung serverseitiger Mehrschicht-Architekturen scheinen diese Anforderungen auf den ersten Blick einfach zu lösen. Schließlich existiert in der J2EE die Möglichkeit zur deklarativen Autorisierung. Dieser Ansatz beschränkt sich allerdings auf die Autorisierung auf Typ- bzw. Methodenebene und geht somit für die einfachsten Datenschutzanforderungen nicht weit genug. Um Richtlinien umzusetzen wie z.B. "vertrauliche Personendaten dürfen nur von der Person eingesehen werden, für die sie erfasst wurden", ist vielmehr ein
instanz- bzw. datenbasierter Zugriffsschutz notwendig.
Die Object Management Group (OMG) hat mit dem Resource Access Decision Service einen Dienst spezifiziert, der als Rahmen für die Realisierung eines datenbasierten Zugriffsschutzes dient. Dieser Dienst ermöglicht die klare Trennung von Applikationslogik und Datenschutzlogik bei gleichzeitiger Gewährleistung eines Maximums an Anpassungsfähigkeit.
Aufbauend auf der Spezifikation der OMG läßt sich ein Framework entwickeln, das sowohl für security-aware, als auch für security-unaware Applications einsetzbar ist und neben der klassischen Ja/Nein-Entscheidung bzgl. des Zugriffs auf eine schützenswerte Ressource (Barriere) auch Möglichkeiten zum
ausblenden nicht-zugreifbarer Daten (Filterung) anbietet.

This session will analyze the evolution of web services usage in Enterprise Application Integration (EAI). The challenges and benefits experienced by integrators and users as web service technologies become enmeshed in enterprise system landscapes will be discussed.

What is the role of EAI in challenges posed by the evolution of Web Services? What will be the relationship between EAI and newly established and emerging Web service standards? And how might this change in the future?

How Web services will benefit EAI practitioners by reusing code, allowing a more modular approach to applications, and greater adaptability, usability, flexibility and integration will be elaborated upon. The technical aspects of diverse elements including hardware, business applications and middleware, as well as performance issues including usability and scalability will be touched upon.

Im Vortrag geht es darum, wie man prozessorientiert die Komplexität bestehender J2EE Anwendungen durch Monitoringwerkzeuge aufbrechen kann.
Dabei werden sowohl die benötigten Prozesse als auch die verfügbaren Werkzeuge
vorgestellt. Anhand eines sehr bekannten Beispieles aus der J2EE-Welt werden die
einzelnen Schritte live gezeigt werden.

Mit Hilfe einiger einfacher Formatierungsregeln bietet ein Wiki jedem Benutzer im Web die Möglichkeit, mit Formularen Text ohne HTML-Kenntnisse zu ändern. Nach dem ersten WikiWiki von Ward Cunningham implementiert als CGI Script in Perl wurden viele Clones in unterschiedlichen Programmiersprachen entwickelt. Das freie unter Smalltalk entwickelte Swiki wird hier näher vorgestellt.

Der Vortrag behandelt folgende Thembereiche:

-Überblick über Wiki Implementierungen
-Einsatzmöglichkeiten für ein Wiki
-Möglichkeiten für die Anpassung des Layouts
-Bedienung und Formatierungsregeln
-Besonderheiten für die Implementierung in Smalltalk
-Ausblick in die Zukunft für Wikis

Mit SOAP existiert ein standardisierter Mechanismus zur Implementierung von Plattformunabhängigen Remote Procedure Calls. SOAP wird unter anderem für die Implementierung von Web-Services genutzt.
Ohne die Verwendung von kryptographischen Verfahren wie Signaturen und Verschlüsselung sind diese Dienste in sicherheitsrelevanten Anwendungen nicht nutzbar. Mit den Standards XML Digital Signature (XML-DSIG) und XML Encryption (XML-ENC) hat das W3-Konsortium diese Lücke geschlossen.

Der Artikel richtet sich an Software-Architekten und Entwickler und umfassst folgende Themen:
_Überblick über die SOAP-Protokollelemente
_eine kurze Einführung in kryptographische Verfahren
_Vorstellung des XML-DSIG Standards
_wie kann XML-DSIG genutzt werden, um sichere SOAP-Applikationen zu erstellen
_eine konkrete Implementierung von SOAP und XML-DSIG in einer Smalltalk-
Klassenbibliothek

We give a report on the Naris-project at Henkel KgaA, Düsseldorf.
In this project a host application of half a million lines of code was replaced by a J2EE-based solution which extended the functionality but took only 5000
lines of XML and 5000 lines of Java code to implement the problem domain.
The solution supports the development of perfumes and is embedded into an
environment of several SAP/R3 systems.
Probably the most interesting part of this project is the approach we took which
we believe to be new.

--W3C und W3C.DE / W3C.AT Das World Wide Web Consortium (W3C) wurde 1994 von Web-Erfinder Tim Berners Lee gegründet, um das volle Potenzial des Webs auszuschöpfen. Dazu werden von den Mitgliedern Technologien (Spezifikationen, Richtlinien, Software und Tools) entwickelt, die den Fortschritt des Webs fördern und seine Interoperabilität sicherstellen. Die sicher bekanntesten sind (X)HTML und XML. Die Empfehlungen (Recommendations) des W3C sind de facto-Standards für das Web.
--Das Deutsch-Österreichische Büro des W3C (W3C.DE / W3C.AT) im Fraunhofer-Institut für Medienkommunikation ist der Repräsentant des W3C für den deutschen Sprachraum.
--Mitglieder des W3C sind mehr als 380 Firmen, Regierungsstellen, Vereinigungen und Forschungseinrichtungen, die an einem fortschrittlichen, leistungsfähigen und interoperablen Web interessiert sind.

Innerhalb der Anwendergemeinde und des World Wide Web Konsortiums (W3C) wird derzeit die Ergänzung der bekannten Unicode-basierten Klartextdarstellung der Extensible Markup Language (XML) um eine binäre Fassung diskutiert. So einleuchtend die Forderung zunächst vorderhand erscheinen mag, so diffus sind dennoch die Zielsetzungen der Proponenten. Während einige sich von einer Binärfassung eine kompaktere Datendarstellung erhoffen, rücken andere einen vermeintlichen inhärenten Sicherungsaspekt, der durch den Verlust an direkter Lesbarkeit für den menschlichen Konsumenten begründet wird, in den Vordergrund. Insgesamt hat sich --- weder unter den Diskutanten, noch dem Standardisierungsgremium --- eine eindeutige Haltung zum Thema herausgebildet. Zunächst versucht versucht das W3C im Rahmen eines Workshops die verschiedenen Anforderungen zu sammeln, um daraus Handlungsempfehlungen an die zuständigen Arbeitsgruppen abzuleiten. Der Vortrag beleuchtet zunächst die Hintergründe des Themas, stellt Zielsetzungen und mögliche technische Lösungen vor, er diskutiert jedoch auch Gefahren, die mit der vermeintlich naheliegenden "Optimierung" einhergehen.

Das DiZ-Web (Seminarverwaltung und Anmeldung des DiZ) besteht aus XML-Technologie mit XLink-Linkbases und XInclude in einer dreistufigen Art und Weise. Die Dateien werden gepflegt in csv-Dateien wegen der einfachen Struktur für Sekretärinnen, daraus werden in einer zweiten Stufe XML-Dateien und XLink-Linkbases erzeugt. Und in einer dritten Stufe werden "normale" XML-Dateien erzeugt, aus denen dynamisch HTML gebildet wird.

The Multimodal Interaction Activity is extending the Web user interface to allow multiple modes of interaction, offering users the choice of using their voice, or an input device such as a key pad, keyboard, mouse, stylus or other input device. For output, users will be able to listen to spoken prompts and audio, and to view information on graphical displays. The Working Group is developing markup specifications for synchronization across multiple modalities and devices with a wide range of capabilities.

The problem of designing a domain-specific language (DSL) can be split into two subproblems: a) defining the language constructs starting from an appropriate set of abstractions in the domain, and b) choosing a syntax that resembles the standard notation, or is otherwise as intuitive as possible from a domain expert standpoint. We propose as a solution a minimal functional language which can be extended syntactically and semantically as needed. The extension process is performed from within the language itself, using a set of reflective facilities, and such process is dynamic (i.e. performed at run-time), thus enabling the programmer to try new constructs as soon as they are defined. We believe this kind of frameworks have not been yet fully exploited in the field of DSL design and implementation.

When considering domain-specific languages that are not purely static, the question arises how programs written in the DSL can interact with those of the base language. We propose to apply the concept of linguistic symbiosis as a standard for evaluating mechanisms that allow such an interaction. Linguistic symbiosis in general refers to the ability of programs written in di erent languages to interact transparently as if they were written in the same language.

Mixin-based inheritance is an interesting alternative to both single and multiple inheritance. As opposite to single inheritance, it allows code reuse among di erent class hierarchies. Contrary to multiple inheritance, it allows developers explicitly specify the desired behavior by explicitly linearising superclasses. In this paper we show that reection can support mixinbased inheritance without any performance overhead. This support is provided by means of metaclasses that are classes which instances are also classes.

A conventional debugger depends on breakpoints, i.e. program points at which a supervised execution halts and users are allowed to probe the program state by submitting expressions for interpretation. As part of a tool to build interpreters, we provide this behaviour as semantics for a simple operation. It is part of what we call the common deep structure of the languages. Lisp-like languages have S-expressions as their deep structure, and a surface structure given by a set of predefined operations. Reflexivity can rely on facilities to represent programs as data that subsequently can be manipulated and interpreted. This is done in Lisp-like languages, and even Java provides means to represent Java programs. Lisp-like languages translate Sexpressions into lists, which is available as a data structure to programmers. Our approach does not provide a data representation for general use, since our interest is restricted to language extensions through an eval-like operation.

In object-oriented systems, classes and objects often evolve into complex entities, and still, specification of features is still done mostly in a method-by-method basis. This paper presents a novel technique for object specialization. It consists of a series of language constructs which perform reflective transformations in compile-time. These are based on annotations added to method signatures called signals, through which sets of methods from an object can be referred to collectively. This way, not only concerns that crosscut several methods from an object can be "factored out", but they can also be specified in a generic way so they can be mixed-in into objects of different inheritance hierarchies.

In order to formally validate the interactive commands of a videoconference sytem on the net we programmed it with a reflective object-oriented system allowing us to explicitly program metaclasses. We programmed a generic model of human-machine interaction and hold simultaneously in one hand the operational objects and in the other hand their formal equivalent in a reactive language with which a formal verification can be done. The dynamical translation is done using the reflective capabilities of the chosen language which combines both Scheme and ObjVLisp functionalities.

Model-Driven Architecture ® (MDA ® ) depends on the availability of decent automatic code generators and model transformers. While applying MDA has long been part of a solutions catalog, particularly for environments targeting complex architectures, the creation of generators and model transformers itself has long been based on rather immature and ad-hoc technologies, such as large collections of templates. This caused all kinds of problems that are well-known from other fields of software engineering: Creating transformations is expensive, the resulting generators/transformers are hard to understand, therefore hard to reuse and extend and are of comparably low quality.

The demonstration will show how the concepts and benefits of object-oriented software design and development can be applied to the creation of maintainable, tailorable and extensible generators / transformers. This includes an inheritance concept for generators / transformers and other OO patterns. Furthermore, the demonstration will show how MDA can be applied to the specification of transformations itself, allowing for the automatic generation of large portions of generators / transformers from UML models.

The demonstration will cover basic samples and it will also share experiences gained in construction of productized transformations for a number of domains.

The HyperSenses technology, developed at Delta Software Technology GmbH, describes a technical architecture which focuses on important parts of the concepts of Generative Programming and Intentional Programming (IP).

The goal of HyperSenses is to facilitate application development by offering different levels of abstraction concerning the source code. Therefore a source is represented by several renderings: Pure text is just the simplest possibility, beneath semi-graphical and graphical renderings. They are combined with intelligent behaviour: Domain-specific patterns describe expansion semantics and code properties, including insertion points and so-called annotations; meta information enables language specific behaviour; application-specific models control the process workflow. Together with checking possibilities and context-sensitve editing features the sources become active sources in the original sense of IP. Hence HyperSenses is much more than a kind of editing support like e.g. the Microsoft(R) IntelliSense(R) technology - this intention is expressed by its name.

MetaEdit+ allows you to build your own CASE tool - without having to write a single line of code. MetaEdit+ provides metamodelling language and tool suite for designing your method. Using these tools you can define the modelling concepts, their properties, associated rules, symbols, checking reports and generators. The object-oriented metamodelling makes CASE tool development fast and cost-effective.

As soon as you define a method, or even a partial prototype, your team can start using it. For the method users, MetaEdit+ provides full CASE tool functionality for multiple users, multiple projects, running on all major platforms. Your team can immediately start to edit designs as graphical diagrams, matrices or tables. You can browse designs with filters, apply components, link your models to other designs, and check your models and generate the desired output, like code, docs, testing material, etc. You can have the tool you want because you are in charge!

e-GEN technology (www.gentastic.com) provides an approach that can deliver managed support for off-shore development organization, tele-development for geographically distributed teams, or simply to reduce deployment costs within an single site organization. In each case the model-driven generative approach provides a solid framework to enforce consistent understanding, process and deliverables.

The demonstration will illustrate how a domain model coupled with a configurable template-based generative capability can be used to provide an Internet based Design Portal application capable of supporting remote development. The approach centralizes the definition of software architecture and design patterns, hiding the technology complexities from designers, exposing only a custom-fit Design Portal that guides designer through an accurate process of capturing domain-specific design details, and generating software artifacts.

The Design Portal can also be integrated with development processes to facilitate compilation, testing and deployment.

The Generic Modeling Environment (GME) is a metaprogrammable graphical editor supporting the design, analysis and synthesis of complex, software-intensive systems in diverse engineering fields. GME has a component-based architecture using MS COM technology and is implemented in C++. The Core component exposes the domain-specific language specification through a set of COM interfaces. Another set of interfaces provides bi-directional model access and also exposes all the model modification events. All the other tool components, (diagram editor, decorators, browser, event-based OCL constraint manager, software generators, etc.) are built independently around the Core. Model persistence is supported via standard database technology and XML import/export functionality. The standard technologies applied throughout the architecture (UML, OCL, COM, XML) make GME easily applicable and extensible to a wide variety of domains. One such domain is metamodeling, where UML class diagram based metamodels can be created to configure GME itself.

exchangeable templates - exchangeable generator meta model - exchangeable input meta model

The b+m Generator is a template-based generator framework designed for architecture-centric software development according to OMG's Model Driven Architecture (MDAT) approach. The b+m Generative Development Process leads to the term of an 'application family' which contains a runtime system, templates and its meta model implementation. However, the application family should be considered not only as a set of applications with a similar platform binding, but also as an operational component of the development process. As an artifact, it contains all components necessary for the use of the generator in order to be able to transform architecture-centric models to implementation frameworks. The flexible import interface of the generator can read design models of virtually any UML tool exported to XMI. The configurability of the meta model instantiation even enables processing proprietary, XML-based formats. In addition to the application design, the generator needs a Java implementation of the design language used - the Java meta model to instantiate the design model. The resulting instantiated Java meta model corresponds exactly to the application design. Fundamentally, any diagram types such as activity diagrams, sequence diagrams, and use-case diagrams can be supported. This means that, in contrast to other tools, not only static but also dynamic application aspects can be made generable. The b+m generator is not restricted to UML but can support any modeling language for which a meta model and the corresponding instantiation rules can be created. The source-code expansion is controlled by templates that are dynamically linked to the classes of the meta model.

The purpose of this dissertation is to investigate the use of advanced separation of concerns techniques—specifically, aspect-oriented programming—in the context of the problems that call for the use of dynamic, lightweight languages. Advanced separation of concerns techniques are feasible and useful for dynamic, lightweight languages. The AOPy project is an aspect-oriented system implemented in the scripting language Python. A common scripting language task, the development of web application services, has been identified as a representative problem domain. A technique from Discount Usability Engineering, known as a Thinking-Aloud study, will be used to evaluate aspect-oriented programming in the problem domain.

The deployment refers to all activities that make software available to its users. These activities become more difficult for software built from heterogeneous distributed components. In this paper, we propose a deployment platform for distribited multi-component software. In this platform, the deployment is carried out by components which are separated from software functionalities. The deployment solution that we propose includes adaptation components which collect information from sensors and act on deployment components.

In this paper we present a novel approach, called FuseJ, for achieving a symbiosis between Aspect-Oriented and Component-Based Software Development. We build on previous research that proposes a new Aspect-Oriented programming language tailored for the Component-Based field, called JAsCo. Although JAsCo provides us with some nice results, we argue that a symbiosis between aspects and components is essential. To achieve this symbiosis, we propose a new component model, where both aspects and components are described in the same base component language.
Each component is equipped with a number of homogeneous gates that allow
accessing a particular feature. An application is assembled by interconnecting
these gates, using explicit connectors, which contain the full expressive power
for specifying crosscutting communication. As crosscutting behavior is
specified as regular components, aspects and components can not be
differentiated and a true symbiosis is achieved.

The development of database application systems will benefit from high reusability because similar design circumstances recur frequently in database
developments. However, research in software reuse has shown that mismatches
of components with the application architecture, state and other components, destroy the component reusability. In this paper, a generative and component based reuse framework is presented to tackle the problem of high variability and therefore to achieve higher reusability in database application
development. A Scenario based dynamic component Adaptation and GenerAtion
technology (SAGA) is developed to support deep component adaptation and component generation. XML has been used as the universal information carrier in the approach.

Since the appearance of Java several tools have been developed to allow making dynamic hanges in Java programs. In general, these tools trades the flexibility for the efficiency of the program.
In this paper I present RtJAC,an aspect-oriented framework for Java based on JAC [3], which makes possible to reate aspects, specify their join points and weave them into an application, all at run-time. I show that weaving at run-time not only provides more flexibility but can significantly improve the performance of a dynamic aspect-oriented system.

Model-driven development is a generative programming technique in which domain-specific features and engineering decisions are described using models of desired properties and behavior at various levels of abstraction. Producing models at the requisite level of specificity is an expensive undertaking. Generally, organizations offset the costs associated with generative techniques like model-driven development by reusing high-level domain-specific models across members of a product family. Most generative techniques focus on the automation of design and implementation activities. However, we believe that the increased level of formalism required by model-driven development can also be leveraged during other activities like analysis, verification, testing, main-tenance and deployment. Furthermore, as design and implementation activities become increasingly automated, we feel that verification and testing activities must leverage the models and the generative engine in order to be feasibly address the generated systems. This paper presents a high-level view of a performance analysis kit as an example of a verification activity that can be integrated into model-driven development. By automating simulation code generation and instrumentation, data collection and data reduction, and by using existing models as inputs into the performance analysis kit, we hope to make it feasible to conduct performance analyses in an ongoing manner throughout the development life cycle. Our research will involve the creation of the model-driven performance analysis kit, its integration into a model-driven development environment, and an evaluation of the kit’s utility during the design and implementation of a complex distributed system.

With the advances in web technologies, web pages are no longer confined to static HTML files that provide direct content. This leads to more interactivity of web pages and at the same time to ignoring a significant part of the Web by search engines (or web crawlers) due to their inability to analyze and index most dynamic web pages. In this paper, we present a prototype system for retrieving dynamic content from pages returned by web forms. The system is based on the form query language that allows to query forms, retrieve data from dynamically generated web pages and store them.

During the last decade, software product lines have increasingly received
attention as they promise to significantly improve the productivity of the
software development process and so to reduce both the cost and time of
developing and maintaining software systems. In order to achieve the promised
improvements, however, a high level of quality of the components reused in the
various product line members is required. Therefore, more than for traditional
software development, testing as still the most prevalent approach for ensuring
quality becomes a very crucial part of every product line effort. Nevertheless,
research in the field of testing reusable components and software product lines
is still in a very early phase and there is actually little guidance for product line organizations on how to systematically test their product lines yet. This paper discusses what the challenges in testing software product lines are and outlines an approach that enables to test product lines more effectively and efficiently.

A high degree of abstraction and capacity for reuse can be obtained in software design through the use of Generic Programming (GP) concepts. Despite widespread use of GP in computing, some areas such as the construction of generic component libraries as the skeleton for complex computing systems with extensive domains have been neglected.
Here we consider the design of a library of generic components based on the GP paradigm implemented with Java. Our aim is to investigate the feasibility of using GP paradigm in the construction of complex computer systems where the management of users interacting with the system and the optimisation of the system’s resources is required.

According to recent publications, tele-education is a vastly growing
business that helps to satisfy the need for lifelong learning. Due to time
shortage, it seems inevitable that tele-education will be more and more de-manded by mobile users. Thus, any platform that provides tele-teaching
documents, must also cope with mobile users. The question now is, whether
already existing systems can be used and easily amended to fulfill this re-quirement.
Therefore, the paper investigates the use of content management systems for tele-education platforms and identifies the functionality to be added for mobile users.

We consider the adaptation of random early detection (RED) as an active queue management algorithm for multimedia traffic in wireless networks. We studied features of RED, multimedia data and point out a weakness in both. We show that an appropriate RED algorithm can improve multimedia data performance.

Objektrelationale Datenbanken bieten sich heute für die Speicherung von unabhängigen Multimedia-Daten an. Die formalen Konzepte objektrelationaler
Datenbanken berücksichtigen aber bisher keine spezielle Beziehungen
(Substitutionsbeziehung, Synchronisationsbeziehung) zwischen Multimedia-Objekten.
Wir stellen daher eine formale Erweiterung der Struktur- und Verhaltens-vererbung vor, die auch die Substitutionsbeziehung berücksichtigt. Weiterhin
wird ein Ausgabeschema als neues Konzept eingeführt, um die Synchroni-sationsbeziehungen für die Datenausgabe zu modellieren.

Im Projekt „Integrierende Benutzer- und Ressourcenverwaltung an den Thüringer Hochschulen (Meta Directory)“, das durch das Thüringer Ministerium für Wissenschaft, Forschung und Kunst (TMWFK) gefördert wird, bemühen sich die Rechenzentren der Universität Erfurt, der Technischen Universität Ilmenau, der Friedrich-Schiller-Universität Jena und der Bauhaus-Universität Weimar um eine integrierende und einheitliche Sicht auf die digitale Identität der Hochschulangehörigen.

The security of Wireless Local Area Networks (WLANs) is an important topic especially in corporate networks. This article provides an analysis of a variety of security technologies for WLANs, including WEP, RADIUS, VPN and 802.1x. Based on the analysis we provide proposals for the security settings in WLANs.

Die Konfiguration von Dienstinstanzen stellt einen wesentlichen Aspekt bei einer dienstorientierten Betrachtung verteilter Systeme dar. Trotz der immensen Bedeutung besteht auf diesem Sektor noch großer Nachholebedarf.
Versionierung von Konfigurationsdaten und Verringerung der Redundanz der darin enthaltenen Daten stellen wesentliche Aspekte bei der Verwaltung von Dienstkonfigurationsdaten dar. Aus diesem Grunde wurde ein Informationsmodell
unter Berücksichtigung dieser Anforderungen entwickelt. Diese Modell wird dann um eine prioritätsbasierte Verwaltung unterschiedlicher Konfigurationsquellen
erweitert.

It is well known that systems that have been evolving over a long period of time become costly to maintain, i.e., the productivity when adding new functionality and fixing bugs is low. In this paper we present a nonintrusive method for increasing the maintainability of complex industrial realtime systems. This method aims to create a formal model of an existing system
and using that model for analyzing the effect of changes. The challenge of this
approach is to develop a valid model with a minimum of complexity and to
show that the model is valid for use. The method focuses on analyzing timing
and synchronization properties.

Focusing on the legacy issues toward new technologies, we present our legacy migration methodology that composed of automation techniques, migration process, and collaborative migration support system to facilitate legacy software migration. It has been partially applied in our experimental migration project, and shows promising results.

Many health care facilities have information systems with support for medical record keeping, finance and work ow, however, it is widely recognized that one of the keys to cost reduction and service improvement in national health care lies in the integration of medical information system. Integrating information not only improves care delivery today, but also helps in building research bases for the enhancement of future care delivery. There exist complex, diverse and evolving systems, therefore adoption of a single client software solution or common clinical terminology is not feasible. This lack of single software solutions and common terminologies implies that integration of medical systems will need to employ and resolve the many heterogeneous systems that currently
exist. In addition, a exible infrastructure that acts as a backbone for integration of medical organizations are needed.
We present current research work aimed at realizing integration of dif-ferent
medical systems in a configurable network of interconnected organizations.
Integration is achieved by wrapping existing systems using web service and industry standards to provide a uniform and adaptable interface with functionalities for interoperability as well as secured and controlled access among the individual systems.

This paper describes some aspects of the software development approach which is used in open source software development projects and has evolved over time to a successful software development model. It identifies and the core processes and the deployed software infrastructure of this software development model. This enables the identification of possible improvement opportunities and possibilities to enhance the open source software development model and to adopt some elements of this approach in a commercial software development environment. Since open source software development has already been proven, that it is able to produce successful software products it seems to make sense to integrate some successful elements of this approach into proprietary and distributed software development projects.

Open source has emerged as a powerful concept in software development
and marketing in the early 21th century. This paper explores how open
source communities work and how they co-exist or thrive in co-operation with
ìtraditionalî software companies. This analysis of given best-practices is backed up from first-hand experiences gained in the German NOW project focusing on efficient usage of open source concepts in industrial contexts.

Open source software development follows a development process that is defined by various rules and conventions as well as the set of tools that is being used, depending on the particular project. Commercial organizations which plan to enter the open source scene usually use quite different processes and tools.
They have to integrate the tools used by the community into their development
environment and adjust their processes accordingly. This is no trivial task. In
addition, there are important cultural differences between Open Source and commercial projects. This paper describes the prerequisites that are necessary for a company to join “the OSS community” and become an accepted player there.
Our argumentation is backed by a survey about tools and processes which we
conducted among a couple of larger open source projects.

The buzzword “open source software” is gaining in importance and popularity in
public, and more and more people are interested in this phenomenon. Yet up until now most of the literature concerning open source has mainly dealt with the technical aspects of the software. The non-technical side, such as discussing the economic aspects in an overall concept, have been neglected thus far. This paper presents a scheme to describe and analyse business relation of the interacting parties involved in the open source process. Additionally
business models will be described briefly, divided into two categories: the product-related and service-related. Both business models can be applied to participants in the open source model. The product-related business model deals with the issue of distributing open source products (like Linux and StarOffice). The first model is handled quickly, as much has been written about this in different studies. The service-related business model is handled in
greater detail, as the services constitute new business opportunities for companies, particularly also companies today mainly active in the market for proprietary software. As an example which questions have to addressed in a business model the role of system integrators in this market segment is discussed.

For years, the software industry has been suffering from problems subsumed under the term “software crisis”. While traditional development methods were not able to provide a cure, open source software (OSS) seems to be an effective approach to reduce product cycle-times and decrease development costs. Moreover, OSS has great potential to achieve high software quality and promote creation of reusable software, provided that proper organization and infrastructureare in place. In this paper, we look at different facets of software quality, and analyze possibilities and limitations of OSS methodology regarding the achievement of certain quality levels. We further consider different forms of cooperation between enterprises and OSS communities and examine the prerequisites for successful adoption of OSS methodology. We come
to the conclusion that to benefit from the advantages of OSS, enterprises have to adapt their internal organization and establish a development style that is less formally organized and more strongly based on self-organization principles.

Now that agents are just beginning to become an accepted method to package the working software elements of a business, it's time to consider what the future holds for business systems that are completely built out of agents. This tutorial explores the future in which agents become autonomous, adaptive, mobile entities inside the business networks of an enterprise -- where the agents can be software, machines, and people. It focuses on the potential power (and complications) of design in a multi-agent setting, and introduces participants to ways of thinking beyond individual, isolated software agents to consider entire systems of interacting agents that adapt and evolve. The tutorial surveys a wide range of agent-based systems, both natural and artificial, that are being studied within the field of Complex Adaptive Systems (CAS), and considers the lessons they offer for the engineering of autonomous object systems.

With Eclipse, IBM has released a free common platform for the Java-based
development of IDE_s, be it for Java, C++ or even COBOL. But there is more to it
than that: with it comes a plug-in component model that has a scope far beyond the development of IDE_s. The runtime environment that handles the plug-ins can be used to build arbitrary applications and fills a gap in the Java language: the lack of a consistent module mechanism that goes further than packages.
Packages do offer encapsulation: one can declare a class with package visibility. But there is no package-level concept of dependencies: a class can import classes from any package without regulations that would come from the class_ enclosing package.
Furthermore, the construction of hierarchical name spaces using packages is
confusingly unconnected with the package visibility concept _ a package has no
privileged access to its sub packages. It follows that the most natural distribution of connected classes amongst the packages of a well-structured hierarchy conflicts with the idea of building one meaningful module using one package.
On the other hand, a plug-in (as introduced by Eclipse) encompasses several packages and defines which of them or which of their classes are exported and which are hidden (this is described using XML files). It also states the dependencies on other plug-ins. Relying on these abilities, we view one plug-in as one module. The module takes advantage of the plug-in mechanisms to manage visibility and dependencies while being internally organized into packages.
Since every plug-in is loaded into the runtime environment by its own class loader, different versions of the same plug-in can work together in one application. Thus, Eclipse_s plug-in component model supports the modularization of an application system and facilitates reuse and version migration.

Domain-Specific Modelling (DSM) provides a viable solution for improving development productivity by raising the level of abstraction beyond coding. With DSM, the models are made up of elements representing concepts that are part of the domain world, not the code world (like e.g. in UML). These languages follow domain abstractions and semantics, allowing developers to
perceive themselves as working directly with domain concepts. In several cases, final products can be automatically generated from these high-level specifications with domain-specific code generators.

This tutorial introduces DSM by emphasizing the differences to modelling languages originating from the semantics of programming languages. This is followed by examples from various fields of software product development. The main part of the tutorial addresses the guidelines for implementing DSM for various application domains: how to identify the necessary language
constructs; what options are available for code generation; and what are the industry experiences.

Level: Intermediate
Required experience: Attendees should have significant software development experience, not necessarily OO, must have used at least one methodology and design/generation tool.
Expected audience: This tutorial is for experienced developers, architects, team leaders, and those responsible for developing or selecting a methodology for their software product development.

Die "Unified Modeling Language" (UML), welche seit ihrem
Erscheinen 1996 die marktbeherrschende Rolle als führende und in der
Praxis am breitesten eingesetzte Sprache zur Konzeption und
Dokumentation objektorientierter Systeme einnimmt, wird derzeit durch
das Industriekonsortium der "Object Management Group" einer
grundlegenden Überarbeitung unterzogen. Hauptansatzpunkte dieser
Aktivität sind die in der ersten Sprachversion zu Tage getretenen
Unzulänglichkeiten hinsichtlich der Abbildung reaktiver dynamischer
Systeme, wie sie zur Modellierung von
Echtzeitanwendungen benötigt werden, aber auch die vielseitig beklagte
mangelnde Formalisierung welche den automatisierten Übergang zu
ablauffähigem Code entscheidend erschwerte.

Diese Fragestellungen waren zwar zum Zeitpunkt der Vereinigung der
Vorgängeransätze zur UML bereits präsent, wurden jedoch aus Zeitgründen
in der Spezifikation nicht vertieft betrachtet. Ebenso waren Bedarf und
Interessenslage des Marktes hinsichtlich der praktischen Verwendung
einer umfassenden Modellierungssprache für verschiedene Aspekte des
Systementwurfs nicht abzuschätzen.

Die derzeit im Entstehen begriffene Sprachversion zwei stellt die erste
große Überarbeitung der bestehenden UML-Spezifikation dar.
Sie entwickelt nicht nur die bereits bestehenden Konzepte und
Möglichkeiten weiter, sondern faßt auch Teile des Sprachumfanges auf der
Basis des neu gestalteten Metamodells neu.

Das Tutorium vermittelt einen Eindruck des aktuellen Standes der
Normierung, sowie einige Hintergründe aus dem
Standardisierungsprozess und stellt an Beispielen aus der Praxis die
Mächtigkeit der nächsten UML-Version dar.

Inhaltspunkte:
- -Welche Diagramme kennt die UML 2.0?
- -Zu welchem Zweck kann ich diese Diagramme in meinen Projekten verwenden?
- -Wie funktioniert jedes einzelne Diagramm?
- -Aus welchen Elementen bestehen die Diagramme?
- -Worauf muss ich bei der Modellierung mit einem bestimmten Diagrammtyp
achten?
- -Welche Tücken verstecken sich in den Diagrammen?
- -Was hat sich seit der UML 1.5 für mich als Modellierer geändert