This presentation starts with examination of research into software project failure, project failure
in other domains, and inappropriateness of sequential lifecycles. It explores the key ideas in
iterative lifecycle and agile development processes, and their expression in the Unified Process,
Extreme Programming, DSDM, and Scrum. It examines agile modeling and the tradeoffs of
formality and specificity in modeling, versus rapid programming. The presentation concludes
with suggestions for high-impact visual modeling techniques.

Several alternatives to manage large XML document collections exist,ranging from file systems over relational or other database systems to specifically tailored XML base management systems.
In this talk we give a tour of Natix, a database management system
designed from scratch for storing and processing XML data.
Contrary to the common belief that management of XML data is just another application for traditional databases like relational systems, we illustrate how almost every component in a database system is affected in terms of adequacy and performance.
We show how to design and optimize areas such as storage, transaction management comprising recovery and multi-user synchronization as well as query processing for XML.

Thread synchronization in Java using synchronized methods or statements is simple and straightforward as long as mutual exclusion of threads is sufficient for an application. Things become less straightforward when wait() and notify() have to be employed to realize more flexible synchronization schemes. Using two well-known examples, the bounded buffer and the readers and writers problem, the snares and traps of hand-coded synchronization code and its entanglement with the actual application code are illustrated. Following that, interaction expressions are introduced as a completely different approach where synchronization problems are solved in a declarative way by simply specifying permissible execution sequences of methods. Their integration into the Java programming language using a simple pre-compiler and the basic ideas to enforce the synchronization con-straints specified that way are described.

AspectS is an approach to general-purpose aspect-oriented programming in the Squeak/Smalltalk environment. Based on concepts of AspectJ it extends the Smalltalk MOP to accommodate the aspect modularity mechanism. In contrast to systems like AspectJ, weaving and unweaving in AspectS happens dynamically at runtime, on-demand, employing metaobject composition. Instead of introducing new language constructs, AspectS utilizes the expressiveness of Smalltalk itself as a pointcut language.

Java applications are composed of classes which are usually grouped and deployed using Java Archives. When an application is started, the hosting Java Virtual Machine (JVM) gets the required classes one by one as they are needed from these archives. For this purpose, the JVM locates the related byte code taking the names of the class and its package and evaluating the environment setting CLASSPATH. This is well-suited as long as there is only one byte code matching the given class name. However, this procedure is not feasible when the byte code has to be selected among others related to the same class name using properties such as version numbers or manufacturer. In this paper, we introduce so called Java Class Collections which enable the logical grouping of classes separately from their physical deployment within Java Archives and allow tagging them with supplementary properties used to select the right byte code. Finally, we illustrate the application of the approach for multi-application hosting and in remotely composable application systems.

Software development organizations are often deterred from introducing product line architectures by the lack of simple, ready-to-use methods for developing and applying them. The well-known, published product-line-engineering methods tend to focus on the early stages of the software life cycle and address product line issues at a high-level of abstraction. Connecting product-line concepts with established implementation technologies is thus largely left to the user. This paper introduces a method, known as the KobrA method, which addresses this problem by enabling product line concerns to be coupled with regular (non-product line) architectural artifacts, and thus introduced incrementally. By explaining how the method can be understood as a concrete instantiation of the well-established PuLSEDSSA product-line architecture approach, the paper clarifies the product line features of the KobrA method and illustrates how they can be used in tandem with established, general-purpose product line methods.

Financial institutions are increasingly using XML as a de-facto standard to represent and exchange information about their products and services. Their aim is to process transactions quickly, cost-effectively, and with minimal human intervention. Due to the nature of the financial industry, inconsistencies inevitably appear throughout the lifetime of a financial transaction and their resolution introduces cost and time overheads. We give an overview of requirements for inconsistency detection in our particular domain of interest: the over-the-counter (OTC) financial derivatives sector. We propose a taxonomy for the classes of consistency constraints that occur in this domain and present how xlinkit, a generic technology for managing the consistency of distributed documents, can be used to specify consistency constraints and detect transaction inconsistencies. We present the result of an evaluation where xlinkit has been used to specify the evaluation rules for version 1.0 of the Financial Products Markup Language (FpML). The results of that evaluation were so encouraging that they have led the FpML Steering Committee to consider xlinkit as the standard for specifying validation constraints throughout.

Mobile systems are gaining more and more importance, nevertheless the means for their speci_cations are still underdeveloped. Existing UML diagrams can be used to conveniently model behavior, but these diagrams can be hardly used to model mobility. In this paper we present an extension to UML class and activity diagrams to model mobile systems. We assume that mobile objects can migrate from one location to another. Locations can be nested and mobile too.We introduce stereotypes to model mobile objects, locations, and activities like moving or cloning. We introduce two notational variants of activity diagrams for modeling mobility. One variant is location centered and focuses on the topology of locations. The other one focuses on the actor responsible for an activity. We compare these two types of diagrams and define a metamodel for them.

The huge amount of recent activities in peer-to-peer (P2P) computing led to the development of a number of applications and protocols all dealing with similar problems providing different non interoperable implementations. In this paper, we present a framework for resource management and information storage in P2P networks. Our framework aims at providing an easy to use and flexible model for P2P computing encouraging more modularised application development and permitting reuse of components. Efficient localization of resource and representation of information are central needs of P2P applications. To address this need our resource management framework (RMF) forms a distributed in-formation space enabling not only at storage of information but forming graph structures that can be used to build new kinds of applications enabling the users to browse the contents of a P2P network.

An argument pro component-based software development is the idea of constructing software systems by assembling pre-existing components instead of re-developing similar or identical functionality always from the scratch. Unfortunately, integrating existing components practically means reuse (i.e., adaptation and use) rather than use only, which makes a clean, ideal component-based development hard to realize in practice. Product line engineering, however, is an approach that tackles this problem by making components systematically as generic as needed for a particular product family and thus allows components to be reused easily within a family context. Making a component generic means a component covers variabilities among systems in the family and thus that its implementation must consider variabilities. In this paper, we describe a process for implementing generic product line components and give an overview of variability mechanisms at the implementation level. The proc-ess, as well as the described variability mechanisms, is illustrated by a running example, a generic test compo-nent.

Zielsetzung des Beitrags ist die Definition eines generischen Protokolls für bilaterale, multiattributive Verhandlungen auf der Grundlage von ebXML. Der zwischenbetriebliche Ablauf bilateraler Verhandlungen wird unter Einsatz des Business Process Specification Schema (BPSS) modelliert. Eingesetzt werden hierzu UML-Diagramme. Im Rahmen der Analyse prüfen wir auch die Eignung von ebXML zur Abbildung komplexer Kollabo-rationen. Vorliegende ebXMLProzessmodelle zu diesem Thema fließen in das Konzept mit ein und werden kri-tisch untersucht. Über die Spezifikation der Abläufe hinaus wird die Struktur der auszutauschenden Daten analy-siert und die entsprechenden Klassendiagramme werden erstellt.

Middleware has become an important part in business applications. Different middleware platforms require different software designs. Even version changes of the used platform often lead to complex re-designs of software. Furthermore, complex business and platform-specific knowledge is required, to translate abstract busi-ness models to platform specific implementations. This paper presents the software design transformation system GREAT in the context of business applications and the Model Driven Architecture (MDA) proposed by the Object Management Group (OMG). It shows, how graph transformations can be used to transform abstract design mod-els into platform specific ones.

Whenever object-oriented applications that use the Enterprise JavaBeans (EJB) environment have to store data in a database, there is a need to combine EJBs with access to persistent data. The current use of entity beans for persistent data storage has a number of weaknesses. Component level inheritance and dynamic querying are not supported appropriately, and the whole approach seems to be overweight. In order to overcome these weaknesses, we implemented a JCA-compliant resource adapter, which enables the use of Java Data Objects (JDO) instead of Entity Beans and allows the introducuction of a lightweight, easy to use and powerful transparent persistence layer for the Java 2 Enterprise Environment (J2EE).

The number of inexpensive, microprocessor-equipped devices that provide wireless communication capabilities is steadily increasing while prices for these devices continue to decrease. Most of these devices today rely on some sort of proprietary network protocols which prohibits data exchange between heterogeneous devices. This paper describes the design and prototypical implementation of a simple, lightweight communication infrastructure specifically targeted to devices with limited resources. One of the central ideas of the infrastructure is to encode both remote procedure calls and user interface abstractions in XML format which provides a broad range of interoperability. In addition, we rely on simple, easily implementable software components in order to adapt the architecture to a large variety of small devices without having to resort on proxy technologies or virtual machines in extremely memory-restricted systems.

``Fat software'' significantly reduces the effect of new and faster computer hardware. Such software is only possible due to the impressive success of the hardware developers. The main reason for this trend is the user's demand for new gimmicks driving the software developers to include all possible features into their systems. Those features are all loaded every time the program is executed and make the system bulky. The fact that most add-ons are simply integrated without a clear interface only adds insult to the injury.
This paper shows a way to design software which helps to battle this development of bulky systems. The well-known plug-in concept is formally described as a design pattern. Based on this pattern a development principle is proposed. As a special case, GUI development is treated in more detail.

In this paper, we investigate whether module concepts for capturing multiobject collaborations can effectively be used to implement crosscutting concerns in reusable, independently developed modules for a-posteriori integration into existing systems. To address the shortcomings that we identify, a new kind of collaboration module, called Object Teams, is proposed, which combines the best features of existing approaches, further advances them with concepts for expressing crosscutting relations between independent collaborations, and facilitates a-posteriori integration of such collaborations into existing systems.

Qualifying types represent a new approach to qualifying the behaviour of instances of other types in a general way. This paper illustrates the idea by showing how they can be used to program various standard syn-chronisation problems, including mutual exclusion, reader-writer synchronisation and several variants of the bounded buffer problem.

Refactoring is a corner stone in a number of agile processes like Extreme Programming (XP). Tools for an automatic support are beginning to appear, usually referred to as refactoring browsers. Most of these are ex-tensions to editors or IDEs and operate on code. This paper discusses how the idea of refactoring can be ex-tended to UML models and presents a refactoring browser integrated in a UML modelling tool. Refactorings for the static architecture as well as dynamic behaviour are presented.
Keywords
Refactoring, refactoring browser, development tool, UML

Code repositories play a central role in the reuse and mining of existing assets when engineering large, complex software systems. It is, therefore, essential that database support be extended to new programming paradigms as and when they emerge. This paper proposes an approach to support the storage, reuse and mining of aspects - constructs used in Aspect-Oriented Programming (AOP) to separate crosscutting concerns - in AspectJ (an aspect language for Java) using a relational database. The approach is based on mapping an aspect's anatomy to the relational model hence allowing fine-grained queries to be composed. This results in greater flexibility during search and retrieval in contrast with most existing code repositories which store the code as BLObs comple-mented by meta-data about the code.

In this paper we present a mechanism for serializing the execution-state of a distributed Java application that is programmed by means of an Object Request Broker such as Java RMI. To support capturing and re-establishment of distributed execution-state, we developed a byte code transformer that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of our mechanism is its portability. It can transparently be integrated into any legacy Java application. Furthermore, it does require no modifications to the Java Virtual Machine (JVM) or to the underlying Object Request Broker. Our mechanism can serve many purposes such as migrating execution-state over the network or storing it on disk. In particular, we describe the implementation of a prototype for re-partitioning distributed Java applications at runtime. Proper partitioning of distributed objects over the different machines is critical to the global performance of the distributed application. Methods for partitioning exist, and employ a graph-based model of the application being partitioned. Our mechanism enables then applying these methods at any point in an ongoing distributed computation.

For the Java component model J2EE, Sun has published guidelines which show, how to use their technology effectively to create enterprise applications. These guidelines are illustrated in the two example enterprise application blueprints Pet Store and Smart Ticket. Since we are working on a wireless project in our group, we investigated the Smart Ticket demo application. This paper describes our experiences until we had the application running on a real Java cell phone (Siemens SL45i) and shows weaknesses and bugs in the demo application.

Component-based software development is a potential reuse paradigm or the future. While the required technologies for a component-style system development are widely available, for instance Sun_s Enterprise Java Beans, a problem inhibits the breakthrough of the component paradigm in business application domains: com-pared to traditional engineering disciplines there is a lack of standardized methods to describe business compo-nents. Such a description has to address several aspects: What services are offered and requested by a business component? How can these services be used? Are there any interdependencies between the services of a set of business components? What quality characteristics do the offered services fulfill? And so on. In this paper, we present a holistic approach to specify a business component. This approach consists of seven specification levels which address both technical and business aspects. Furthermore, we show the application of this method by specifying a simple business component that deals with German bank codes.

An eBusiness is one in which major portions of the core business processes are automated. This dependence on technology enables innovative business models, but also demands that supporting software systems are developed alongside careful consideration of the company's future strategy and business models. This paper presents a new approach to semi-automated component-based evolution of eBusiness support systems. The process is automated by linking business strategy with software structure using mappings between business process patterns and software patterns. Identified software patterns are used to guide the procurement of appro-priate components using software "test harnesses". A strategic positioning and planning tool, the eBusiness Ma-turity Model (eBMM) is used for the strategic level input by positioning a company depending on which business processes are automated, and then planning the future extensions of software support to progress up the EBusi-ness maturity levels. We illustrate the use of this model in an eCommerce start-up and show how the model guides the procurement of software components to support mission-critical parts of the business whilst enabling future growth in the marketplace.

Today, software availability as well as adaptability has a strong impact on application development. Together with the success of the Internet technology, it is often necessary to offer a web-based software solution. For Java development, J2EE builds a bridge from traditional towards web application development. With Java Server Pages and Servlets it is possible to implement web sites with dynamic content. Using these techniques, it is possible to apply well-tried programming paradigms, e.g. the Model-View-Controller (MVC) paradigm. With regard to software quality as well as adaptability, unit testing has become more and more important during application development. It provides a powerful technique to develop new functionality as well as to change existing parts. This is also strengthened with success of Agile Processes that force a test-driven development. From there, appli-cation code grows up with unit tests from scratch on.
For Java, JUnit has become the de-facto standard unit test environment that supports a test-driven approach for traditional software development quite good. Nevertheless, web application development requires broadening the unit test approach. Both, the scope of the unit tests as well as the JUnit framework, have to be extended to enable unit tests considering the special requirements of web application development. In this paper, we present an ap-proach to customize the unit test approach as well as the JUnit Framework towards a test-driven web application development.

Various web applications in e-business, such as online price com-parisons, competition monitoring and personalised newsletters require retrieval of distributed information from the Internet. This paper examines the suitability of software toolkits for the extraction of data from websites. The term wrapper is defined and an over-view of presently available toolkits for generating wrap-pers is provided. In order to give a better insight into the workings of such tool-kits, a detailed analysis of a non-commercial software program is presented. An example application using this toolkit demonstrates how acceptable results can be achieved with relative ease. Required but currently unavailable features of the program are listed. The functionality of the program is compared with the functionality of a commercial toolkit and the differences are highlighted. With the aim of providing improved ease-of-use and faster wrapper generation in mind, possible areas of development of such toolkits are discussed.

For incremental iterative software development proc-esses, automated testing is necessary to enable evolution not only in terms of functionality, but in terms of soft-ware quality as well. Automation requires models to provide the necessary information. Scenarios and use cases do not only feed requirements engineering, they may also be the basis for testing. The have to be enriched by detailed behavioral information in order to be used for statistical test case generation.
This paper introduces an approach for generating sys-tem-level test cases based on use case models and refined by state diagrams. These models are transformed into usage models to describe both system behavior and us-age. The method is intended for integration into an iterative software development process model. The resulting test cases are suited to be carried out in conventional ways, i.e., either manually or using test tools. The method is supported by a XML-based tool for model transformation.

This paper introduces ubiquitous healthcare, addressing the access of health services by individual consumers applying to mobile computing devices. This access requires knowledge about the individual health status, which may involve (as far as available) the current personal situation (e.g., accident), relevant recent diseases etc., current symptoms or already available diagnosis. Addressing the related IT challenges _ e.g., patient-centric knowledge processing, situation awareness, local control _ we develop in detail the OnkoNet Mobile Agents Architecture involving architectures on the macrolevel and microlevel as well as cooperation protocols, inference models controlling system behaviour, and a health ontology.

. Lightweight, 'agile' software development methods are not a replacement for traditional, heavyweight methods. But under certain assumptions, they are a welcome alternative in many areas of software development. In this paper, we outline the differences between agile and traditional approaches of software development and examine how development tools are used in the latter. We consider experience from industrial projects as well as results found in the research community. Then we discuss the requirements which agile methods and development processes impose on development tools and show how existing tool technology can be used to build agile tools. These tools allow agile methods to evolve through suitable tool support.

The design of advanced driver assistance systems always aims at enabling the driver to master today’s traffic in a more safe and comfortable way. In order to judge the risks in a situation and initiate precautionary actions, future systems have to possess the capability to predict the behavior of surrounding traffic participants. This paper outlines an approach to predictive situation analysis for driver assistance systems and discusses one key issue in more detail - namely the predictive action recognition. In this context, a situation representation formalism will be introduced that exploits time as a compact physical measure. Furthermore, it will be shown how probabilistic networks can be used for reasoning about driver (action) intentions and how such networks can help to cope with uncertainty resulting from inaccuracy in models and sensor data. First results are shown in simulation for highway overtake scenarios. In the situations presented the prediction for an upcoming lane change can be made by the assessment of the time gaps to the nearest neighbors of that specific vehicle.

The development of real-time systems is traditionally characterised by the usage of a priori design techniques which can guarantee that a set of tasks will meet their deadlines. This development methodology requires that the
application’s task set and the characteristics of each task – execution period,
worst case execution time, etc. – are previously known. Although leading to
proven systems, the adaptability to changes in the system’s architecture is quite low, due to the static nature of the design. In the area of distributed real-time systems, complex applications are arising where the need for adaptation and flexibility can not be ignored. The concept of agent based software development is proposed as suitable to cope with the complexity of such systems, providing intrinsic characteristics of autonomy and self-regulation. As example, an automotive electronic control system is presented, as well as the vision of an agent based approach to the scenario.

To succeed, agents need to become part of legacy and future systems that are not agent oriented. That means agents must be able to run (and migrate) on servers that are not based on multi-agent platforms. Also, agents will have to
be able to communicate using languages and protocols that are not dedicated to
them, such as HTML. Last, agents need to be able to adapt (themselves) to
modifications of their environment. Such features are provided by a family of
agents developed at CRIM, which we call Guest.

In the paper it is assumed that Business Process Reengineering (BPR) is the prerequisite and consequence of new software and Information Technology (IT) solutions implementation. Process reengineering includes process modelling
as well as roles, rules and information modelling. In the paper the main
question is if agent methodologies are BPR-oriented. Analysis includes the current multiagent methodologies like AAII, Gaia, MaSE, Comparative Information
Agent Design, ADEPT project, MAS-CommonKADS, CoMoMAS, DESIRE and Cassiopeia.

The planning process of multiple autonomous agents is influenced by various factors, such as homogeneity/heterogeneity, co-operation/competition,