Table of contents

Only very recently has it been widely noticed that web client technology has matured to a point that supports applications whose visual and interaction qualities are comparable to graphical user interfaces (GUIs) as they were known before the web. Web applications can now offload a considerable part of the interaction and application logic to the client side, and thus reconcile the advantages in deployability, distributedness, and concurrency that the web provides with desirable properties of GUIs such as rich state, immediate feedback, and direct manipulation, which are sadly missing from pure HTML based web applications. The technologies that enable this architecture are JavaScript, asynchronously handled HTTP requests, and XML, which in this combination are nowadays referred to as AJAX, and of which, although probably most well known, XML is the least essential. Besides increasing the interactive quality, AJAX introduces a rather radical segregation of functionality and interaction into the architecture of web applications in that it requires a non trivial part of the application to be implemented in yet another programming language, JavaScript, and in that objects which are communicated between the parts of the application are marshalled through HTTP sessions. These requirements might seem to be burdensome at first but in fact they can considerably reduce the complexity into which purely server based web applications have evolved.

IT administrators have to manage multiple layers of architecture that effects data – from databases to flat files, structured and unstructured data and storage. How could these challenges effectively addressed in a grid environment. What are the today's IT problems and what are the requirements to integrate it into the On demand operating environmental. Grid computing provides an infrastructure on which to support a large collection of system resources that include servers, software, storage and networks.
It creates a virtualization layer of a simple yet large and powerful self managing computer out of a large collection of connected heterogeneous systems, sharing various combinations of resources. An additional benefit of grid computing is improved resource utilization.
For example, an organization may have occasional unexpected peaks of activity that demand more resources. If the applications being executed are grid enabled, they can be effectively managed in the grid by being moved to under utilized machines during peak hours.
GGF (Global Grid Forum) goals are to best serve needs and help to achieve the challenges. With other words to create STANDARDS.

Describing and understanding the interactions among computation units in a software system remains one of the most interesting challenges of software architecture. Object-orientation, concurrency, and component-based systems have pushed us into a realm where interactions between computation units (components) are often quite complex and difficult to understand.

Over the years numerous kinds of models have been used to describe interactions, including state charts, UML sequence diagrams, Petri nets, special-purpose languages, connectors, etc. However, component interactions, like many other component properties, can depend on the context or environment in which the component operates, and on the other components it is composed with. Describing these things in an interaction protocol and developing a corresponding composition semantics remains a problem. Another issue has arisen with the use of multiple views to describe the software architecture. Interaction behavior is a key part of many types of views, which results in the need to reconcile the relationship between interaction protocols across views.

Some recent work has moved away from a strictly static analysis of interaction protocols to include run-time checking of interactions. This greatly expands the kinds of things that can be described and checked in an interaction protocol, but does not address problems of composing interaction protocols nor of checking their consistency across protocol layers. Solving these problems may require a paradigm shift, from describing interaction protocols as properties of components to treating interactions as entities in their own right, with their own sets of properties.

Exposing business functions of IT-Systems as services and orchestrating these services via BPEL interpreters is only a first step towards an IT-architecture, which reflects the business process- orientation of an enterprise. How can orchestrated environments be simulated, monitored, analyzed and optimized? How are orchestrated services integrated with interactive applications and workflow? What are the technical boundaries in terms of security, transactions, synchronicity? How can distributed orchestration environments communicate in order to share a common execution context?

The presentation will discuss questions like the above by introducing the abstract building blocks of a process-oriented service-orchestration environment, mapping these building blocks to existing technologies like J2EE or .NET components, comparing standards like BPEL or WfMC, providing an overview of product families and discussing existing methodologies to obtain executable systems from domain models. It will be explained with real world examples, how such an architecture may satisfy generic technical and application domain requirements with predictable effort and cost.

The open source movement is an emergent phenomenon that is changing the way we do software development. Corporations large and small are finding that the tools and techniques that have been successful in the open source world have practical business benefits too. Jeff will talk about globally distributed software development in general and the requirements it places on collaboration, artifact sharing, issue tracking and project management. He will illustrate how service oriented architectures and portals can be used to integrate various point services into a common environment that supports multiple software development lifecycles.

Several projects, like the European ModelWare IP, are currently investigating the applicability of Model Driven Engineering (MDE) to change the current practices of software development and maintenance.
Since the MDA initial proposal by OMG five years ago, MDE has much changed and gained in consideration but still has to prove that it is really a long-term technological evolution. To this end, what is much needed is a precise definition of the MDE goals and non-goals and a stable statement of the set of principles from which MDE foundations could be assessed. The talk will discuss the historical contributions, the present state and potential future evolutions of MDE basic foundations.

Croquet is a combination of open source computer software and network architecture that supports deep collaboration and resource sharing among large numbers of users. Such collaboration is carried out within the context of a large-scale distributed information system. The software and architecture define a framework for delivering a scalable, persistent, and extensible interface to network delivered resources.

The integrated 2D and 3D Croquet interface allows for co-creativity, knowledge sharing, and deep social presence among large numbers of people. Within Croquet's 3D wide-area environments, participants enjoy synchronous telepresence with one another. Moreover, users enjoy secure, shared access to Internet and other network-deliverable information resources, as well as the ability to design complex spaces individually or while working with others. Every visualization and simulation within Croquet is a collaborative object, as Croquet is fully modifiable at all times.

The talk will touch various relevant issues including the areas of system design, programming languages, networked environments and authoring systems. It will be presented as a life demonstration of and in Croquet and (technical issues notwithstanding) allow the audience to actively participate during the presentation.

In the past Microsoft as one of the key players in the software development space was asked several times about its strategy regarding future development methodologies, its attitude towards Model-Driven-Development or Architecture, and the usage of UML. It took quite some time before a statement was given. As a part of the Dynamic Systems Initiative a vision for future development frameworks were given. Certain well known state-of-the-art approaches like modelling, service orientation, and software product lines are part this and others do not match with the current mainstream like domain specific languages and the usage of UML. Microsoft has already implemented the first steps towards this vision. First of all the presentation should shed some light on what the vision is, what the prerequisites are for the vision to become reality, what steps are already taken or are to be taken in the near future but also why Microsoft decided to move that way and sometimes leave the mainstream.

Mit der Einfuehrung von "client server" Technologien hat Unternehmenssoftware in den 90er Jahren die betriebliche IT revolutioniert. Anstelle von Grossrechnern und properitaerer, massgeschneiderter Software kamen erstmals preisguenstige Standardrechentechnik und Standardsoftware bei der betrieblichen Datenverarbeitung zum Einsatz. ERP war und ist der erfolgreichste Einsatzbereich von Unternehmenssoftware. Doch das Momentum fuer Unternehmenssoftware hat mit den neueren Themengebieten wie CRM und eCommerce bereits deutlich nachgelassen. Die Gruende sind vor allem in dem problematischen Preis/Risiko/Leistungsverhaeltnis von Unternehmenssoftware zu sehen, denn der Softwarehersteller ist nur zum Teil fuer den wirtschaftlichen Erfolg der Installation verantwortlich. Der Kunde - das Unternehmen - wird mit der Verantwortung fuer Hardware, Betrieb, Pflege, Upgrades und Weiterentwicklung allein gelassen, mit der Folge, dass viele Projekte scheitern oder einfach zu unkalkulierbaren finanziellen Risiken fuehren.

Traditionelle ASP Modelle sind bei dem Versuch, diesem Problem zu begegnen, weitgehend gescheitert. In Zukunft sehe ich vor allem zwei Modelle fuer Unternehmenssoftware: OpenSource und Software-as-a-Service (On Demand). On Demand - oder Software-as-a-Service - hat das Potential, Unternehmenssoftware als Lizenz komplett abzuloesen. Insbesondere in den Bereichen CRM und eCommerce erwarten Analysten und Visionaere eine schnelle Dominanz von On-Demand Loesungen.

A test case is said to be successful if it does not reveal a failure. With the exception of fault-based testing, a general impression is that successful test cases are useless. In this talk, we are going to revisit this impression. Recently, metamorphic testing and adaptive random testing have been developed to make use of the successful test cases to improve their fault detection capabilities. The technique of adaptive random testing will be thoroughly discussed.

Für die AAreal Bank (eine der führenden Immobilienbanken Europas) entwickelt die Tricept Informationssysteme AG in Zusammenarbeit mit der AAreal First Financial AG ein neues Banksystem basierend auf einer J2EE-Architektur. Die Architektur besteht aus zwei Clients (Beraterplatz und Kundenportal), Middletier und Host. Die Fachfunktionalität ist größtenteils im Middletier abgebildet. Der Eingang und die Verarbeitung des Zahlungsverkehrs werden aufgrund spezieller Anforderungen mittels Java auf dem Host implementiert.

Der Vortrag stellt einen Erfahrungsbericht über die eingesetzten J2EE-Softwarekomponenten, Probleme und Herausforderungen im Zusammenspiel ApplicationServer / Java / Host dar.

Many software architects are confronted with the same situation in their respective companies. Three different groups in the companies complain about the inefficiency of software architecture. Managers: "We were told that software architecture would improve our software development efficiency and would lower the costs of our IT group. Currently, we are confronted with delayed projects. What has gone wrong?"

Project managers: "We need more ressources than allocated. If we plan our designs according to architecture we need more skills, we have to re-design existing software."

Software architects: "We are always forced to agree to sub-optimal solutions because the project managers will play the deadline of the project as the ultimate trump card."

Very often those statements result from one reason: software architecture has just been introduced. The software architects concerned are enterprise architects. While the project architect may concentrate on one project the enterprise architect must observe all projects in the company.

Various writers depict the architectural process as a series of necessary steps to achieve a proper architectural design. A proper architectural design identifies business needs and establishes an application portfolio composed of flexible and reusable components with the the goal to grant low total costs of ownership (TCO) of the total application portfolio. The guidelines for enterprise architects describe how they should conceive, plan and enact "sound architectures".

Such depictions of the architectural process tends to overlook that, if software development is to be guided by software architecture, an organizational unit must be introduced dedicated to this goal and new business processes must be implemented that exploit the advantages that software architecture can grant.

The introduction of a new organizational unit and the introduction of new business processes - or the change of existing ones - require the management of change. This paper shall not prescribe a necessary change management process. It hopes rather to convince of the need for change management and explain the undiscovered role of architecture as the research and development department of a software producing company.

DaimlerChrysler's Proactive Infrastructure (PAI) provides an enterprise wide framework for developing and running web based applications. Operational aspects are also focused by this solution.

Experiences from deploying and operating PAI based applications in test centers and production datacenters are shown in this presentation. The author gives a short overview about the PAI solution for integrating manual installations, node based installation scripts up to Provisioning systems. The presentation also shows some open topics regarding the current modeling capabilities in operation areas.

Today mergers of larger financial institutions are quite common place. You often find conglomerates that stem from a sequence of merger & acquisition activities. In each such case, IT management is confronted with more than one set of applications, often more than one IT service organization and the question is how to deal with such a situation. Typically management likes to reduce cost by migrating to just one application landscape and one IT service organization. This article describes a few observations and patterns how these challenges can be dealt with.

IT-Projekte stellen eine besondere Herausforderung an die Projektarbeit dar. Die Standish Group berichtet regelmäßig über einen bedenklich hohen Anteil gescheiterter Projekte oder von erheblichen Zeit- und Budgetüberschreitungen, von einem hohen Maß an von Unzufriedenheit über gelieferte Funktionalität. Dieser Art von Abschluss-Konflikten gehen oftmals Konflikte im Projektverlauf voraus. Sie trüben das Verhältnis zum Kunden und beeinträchtigen die Projektdurchführung, vor allem wenn sie innerhalb des ausführenden Unternehmens auftreten. Der finanzielle und der Schaden an Ansehen ist häufig beträchtlich.

In IT-Projekten arbeiten eine Vielzahl verschiedener Menschen in unterschiedlichen Rollen zusammen, etwa Projektleiter, Anwender, Entwickler, Vertreter von IT-Fachabteilungen, Kaufleute, Subunternehmer. Neben diesem zufälligen Zusammenkommen von Individuen liegt hier ein Konfliktpotential insbesondere in den verschiedenen Sichtweisen und Voraussetzungen bei jedem einzelnen: technisch, organisatorisch, finanziell, funktional. Das Gebiet IT selber ist hoch innovativ, nicht nur hinsichtlich Technologie sondern auch in bezug auf die Vorgehensweisen. Oft beeinflussen die Projekte komplexe Prozesse beim Kundenunternehmen. Deshalb ist überdurchschnittlich viel Abstimmung und Kommunikation erforderlich. Knappe Budget- und Zeitvorgaben sowie unscharfe Beschreibungen des zu erzielenden Ergebnisses erzeugen Spannungen und stellen weiteres Konfliktpotential dar.

Mediation ist ein Verfahren zur Konfliktlösung, dass in den USA seit etwa 30 Jahren etabliert ist und in Deutschland immer mehr geschätzt wird. Ihr Anwendungsgebiet reicht von Scheidungsmediation über gerichtliche Streitfälle, Wirtschaftsmediation bis hin zu innerbetrieblicher Konfliktlösung. In der Mediation ist der Mediator als neutraler Dritter für die Struktur des Verfahrens zuständig. Im Gegensatz zur Schlichtung oder zum Schiedsgericht schlägt er keine Entscheidung vor. Er hilft den Parteien selbstverantwortlich eine Lösung zu finden. Die wesentliche Methode dabei ist das Herausarbeiten von eigentlichen Interessen, die hinter den Streitpositionen liegen. In der Regel werden tragfähige und zukunftsorientierte Einigungen erzielt, die für alle Beteiligte von hohem Wert sind.

In dem Vortrag wird die Mediation unter dem Gesichtspunkt ihrer Einsatzmöglichkeiten in IT-Projekten vorgestellt. Reine Mediation in IT-Projekten wird kritisch beleuchtet, da die Voraussetzungen nicht ohne weiteres zu erfüllen sind, wie etwa die formale Neutralität des Mediators. Es zeigt sich aber, dass Mediation ein großes Spektrum an Mitteln bietet, die prophylaktisch und projektbegleitend gewinnbringend eingebracht werden können. Dazu gehören nicht nur Techniken (z.B. Gesprächsführung), sondern auch theoretisches Wissen z.B. Eskalationstheorie). Letztlich kann Mediation auch Veränderungen in der inneren Haltung der Projektteilnehmer bewirken, ausgelöst durch erfolgreiche Kommunikation mit anderen Menschen.

Das Open Source Eclipse Plugin JSR220-ORM unterstützt sowohl das Persistenz API der Gegenwart, nämlich die aktuelle JDO Spezifikation (JSR243), als auch das zukünftige EJB 3.0 Persistenz API. Der Vortrag informiert Sie über aktuelle und künftige Entwicklungen dieser beiden Standards. Ein praktisches Beispiel demonstriert die Handhabung und zeigt den aktuellen Stand des Plugins. Das Beispiel zeigt auch, wie Sie Ihr Projekt schon heute auf die Technologie von morgen vorbereiten.

Für viele Unternehmen ist der stringente Architekturschwenk in Richtung SOA heute noch nicht realistisch vorstellbar, da eine prozessorientierte Software-Architektur eine grundlegende Umwälzung der heute funktional und datenzentriert ausgerichteten Software-Systeme verursachen würde.
Daher nähern sich viele Unternehmen SOA, indem sie quasi Bottum Up vorgehen und die Implementierung von Web Services vornehmen. So entstehen Services, die dann als wieder verwendbare Bausteine für spätere Applikationen dienen sollen.
Gerade im Umfeld von Systemintegrationen bieten die Web Services Technologien eine offene, häufig weniger komplexe, effizientere und zukunftsweisende Alternative zu EAI-Systemen.
In einem Bericht aus der Praxis zeigen wir, dass Web Services ein probates Mittel darstellen, um Systemgrenzen (in diesem aktuellen Fall Portalgrenzen) zu überwinden und so Systeme unterschiedlichster Technologien intelligent miteinander zu verbinden. Ein positiver Nebeneffekt der so eingesetzten Web Services ist die automatisch vorhandene Kommunikations- und Verhandlungsbasis für die involvierten Dienstleister, um die Service Level und gegenseitigen Kompetenzen und Pflichten objektiv abzugrenzen.

Calculating metrics is mostly restricted in terms of extensibility and adaptability. The need for consistent source code representation, which can be queried easily, increases due to varying requirements.

In order to show advantages of XQuery usage, taking an XML database containing a bytecode analysis representation as an example illustrates the potential in respect to metric calculation. Flexible and easy access to stored data allows complex and extensive analyses of your source code - exemplification follows.

The realization related to practice is a set of Eclipse plugins for calculation and visualisation of software metrics and is meant to be a generic basis for extensions. Adding new metrics without difficulty is the primary objective. At the same time the application allows to choose from various visualisations to improve the interpretation.

Extensibility and practical benefits of each module are shown by way of example. Reporting, personal adaptation and exhausting integration in the Eclipse development environment are worth mentioning, but not limited to.

Seit dem Beginn der Verarbeitung von XML-Daten erfreuen sich bekannte APIs wie SAX und DOM großer Beliebtheit. Beide Modelle haben sich stetig eiterentwickelt, sowohl in Form neuer Versionen, wie etwa SAX 2, oder in abgewandelten Ausprägungen, etwa JDOM.

Daneben sind aber auch völlig neue Verarbeitungsmodelle samt jeweils entsprechendem API entstanden, die Vorteile von SAX und DOM kombinieren und weitere Vorteile einbringen. Der Vortrag stellt die wichtigsten Modelle und APIs sowohl aus der Java- als auch aus der .Net-Welt vor.

Within many companies, use of service-oriented architectures has developed to a state of the art concept. In this paper, the intention is to discuss the main aspects of developing service-oriented architecture to match business needs, on the basis of a process which has been well-proven in many projects, from the business strategy through to the definition of services. Fitting the business expectations to an architectural development without ignoring the technical constraints is the essence of this process.

The topics addressed in the paper are "Service specification & composition", "Architecture-centric development" and "Component-based approaches".

Die rasante Entwicklung und Verbreitung der Web Service Technologien führt dazu, dass die Marktteilnehmer Web Services außerhalb gefestigter Geschäftsbeziehungen kommerziell anbieten bzw. nachfragen wollen. Für die Auswahl polypoler, substituierbarer Dienste im Sinne von Web Services müssen Verzeichnisse geschaffen werden, in denen die Web Services gesucht, gefunden und spezifische, nutzungsrelevante Informationen sofort abgerufen werden können. An bestehenden Standards bietet sich hier UDDI an. Im Vergleich zu den etablierten Web Service Technologien, etwa XML, SOAP, WSDL fehlt es UDDI an praktischer Akzeptanz. Es existieren faktisch keine öffentlichen UDDI Knoten, die eine Datenqualität sicherstellen, mit der man dynamische Such- und Bindungsoperationen zur Laufzeit ausführen könnte. Das verwundert insofern nicht, dass es für UDDI Knotenbetreiber keine ökonomische Motivation gibt, für eine hohe Datenqualität ihres angebotenen Verzeichnisknotens zu sorgen. Hier könnte ein ECommerce orientiertes Geschäftsmodell helfen, das es hochgradig spezialisierten Firmen ermöglicht, domänenspezifische UDDI Verzeichnisknoten profitorientiert zu betreiben.

Aspect-oriented languages provide means to superimpose aspectual behavior on a given set of join points. It is possible that not just a single, but several units of aspectual behavior need to be superimposed on the same join point.
Aspects that specify the superimposition of these units are said to "share" the same join point. Such shared join points may give rise to issues such as etermining the exact execution order and the dependencies among the aspects. In this paper, we present a detailed analysis of the problem, and identify a set of requirements upon mechanisms for composing aspects at shared join points. To address the identified issues, we propose a general and declarative model for defining constraints upon the possible compositions of aspects at a shared join point. Finally, by using an extended notion of join points, we show how concrete aspect-oriented programming languages, particularly AspectJ and Compose*, can adopt the proposed model.

Complex software systems, like operating systems and middleware, have to cope with a broad range of requirements as well as strict resource constraints.
Family-based software development is a promising approach to develop application-specific systems from reusable components. However, once statically configured, these systems still need to adapt at runtime according to the dynamics of the environment. The majority of the concerns in the complex systems, that need to be adaptable, are crosscutting. With the application of Aspect-oriented Programming (AOP), these concerns can be cleanly encapsulated, and then dynamic AOP can be applied for the adaptations to be contained, and applied at runtime. An efficient dynamic aspect weaver is needed for the dynamic weaving and unweaving of these crosscutting concerns into the system.
None of the currently available dynamic weaver can be optimized according to specific application requirements. In this paper we present the family-based dynamic weaver framework that supports the static as well as dynamic weaving and unweaving of the aspects to the components. By applying the program family concept, the system itself as well as the dynamic weaver, built on top of it, is tailored down to provide only the features or services required by any particular application.

Current compilers for aspect-oriented programs are rather costly in terms of memory and time consumed at compile-time. This is because member accesses that are advised by aspects, generally, occur several times in the program code. These sites are in complex methods whose control flows must be updated when weaving advice. In this paper we present a new weaving technique that introduces indirections into the program code which makes weaving advice easier. We will show that the time and memory consumption at compile-time benefits from this approach and still the loss of runtime-performance is acceptable as the introduced indirections are optimized away by the execution environment.

Local functions provided by classical procedural programming languages are a useful concept for structuring and decomposing large functions into smaller and more comprehensible pieces. This is even more useful if local functions can be passed as parameters to other functions. On the other hand, this creates the problem of dangling function references, i. e., references to local functions whose enclosing function has terminated. To solve this problem, local virtual functions are presented as a restricted form of local functions which do not constitute functions in their own right, but are merely temporary redefinitions of already existing global functions. As such, local virtual functions turn out to be a straightforward generalization of global virtual functions proposed earlier by the author. After introducing the basic concepts, different applications are described which demonstrate its usefulness. In particular, exception handling with the possibility of resumption becomes possible, even in a language without an exception handling mechanism. Furthermore, the basic ideas to implement local virtual functions by means of a precompiler for C++ are explained.

The world of programming has been conquered by the procedure call mechanism, including object-oriented method invocation which is a procedure call in context of an object. This paper presents an alternative, method mixin invocations, that is optimized for flexible creation of composite behavior, where traditional invocation is optimized for as-is reuse of existing behavior. Tight coupling reduces flexibility, and traditional invocation tightly couples transfer of information and transfer of control. Method mixins decouple these two kinds of transfer, thereby opening the doors for new kinds of abstraction and reuse. Method mixins use shared name spaces to transfer information between caller and callee, as opposed to traditional invocation which uses parameters and returned results. This relieves the caller from dependencies on the callee, and it allows direct transfer of information further down the call stack, e.g., to a callee's callee. The mechanism has been implemented in the programming language gbeta. Variants of the mechanism could be added to almost any imperative programming language.

Security concerns are one of the predominant concerns for the development of web applications - applications that are written in a certain architectural context like J2EE. However, the crosscutting nature of security implementations in such enterprise frameworks is hardly studied. Furthermore, the impact of using aspect-oriented techniques in order to implement security relevant concerns in a J2EE architecture is hardly studied. Consequently, developers cannot decide upfront whether or not the application of aspect-oriented techniques for implementing security concerns has a significant positive impact on the resulting application. This paper studies the impact of implementing security relevant concerns in a J2EE context via a case study. Security concerns for a given base application are implemented in a pure J2EE style as well as in an aspect-oriented style using AspectJ. Both approaches are compared and assessed in respect to the necessary changes in the base application.

Dynamic AOP has been identified as a useful technique to implement an auto-adaptive framework. To supplement this policies based upon Event-Condition-Action rules are used to specify when adaptations should be applied to the underlying system. However, for use in auto-adaptive systems it is advantageous if these policies allow certain relationship information to be specified to ensure the system never encounters undesirable interactions and adaptations are applied in a correct manner. This paper highlights the need for these relationships by giving a series of examples followed by a proposed solution to these problems.

This paper presents a portable framework to profile memory allocation in standard Java Virtual Machines. We extended our exact profiler JP, which generates a method call tree (MCT) for each thread in the system, in order to store information concerning object allocation in the MCT. Our primary design goals were to use platform-independent metrics for memory allocation and to minimize the extra overhead caused by memory profiling. For each method invocation context, the profiler preserves the number of allocated objects of each type. We exploit the fact that an object allocation is usually followed by a constructor invocation, in order to compute the number of object allocations from the MCT. A static analysis of constructor code allows to distinguish between the invocation of an alternate or superclass constructor and object allocation within the constructor. Arrays are treated specially, as we instrument array allocation instructions in order to preserve accumulated information on the type, number, and size of allocated arrays for each method invocation context. A performance evaluation shows that the extra overhead due to memory profiling is small.

On the one hand, traits are a powerful way of structuring classes. Traits support the reuse of method collections over several classes. However, traits cannot be used when specifying unanticipated changes to an application. On the other hand, classboxes are a new module system that supports the local redefinition of classes: a collection of classes can be locally extended with variables and/or methods and the existing clients do not get impacted by changes. However, an extension applied to a class by a classbox cannot be reused for other classes. This paper describes how combining Traits and Classboxes supports the safe introduction of crosscutting collaborations: safe because the existing clients of the classes do not get impacted, crosscutting because collaborations between several classes can be put in place in a unanticipated manner. In the resulting system, a collaboration is represented by a classbox and a role by a trait.

Traditionally in aspect-oriented languages, pointcut designators select joinpoints of a program based on lexical information such as explicit names of program elements. However, this reduces the adaptability of software, since it involves too much information that is hard-coded, and often implementation-specific. We claim that this problem can be reduced by referring to program units through their design intentions. Design intention is represented by annotated design information, which describes for example the behavior of a program element or its intended meaning. In this paper, we analyze four techniques that are regularly used in state-of-the-art object-oriented languages in associating design information with program elements. Also, the usage of design information in the weaving process of aspect-oriented languages is illustrated and their deficiencies are outlined. Accordingly, we formulate requirements for the proper application of design information in aspect-oriented programming. We discuss how to use design information for the superimposition of aspects, and how to apply superimposition to bind design information to program elements. To achieve this, we propose language abstractions that support semantic composition: the ability to compose aspects with the elements of the base program that incorporate certain design information. Based on this proposal, we show how the aspect-oriented language Compose* can be extended to support design information. We demonstrate the application of design information to improve the reusability of aspects. The paper ends with related works, a discussion, and conclusions.

Integration projects involve expert groups with different backgrounds and skills. Coordination mechanisms that manage the close collaborative work are given through the concepts of procedure models. An effective use of procedure models requires tool support that covers easy-to-use documentation aspects as well as sophisticated run time support for the complete development life cycle. Therefore we introduce a multi-layer tool architecture capable of supporting all stages of the application of procedure models. In particular we focus on the transformation of models between different abstraction layers. The practicability of our approach is discussed on the base of a prototypical implementation of its tool components.

Semantic Web is an often used buzzword in the field of distributed systems. The Adaptive Service Grid (ASG) project is an Integrated Project supported by the Sixth Framework Programme of the European Commission that has the goal to facilitate the discovery, creation, composition, and enactment of semantic specified services. One task within this project is the development of mechanisms for the dynamic creation of services and the enrolment in the ASG registry. The discovery of services in the registry is only possible with a unified description of these services. Such a Semantic Service Specification is the basis for the composition of services to application service processes. This paper in-troduces in the fundamentals of Semantic Service Specifications like ontology and service description language and suggests a design for such a specification. It will also describe services in the context of ASG. Furthermore, it will illus-trate one possible way to automatically create a Semantic Service Specification of a concrete example. Additionally it describes the rules for transformations between input data and Semantic Service Specification. At the end of this paper the planned of creation of a generator for automated generation of Semantic Service Specification will be explained.

Real world commerce is largely built on agreements specifying the mutual responsibilities of service providers and their customers with respect to functional and non-functional parameters. Although considered to be an enabler technology for a successful commercialization of heterogeneous service grid environments, service level agreements have not fully established themselves yet. The paper at hand gives a first insight into the author's research of creating precise, resource-specific, composite service level agreements in heterogeneous service grid environments using modelling and generative mechanisms for contract composition. After describing the problem domain and spotting the lack of solutions in this area, the scientific challenge and the author's area of interest are identified to motivate further research. Briefly the steps that are necessary to solve the addressed problem are explained and point to concepts and mechanisms that will need to be analyzed and evaluated for further application in the course of problem solving.

Together with the enormous growth of Web services popularity and their emergence on the e-market, there appears a problem of comparison and competition between them. The latter can be possible only when the proper description of services is available. Such a description should consist of both functional and non-functional parameters, so that it would allow not only for comparison but also for automatic selection and discovery of services. The main goal of the article is to provide a survey of quality of services description efforts. It is also a starting point for discussion on research results achieved during the course of the Adaptive Services Grid project.

Adaptive Services Grid (ASG) is an Integrated Project supported by the Sixth Framework of the European Commission that has the goal to facilitate the discovery, creation, composition, and enactment of semantic specified services. This paper presents the ASG context of service creation and suggests a process that could be used in order to generate services on-demand. Since the creation process was designed bearing in mind a number of state-of-the-art software engineering paradigms and software architecture approaches such as component based software development, domain-specific languages, software product lines, model driven development etc., those paradigms and approaches are introduced and explained briefly. On this basis the service creation process as a combination of those paradigms and approaches is derived and explained.

The introduction of a new business process is expensive and risky and immediately impacts the operation of the entire enterprise. Similarly, any business process changes, whatever small, also have an immediate impact on the company. Therefore, performance characteristics of the newly introduced (or changed) process have to be assessed well before process deployment and integration. The ability to do early performance assessment, already at design time, would also allow for educated decision making during selection of vendor and/or provider of Web Services, which is crucial for successful process functioning. An approach for measuring QoS-related parameters of a business process using a partly-emulated execution environment is proposed. The business processes can be modeled and executed using various BP-frameworks, the environment is modeled using a UML-based formal modeling language and generated utilizing Siemens IPPR technology. The measures are obtained from real enterprise infrastructure maintaining safety and integrity of production systems by using generated substitutes of critical services.

Performance prediction of SOA based systems and service grids is an important issue, since in a SOA-based architecture performace-critical interaction is necessary. The idea of predicting thoses systems with performance modelling, where most parts of these approaches are based on system's formal models, is not new. For example such performance models are prototypes that are generated from architecture-relevant information as described in deployment and others diagrams [1,2]. But the idea of constructing a performance model of a system from live performance measurements by now has not been broadly investigated. The point of this model is that it incorporates hidden resource-based service dependencies. These resource dependencies are discovered on stage of performance measurements analysis. This model is very useful for performance prediction and analysis of the production systems, when frequent and extensive performance tests are not possible. Further it allows for obtaining performance measurements of user scenarios which have not been tested explicitly, as well as combinations of such scenarios with different workload.

Research on Component-Oriented Business Applications has focussed on Specifications of Components and Component Markets. Another approach based on Mass Customization and Software Product Lines is presented here. Mass Customization is a strategic concept used in many industries to offer products that are customer-individual, but based on a limited number of building blocks. Thus, customer value is maximized while developing the systems is still economical. Software Product Lines are a promising approach to allow the adoption of Mass Customization for Software in general and Business Applications in particular. Unfortunately, existing literature on Software Product Lines largely ignores the importance of strategic decisions on the product portfolio. Quality Function Deployment (QFD) is a well-known and successfully used Quality Management method that can help companies identify true customer needs and the features needed to fulfil these needs. This paper demonstrates how QFD can be used for Product Portfolio Planning, thus offering potentially great benefits.

Global Software Development (GSD) is a reality but still faces a lot of challenges to give solutions to problems related to software processes themselves, and problems raised by geographical dispersion. Focusing on the latter, we are interested in building a supporting software development environment to integrate processes and tools. This paper introduces Eleggua, an infrastructure for application cooperation with a central focus on low coupling and loose integration of applications. Eleggua is based on distributed events and Web Services for communication. It also uses Event Condition Action (ECA) rules to describe application cooperation models. The goal of application cooperation is to ensure consistency and integrity of overlapping domain concepts embedded in applications that interact throughout the enactment of business processes. The main restrictions on the design are imposed by the existence of heterogeneous, distributed, legacy systems which are too expensive to modify.
Eleggua is being validated in the context of a GSD project focused on improving processes of a software house that faces the challenges of geographical dispersion.

During recent years, the World Wide Web (WWW, Web) has increasingly been used as a platform for applications that link together processes both between and across organizations. Acting as distributed components, Web Services provide a standardized way of externalizing functionality on a global scale and as such enable accesses that transcend organizational boundaries to form federated applications. The design and evolution of these federated applications is now imposing new obligations for the disciplined engineering of composed Web solutions. To meet these obligations, we extend the WebComposition idea, which is an approach to apply component-based software development concepts on Web applications. This extension facilitates modeling the complex landscape of the components and services building the federated applications.

In this context, we introduce the WebComposition Architecture Model that serves as a map to keep track of the interrelations between the federated partners in terms of the involved Web-technology. Among the modeled artifacts are Web services, Web Applications and organizational zones of control that are all subject to evolution in the sense of the WebComposition approach.

The deployment of business components in large enterprise information systems offers great potential. Nonetheless the process of finding and defining the right business components is very challenging. While the definition of business components is comparatively simple for small business domains, it becomes very complex for larger domains of interest. This paper illustrates the experiences made during the modeling process of an integrated information system architecture for Customer Relation Management (CRM) and Supply Chain Management (SCM) with more than 500 functions and 1000 information objects under usage of the Business Component Identification (BCI)-Method. Based on this experience possible enhancements and needed extensions for the BCI-Method are proposed and explained.

Compositional plug-and-play-like reuse of black-box components requires sophisticated techniques to specify the components. One current problem in specifying behavioral aspects comes from the fact that editing OCL constraints manually is time consuming and error-prone. To simplify constraint definition we propose to use specification patterns for which OCL constraints can be generated automatically. As a first step we identify a list of patterns that frequently occur in behavioral specifications. These patterns are described in detail using a special description scheme and specification examples.

Component-based development (CBD) is an effective paradigm for building software systems with reusable assets, where components often come in black-box form and expose interfaces while hiding internal details. Components are reused in developing various applications in a domain. However, the behavior provided by a component may not exactly match to the specification of an expected component. This is called a partial matching problem. Therefore, they have to be adapted for specific requirement. A component can be adapted in two ways; internal and external adaptation. For internal adaptation, the mismatch between a candidate component and the specification of an expected component can be resolved by some customization mechanism. However, if the component does not provide adequate customizability, it has to be adapted externally by using some external adaptation mechanism such as smart connector [1]. In this paper, we first propose a taxonomy for various mismatches during component acquisition. Then, we define a systematic process and practical instructions for identifying mismatches and adapting components.

For software reuse to be successful, a repository for storing and retrieving reusable components is essential. The traditional component repositories almost adopt Client/Server mode and offer a centralized authority on reusable components stored. However, such C/S-based repositories suffer from several limitations. This paper presents the design and implementation of an original P2P-based reusable component repository system called PeeRCR that enables the sharing of reusable component in a large distributed environment. We build the PeeRCR system using peer-to-peer distributed hash table protocol. The PeeRCR uses two kinds of index dictionaries (Local Dictionary and DHT-based Peer Dictionary respectively) together to assist in processing reusable component queries. We also implement a number of alternative scheme repositories to evaluate the performance of the PeeRCR. The experimental results demonstrate the feasibility and effectiveness of the PeeRCR for sharing reusable components in a large distributed and dynamic environment.

In this paper, we propose a unified approach based on visual notations for describing dynamic component-based software architectures. Our approach allows describing the static, the dynamic and the behavioural aspects as well as the architectural constraints to be respected during the architecture evolution. We specify, using UML2.0, the static aspect of a software architecture in accordance with an architectural style, the dynamic aspect using the graph transformation rules, and the behavioural aspect based on UML2.0 notation. These specifications are defined according to the proposed notation integrating UML2.0 and OCL language. Indeed, all constraints, all functional and some structural actions can be expressed using the OCL language. These three aspects offer to the architects an initiative and complete way to specify the software architecture.

There is a dilemma between, on the one hand, easily and straightforwardly acquiring and integrating external, prefabricated, cost-effective, plug & play components and, on the other hand, the strong need for assessing and possibly accepting these components so that their incorporation into in-house products is not the source of any damage. This paper supplies some technical leads based on the concomitant and coherent use of the Unified Modeling Language (UML) and the programming mechanism of reflection. As an illustration, a concrete approach developed with the Component+ project is described. This approach relies on the Built-In Test (BIT) technology that aims to guide COTS component design that facilitates qualification.

In grid workflow systems, to verify fixed-time constraints efficiently at the run-time execution stage, some checkpoints are often selected so that we only need to conduct the fixed-time constraint verification at such checkpoints rather than at all activity points. However, the existing typical checkpoint selection strategies are inefficient and/or ineffective because they may incur some unnecessary verification by selecting some un