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.

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 fea