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,
cardinality, and communication syntax/semantics. Analytical planning approaches
were usually designed for specific domains and therefore are relative domain-depend.
In this work, these difficulties are addressed through a generic algorithmic approach, namely the Co-evolutionary Planning (CEVOP) methodology, which provides a planning mechanism for multiple co-operating and/or competing homogeneous and/or heterogeneous agents through a single co-evolutionary algorithm. CEVOP is rather a framework for mapping the planning problem from the multi-agent domain onto the co-evolutionary algorithm domain, in order to find concrete plans to be executed later by the agents co-operatively and/or competitively.

Collaborative agents are able to find global solutions to complex systems using local knowledge rather than a complete global knowledge set. The complexity, on the other hand, brings uncertainty. Global optimisation in a uncertain environment can be undertaken using fuzzy collaborative agents. Negotiation, involving generating, evaluating and modifying action plans, under fuzzy circumstance is a key to construct fuzzy collaborative agents and fuzzy multi-agent systems. This paper presents an approach of negotiation using fuzzy reasoning, in particular fuzzy backward reasoning. A fuzzy collaborative agent has local knowledge in the form of a fuzzy model. Fuzzy backward reasoning is performed based on the fuzzy model to generate and modify an action plan in each agent.

This paper provides some results and analysis of several negotiation
algorithms. We have used a tournament-based approach to evaluation and
applied this within a community of Buyers and Sellers in a simulated car hire
scenario. An automated negotiation environment has been developed and the
various negotiation algorithms made to compete against each other. In a single
tournament, each algorithm was used as both a Buyer-negotiator and a Sellernegotiator.
Each negotiating algorithm accommodates the parameters for negotiation as a set of desirable goals, represented as examples of product specifications. It was the task of each negotiating algorithm to get the best deal possible from every one of their opposites (i.e. Buyer versus Seller) in the sense of being close to the examples they were given as goals. One algorithm proved to be superior to the others against which it was made to compete.

Agent-oriented technique represents an exciting new means to develop complex software system. The paper presents a novel abstract concept of joint maintenance intention to represent joint constraints of social behaviors in multi-agent system. The joint maintenance intention’s meaning and
characteristics are discussed, the formal and rigorous semantics is defined, and
some important properties are specified and proved. The abstract concept model
and its theoretical results can effectively be used to specify, validate and refine multi-agent system.

The paper attempts to survey the existing research and development efforts involving the use of mobile agents and intelligent agents for advanced
e-commerce solutions. In particular it aims at providing a representative
view of the current research trends in developing intelligent and mobile agentmediated e-commerce including location-aware, mobile and networked comparison-shopping, auction bidding and contract negotiation. A number of selected agent systems are presented with short overviews and then discussed in
the context of agent-mediated e-commerce including the scope and specific solutions they address, provided support for agents’ migration and users’ mobility, and deployment approaches. Finally, a summary of the considered systems is presented together with some concluding remarks including the current state and trends in developing mobile and intelligent agents in advanced agentmediated e-commerce.

This paper introduces a multi-agent system which integrates process planning and
production scheduling, in order to increase the flexibility of manufacturing systems in coping with rapid changes in the market. This system consists of various autonomous agents which have the capability of communicating with each other and making decisions based on its knowledge. An iterative bidding mechanism is proposed to facilitate the process of job assignment to machines and handle the negotiation between agents. This mechanism enables optimum process plans and production schedules to be produced concurrently. A currency
scheme is proposed to encourage or prohibit machine agents to put forward their bids. To deal with the optimisation problem, i.e. to what degree and how the currency values are adjusted in each iteration, a genetic algorithm (GA) approach is developed. This system is implemented in a Java platform. A test case is used and the results will be discussed in this paper.

A model for multi-agent negotiation under time constraints on an agent-based marketplace for personnel acquisition is presented. In the situation under consideration agents have contradictory aims and multi-lateral negotiation is chosen as the most suitable form for agents’ co-ordination.
Negotiation issues and negotiation strategies are discussed first. Then the
general case of multi-lateral negotiation with multiple negotiation issues is
considered. Although the paper deals with the specific situation of an electronic marketplace for personnel acquisition, the proposed negotiation model can be used with appropriate modifications for other agent-based e-marketplaces where agents have contradictory aims and negotiation is required.

A major challenge for today’s manufacturing organizations is how to respond agilely and cost-effectively to dynamic fluctuations of demand patterns across product mix and increasing rates of new products introduction. As traditional process planning and production scheduling operate independently for process plans and production schedules generation respectively, production schedules generation processes become inflexible and is restricted by the pregenerated
process plan. In response to this issue, a multi-agent Monte Carlo configuration and optimization method is proposed to integrate process planning, production scheduling, and resource optimization for concurrent
evaluation of planning and scheduling options. The principle of this
methodology is to integrate agent bidding mechanism and Monte Carlo optimization, in which agents perform iterative interactions to evaluate
production decisions dynamically for an optimum solution determination.

The presentation starts with well known examples of MAS-applications, like homebots in order to balance load of power delivery, the con-cept of SoComs (Sphere of Commitments) to handle contract obligations in a flexible way, multi-agent systems for production control and for supporting supply chain management (SCM), mobile information agents, and policy agents for scheduling in hospitals.
These examples are analyzed with respect to common values of the organizational variables ‘goal orientation’, ‘coordination’ resp. ‘co-operation’, ‘division of labor and allocation of work’, and ‘delegation and responsibility’.
Particularly, depending on the situational variables ‘information availability’,
‘environmental dynamics’ and ‘problem-complexity’ these organizational
variables show typical ranges. Thus, a common framework is established in
order to classify multi-agent systems for their ability to solve business
problems.
In recent decades principal-agent-theory has turned out to be one of the most
prominent theoretical foundations of management science. Applying this theory
to the application of MAS in enterprises, an improved and theoretically guided
understanding of deficits of MAS applications will result. Combining these
insights with the situational variables ‘information availability’,‘environmental dynamics’ and ‘problem-complexity’ most promising research areas for future applications are identified.

In view of strong competitive markets, current companies tend to new methods of production, from a logic of «planning» type of production to a logical of «Just in time » type. In this context, the system that allows controlling the production has to be a modular, flexible and reactive system. The hierarchized and classical approaches don’t permit any more to take into
account the complexity linked to such system. That’s why, we propose an
approach, which has reactive, distributive, and emergent properties to control
the system of production, based on multi-agent system principles. After having
introduced the context and reasoning work, we describe the different parts of
our multi-agent model. Lastly, we illustrate this approach on a practical
example of cell production.

Most of the knowledge management systems of complex organizations are based on technological architectures that are in contradiction with the social processes of knowledge creation. In particular, centralized architectures are adopted to manage a process that is intrinsically distributed. In this paper, assuming a Distributed approach to Knowledge Management (DKM), is proposed that technological and social architectures must be reciprocally consistent.
Moreover, in the domain of Knowledge Management, technological architectures
should be designed in order to support the interplay between two
qualitatively different processes: the autonomous management of knowledge of
individuals and groups - here called Knowledge Nodes (KNs) -, and the coordination required in order to exchange knowledge among them. Finally a peer to peer architecture to support knowledge exchange across distributed and
autonomous KNs is presented.

In this paper, a new domain-based organisational model is proposed as an extension of the traditional role-based models for formal agent society
specification. The concept of social commitment policies, which govern various
aspects of group behaviour, including penalties for individual acts in the context of group activities, is at the heart of this model. The concept of penalty is presented as an important concern in light of the assumption that, even conceived as society members, agents are still autonomous, so they can violate the established social commitments. The different types of social commitment policies are classified, and the interest of their application not only as an organisational abstraction but also as a mechanism for specifying the expected behaviour of the agent society is discussed. It is also shown how deontic, action and temporal (DAT) modal logic will be used in the formal specification of the different types of policies and their related concept of violation. This formalisation will allow agents to reason deliberatively about the existing social norms, the responsibilities proper to their position and the consequences of violating these responsibilities. Finally, attention is paid to the formalisation of policy dynamics by means of illocutionary logic.

In this paper an approach to model conversations and agents decision activities by using state-based models is presented. These models are parts of a layered architecture which separates the aspects regarding the communication from the decision activities of the agents. By this, application independent conversation protocols are defined. The application dependent parts of the model are formed by a sequence of activities an agent has to perform to solve a problem. The different layers of the architecture are separated from each other by well-defined interfaces.

This paper illustrates three typical instances of e-variants, i.e., e-enterprise, e-government and e-health. The conclusion is that the essence of e-variants is the computer technology being embedded and integrated in the tradi-tional business processes.

The Semantic Web will enable systems to communicate intelligently with one another. As this occurs, the nature and extent of human interaction with computers will alter correspondingly. Although the characteristics of interaction cannot be fully anticipated, it is clear that as sy stems gain intelligence and autonomy, the demands placed on them will become more exacting. To meet these expectations, the Semantic Web should incorporate work-centered services. These services will provide focused, intelligent points of contact between the Web and its users. Users will access work-centered services to formulate and conduct investigations, and to collect, organize, and analyze results. Work-centered services will direct tasks in behalf of the user and communicate with the user in a humanly coherent manner. As a result, the concept of the user interface will broaden and deepen to include specialized agents, possessing the expertise to assemble information for end-user consumption. These agents will occupy the web-continuum just as any other knowledge resources.
This paper introduces the concept of work-centered services and describes related research and development being performed as part of the KnoWeb project.

Multi-agent systems have been successfully used in a number of industrial
applications. However, in the domain of industrial automation systems,
little practical experience about the use of agents in such a demanding environment exists. Nowadays automation systems face new challenges and therefore new concepts are needed to meet them. This paper presents a vision of using agents within industrial automation systems from the point of view of automation engineering. To this end, the characteristic structures of automation systems are analyzed and opportunities, as well as advantages, of applying agentoriented concepts are investigated. A possible approach for the integration of a multi-agent system into existing automation systems is introduced and illustrated by an application example.

This paper presents a conceptual hierarchically structured multi-agent architecture for manufacturing systems’ modelling. The architecture provides a suitable decision-making framework where each agent represents a node in the hierarchic tree of manufacturing systems such as the company as a whole, each plant within the company, each cell or line within the plant, each machine in a cell or line. Each agent has the ability to perceive and evaluate changes that occur in the manufacturing environment, interact with other agents in the system in order to reach an optimal decision, and act based on that decision. In other words, agents respond timely to unexpected changes by continuously co-ordinating their activities, and allocating manufacturing resources dynamically based on actual shop-floor situation. The flexibility of this architecture also lies in its ability to accommodate both homogenous and heterogeneous agents, and its capability for the dynamic addition and removal of agents using a conceptual intelligent communication mechanism similar to the blackboard messaging system.

In this paper, we propose an Attitude Based Team Model (ABTM)
in which we argue that team members’ perspective or attitude is a very
important attribute for the performance of a team. Our team model presents
team as a collective abstract attitude, in which is embedded a novel way of
solving problems and conflicts in our domain. We argue that this collective
attitude is further decomposed into the individual attitudes of the agents
towards various team attributes (Team definition, team methods … etc.). We
then evaluate the different types of the agent teams in a simulated fire world
using teams with and without different types of attitudes. The application and
implementation of this model to a virtual fire world has revealed a promising
prospect in developing team agents.

The widespread use of the Internet signals the need for a better understanding
of trust as a basis for secure on-line interaction. In this paper we provide and discuss existing works on trust management models in the area of Multi Agent Systems and highlight the shortcomings. Our proposed model is not presented as the final solution to the issue. This new model will have a
mechanism that allows agents to manage trust not by just one way but a few
combinations of different types of trust in different situations. The proposed
model is concerned with the general notion of trust, one that goes beyond
cryptographic protocols. Findings from this paper can be used for future research work in the area of trust in Multi Agent Systems and to address further
the importance of trust management on the Internet.

E-learning is nowadays recognized as one of the key components of Enterprise Knowledge Management platforms. Given a project specification, the platform should be able to suggest a project team, to measure human resources competence gaps and to contribute to reduce them by creating personalized learning paths. In this paper we propose an XML based Multi-Agent System to perform the following tasks: (i) supporting Chief Learning Officers in defining roles, associated competencies and knowledge level required; (ii) managing skill map of the organization; (iii) measuring human resources competence gaps; (iv) supporting employees in filling their competence gaps as related to their roles; (v) enriching a given courseware or creating personalized learning
paths according to feedbacks user provides in order to optimize the acquisition
of needed competencies; (vi) assisting Chief Learning Officers in choosing the
most appropriate employee for a given role.

This paper presents an organizational network for product configuration
management within the context of Virtual Enterprise. Actors, from high level strategy making actors to low level physical devices, can advertise their own skill and knowledge and seek for partners to form dynamic alliances in a
community. The network is organized based on Adaptive Resonance Theory (ART) which was originally used for unsupervised neural network learning and which allows the organization and cooperation of such product development alliances to be more flexible and adaptable. Some characteristics, which are inherent in real enterprises or society, such as self-organization, unsupervised learning, competition between actors are exhibited in the ART-based organization network and are the keys for evolution and development of enterprises.

Der Vortrag besteht aus zwei Teilen. Im ersten Teil werden Anforderungen an ein Schätzverfahren beschrieben, das einerseits schon vom Beginn eines Projektes an zuverlässige Ergebnisse liefern soll, das aber andererseits Angaben über das Projekt verwenden muss, die anfänglich gar nicht präzise sein können.

Im zweiten Teil des Vortrags wird gezeigt, wie diese Anforderungen vom Schätz- tool Tassc:Estimator umgesetzt werden. Dabei wird besonders hervorgehoben, dass es wichtig ist, dass man die Daten, auf denen die Schätzung beruht, leicht ändern können muss, um die äußeren Einflüsse auf ein Projekt schnell berück- sichtigen zu können.

Peer-to-Peer systems have become extremely popular about one, two years ago when researchers all over the world started to talk about the _potential_ of such kind of systems. It is especially interesting taking in consideration the fact that centralized systems appeared later than pure peer-to-peer systems did, but very soon pushed the peer-to-peer completely out of the scene. The _killer_ application that would prove the 100% necessity of fully decentralized systems or their 100% benefit in comparison to the centralized systems is still not found as it was not found 30 years ago when the first peer-to-peer systems appeared. Nevertheless, we do talk about peer-to-peer today as about technology of high importance. We do not want to dedicate this paper to the search for a killer application for peer-to-peer technology or to attempts to find the ways to replace the centralized systems. Instead, we will talk about other class of systems _ _ad-hoc_ _ and about peer-to-peer as enabling technology for ad-hoc systems. We would like to analyze why do we need ad-hoc systems, discuss their features and requirements, and based on this analysis discover the opportunities of peer-to-peer networking. We also provide a list of requirements to the peer-to-peer systems as well as to the existing network technologies that need to be fulfilled in order to fully enable ad-hoc networking in the future.

Der Beitrag beschäftigt sich mit internetbasierten Services auf embedded Systemen. Zuerst wird ausführlich auf die OSGi-Technologie eingegangen. Es werden alle notwendigen Komponenten vorgestellt. Dabei wird auf einige Dienstleistungen näher eingegangen und auch die entsprechenden gerätetechnischen Voraussetzungen für diese Services genannt. Dies bezieht sich insbesondere auf die Themen Netzzugang und die Verbindung mit haus- bzw. fabrikinternen Bussystemen wie Feldbusse, Gebäudebusse, Multimediakommunikation aber auch die einfache Kommunikation zwischen einzelnen Geräten. Resultat dieser Betrachtungen wird eine geeignete Architektur des Dienstleistungsgateways sein, die mit Kommunikationsschnittstellen zum Internet und zu unterschiedlichsten Anwendungen ausgestattet ist. Zum Abschluß werden drei Applikationen vorgestellt, die auf einem solchen Gateway einzeln oder miteinander laufen können.

Immer mehr Kunden versprechen sich bei der Entwicklung von Loesungen neue
moderner Clients wie Mobiltelefone. Die Java Architektur bietet die
Moeglichkeit, End-to-End Lösungen - vom Mobiltelefon bis zum
Applikationsserver - auf Basis von Web Services und Standards wie J2EE und

J2ME zu erstellen und einzusetzen.
Der Vortag wird auf die Sun ONE Architektur eingehen und anhand eines
praktischen Beispiels die Erstellung einer Java Loesung anhand Sun ONE
Studio vorstellen, die im Front-End auf einem Java-faehigen Mobiltelefon
ablaeuft und im Back-End mittels Web Servies auf einer EJB- Architektur
zugreift.

Many real-world Java applications fall short of Java_s excellent
exception handling capabilities. In this article we point out several design and
programming mistakes encountered in industry projects. We give advice on
best practice concepts of Java exception handling and cover enhanced
exception handling features in Java 1.4.

What is behind _technical interoperability_? It is easy to discuss Web services, but the actual act of integrating services can be extremely complicated. This session will discuss interoperability between Web services, J2EE and CORBA "from PC's over Unix to the Mainframe" highlighting the following technologies:
 The exposure of Enterprise Java Beans (EJB_s) as Web services
 The exposure of CORBA Objects as Web services
 The interoperability of CORBA and Enterprise Java Beans: CORBA calling EJB_s, EJB_s calling CORBA including CORBA based mainframe integration.
How do all these technologies communicate? 2-Phase Transactional interoperability becomes increasingly important as more computer languages are developed; security (incl. HTTPS, SAML/XKML, CSIv2, TLS/SSL, RACF) also becomes an issue as the technologies are used to transfer sensitive materials that need to remain private.

This presentation will include a demo of Web services technology interoperating with J2EE and CORBA technology, presenting an overall application server platform example. Also included are both, integration architecture and _hands on_ real world project samples.

This article describes a software development process based on models, especially mental models.
It discusses the implications of these models on change, redundancy and communication. Just by being aware
of the existence of these models everybody implied in the development process can benefit from more efficient
communication. Using a simple pen and paper technique misunderstandings can be reduced. It also provides
insights into the dynamic nature of the development process and a better understanding why it is so difficult
to keep the process alive. It shows the fight between order and chaos, chaos that can make a software system
so immobile that the search for solutions and the learning process (that mean the ability to adapt the models
to new insights and keep them synchronized) come to an end.

Auch Web Services ersparen einem nicht das Nachdenken und die Dokumentation bei der Softwareentwicklung. Sie ermöglichen aber prinzipiell die schnelle Verknüpfung von heterogenen Systemen. Dies wird an zwei Beispielen aus der Praxis gezeigt.

By using powerful base technologies such as XML, SOAP and UDDI, Web Services today are state-of-the-art for electronic data exchange between applications, and for interaction between information and business transaction services on the net. Due to their flexibility and neutrality regarding programming languages and providers, Web Services are becoming increasingly important in all areas of commercial technology, and thus may be viewed as a mainstream development within IT.

Despite of all optimism and the obvious fundamental possibilities, the introduction barrier of this technology, which is created by established - even though often inefficient – procedures, and the inclusion of legacy systems should not be underestimated. Effective migration approaches and mechanisms to comprise today’s IT landscape are required. Only then Web Service technology will experience a true market breakthrough after initial success reports of early adopters.

This article gives an overview of the current situation with Web Services both from a technical and an economic point of view. After a brief introduction of the basic principles, a closer look will be taken into what is available right now and what is under work or can be expected as far as the level of standards in the near future is concerned. Furthermore, Web Services sometimes considered as the ultimate way of process and system integration, are compared with other XML-based approaches like ebXML and RosettaNet.

With our explanations we try to bridge the arch of today’s Web Services technology and previously used mechanisms, and demonstrate how, by the help of modern integration tools, the hurdles of migration and mixed environments can be overcome, and how the required integration of new and legacy systems can efficiently be realized.

Software evolution requires an intelligent planning of evolution and main-tenance activities in an organization. Intelligent planning means integrating the long-term strategy of a product_s evolution with short-term maintenance activities. This paper describes a successful example of software evolution in the context of the ap-plied-research project APPLICATION2WEB. The paper describes experience in transfer-ring technology into a small company to realize web services based on a legacy sys-tem.
The project covered all necessary activities including reverse engineering, do-main analysis, architecture analysis, and middleware integration.

The internal agent architectures that current MAS frameworks provide
don’t enable the rapid implementation of agents from reusable components.
This is because of the underlying problem that the agent-oriented programming
paradigm, defining how abstraction, decomposition, and modularity
are achieved, is not sufficiently understood or developed. This paper presents
an agent decomposition framework that offers agent-oriented programming and
software engineering separation of concern guidelines in the context of proposing a more flexible and extensible internal agent architecture than current MAS frameworks provide. This architecture provides an infrastructure that supports constructing agents from reusable components at the subsystem level. Subsystems are added to an agent through a dynamic description, event, and ontology registration process. Once connected, the composite subsystems interact by an event-based software bus that acts as the central nervous system of an agent. This gives subsystems the ability to reason about the functionality and current state of their constituent parts and allows agents to be composed from industry wide best known components instead of building agents from a single MAS framework repository.

Behavior-Oriented Design (BOD) is a development methodology for creating complex, complete agents such as virtual-reality characters, autonomous
robots, intelligent tutors. BOD agents are modular, but not multi-agent systems.
They use hierarchical reactive plans to perform arbitration between their component modules. BOD provides not only architectural specifications for modules and plans, but a methodology for building them. The BOD methodology is cyclic, consisting of rules for an initial decomposition and heuristics for revising the specification over the process of development.

Stepwise feature introduction is an approach to construct software systems by incrementally extending a system with new features.
This approach emphasizes reliable software construction in the meaning that each layer is a superposition refinement of its preceding layer, and each evolution version of the implementation is a data refinement of its preceding version or the initial specification. This paper argues for using stepwise feature introduction as a building methodology for reliable cooperative
agent systems, and explain how to resolve feature ordering and feature interaction problems between different layers when implementing agent systems by this approach.

While tools for agent based social simulation have come a long way towards making life easier for the social scientist depending on computerized methodologies, we find that some of the requirements for efficient scientific progress have not been met. Inspired by the success of simulation environments and tools in the last decade, by the work on the alignment of models and by proven technology in business information systems, we propose a common methodology in the form of a common object model architecture for agents(COMA).

Auction mechanism is a good solution to the distributed resource allocation. However, in open agent system, it is impossible to fix the market configuration for resource allocation in advance because of the different participants and the variety of resources. It implies the necessity for configurability of auction mechanism.
This paper presents a configurable auction framework for resource allocation in the open agent system. Compared with other related work, the framework implemented here has its special features, including application-oriented, the more configurability flexibility, considerate auction abstraction, XML-based implementation and wider applicability.

In the context of highly heterogeneous, complex and dynamic systems, we can compare distributed object based and component based approaches, that were first centered on the idea of composition and modularity, where dynamicity has become an issue afterward, with MAS approaches, whose first concern was the dynamicity, and where composition was in the beginning rather considered as an implementation issue. Now, both communities tend to foster the gap. Our work is part of this trend, by exploring the notion of situated composition, where each agent or component can have its own compositional perception of the rest of the system, and by considering that an agent is actually an extended component. We achieve agent dynamic composition in terms of delegation and agent proxies. This way, component aggregation accounts for synchronization and existing interaction patterns. Agent conversations are the natural canvas supporting compositional relationships, and agents are recursively decomposable, without having to introduce other organizational constructs that might disturb agents fundamental properties.

This paper focuses on design issues to be faced when developing knowledge management (KM) applications based on the integration of peer-to-peer and multi-agent technologies. The reasons for using these technologies rest on the requirements posed by the specific KM paradigm that has been adopted, which emphasizes aspects such as autonomy and distribution of knowledge sources. We adopt an agent-oriented approach that extends Tropos, a software engineering methodology introduced in earlier papers. We present a characterization of peer-to-peer in terms of a general architectural pattern, a set of design guidelines for peerto-peer applications, and a framework that integrates multi-agent and
peer-to-peer concepts and technologies.

The process of designing a multi-agent system (MAS) naturally involves many different concepts. The system should reach some goals and provide specific requirements. The designer should produce an accurate model for the domain ontology, the agents’ knowledge and interactions. The structural and behavioral description of the system will descend from these elements and will also generate some constraints in the other parts of the design.
From these considerations and our experiences in designing MAS with a CASE
tool supported methodology (PASSI) we deducted the importance of exploring
the design process of these systems from several different perspectives that
explicitly address the architectural, social, knowledge, resource and physical
aspects of them.

Agent Oriented Software Engineering (AOSE) is one of the fields of the agent
domain with a continuous growing interest. The reason is that the possibility to
easily specify and implement agent-based systems is of a great importance for
the recognition of the add-value of the agent technology in many application
fields. In this paper we present an attempt towards this direction, by proposing a kind of roadmap of how one can combine the Gaia methodology for agentoriented analysis and design and JADE, a FIPA compliant agent development
framework, for an easer analysis, design and implementation of multi-agent
systems. Our objective is realized through the presentation of the analysis,
design and implementation phases, of a limited version of a system we
currently develop in the context of the IST IMAGE project.

This paper describes an investigation into how the robustness of a software system can be improved via the use of software agents as a fundamental component of the system. Robustness can be achieved through redundancy, and we hypothesize that agents are an appropriate unit for adding redundancy. As part of our investigation, we asked 53 students to independently build one agent for a simple Multiagent domain.
We did a comparison study between the different student’s agents while working with each other independently and while working with each other as part of collaboration. A simple decision-making mechanism was also introduced and compared. This influx of redundancy in the collaborations provided a discernible increase in productivity. The results shown here should lead to further rich and enlightening research into agent-oriented software engineering.

Normally a society of agents is developed to cope with and solve a particular set of problems or to achieve some particular goals and objectives. Different people, organizations and groups have developed and deployed agent societies for their own particular needs. These societies have to communicate, coordinate and compete with each other. In this paper an explanation is provided as to what is meant by inter society communication in agents, why it is needed and some basic problems in the area of inter-society communication are identified. A framework for inter-society communication in agent systems is also proposed.

Once the decision is made of using agents in your software application you should decide how these agents are going to be implemented and integrated in your application. There are basically two options to implement agents. Either you use a dedicated agent platform or you implement the agents from scratch in some standard programming language. The choice between these options impacts the architecture of your application. This article will briefly discuss both options and will present object-oriented models to integrate agents in your application in case of the latter option being used. The presented models can be used as guidelines to integrate software agents in object-oriented software applications.

In the last years, multi-agent systems (MAS) have proved more and more successful. The need of a quality software engineering approach to their
design arises together with the need of new methodological ways to address
important issues such as ontology representation, security concerns and
production costs. The introduction of an extensive pattern reuse practice can be
determinant in cutting down the time and cost of developing these systems.
Patterns can be extremely successful with MAS (even more than with objectoriented systems) because the great encapsulation of agents allows an easier identification and disposition of reusable parts. In this paper we discuss our approach to the pattern reuse that is a phase of a more comprehensive approach to agent-oriented software design.

The work presented in this article is based upon a methodological approach for building Multi-Agent Systems specifications. Thebasic idea is to define such systems as a set of entities playing roles which have interactions between them. We present a mechanism for dynamic role-playing specification within a formal framework. The framework use a formalism which can express Multi-Agent Systems aspects. This formalism composes Object-Z and statecharts. The main features of this approach are : enough expressive power to obtain unbiased specifications, tools for specification analysis and refinement mechanisms allowing the refinement of a high level specification into a low level specification which can be easily implemented.

As mobile computing matures, location-awareness as part of context-awareness gains more attention; especially, location-aware services for mobile users. This paper concentrates on the software engineering issues of location-aware services and presents Mobile Shadow as an successful example of a design and an implementation of a scalable, fault tolerant, and component-based service infrastructure for location-aware services. The paper presents the basic concepts used in Mobile Shadow, the requirements, and the resulting component architecture.

A growing interest in the practical application of the autonomous agent paradigm in open and distributed environments has been observed in recent years. A host of standards are being developed in this respect, aiming at
easing and promoting interoperability between heterogeneous agents and multiagent systems. The work of the FIPA is prominent in this field. The effort of this organization centres on defining an abstract architecture that identifies all the elements involved in achieving the above-mentioned interoperability and establishes the relationships between these elements. Nevertheless, this model does not completely address the inherent social-ability of any multi-agent system and which is especially important for achieving a higher level of interoperability. This paper lays the foundations for an extended role model and an organizational model that will serve as a framework for establishing and specifying relationships between heterogeneous agents interacting in an open environment. The agent and agent information models proposed by the FIPA are adapted and extended to accommodate this social viewpoint and social requirements on agent conversations and communication languages are discussed. We then propose a policy framework that constitutes the basis for agent social infrastructure management. Finally, the most relevant platform service infrastructure needed to support the policy framework is presented and defined. Our aim is to be able to model how agents are going to interoperate with one another within an open environment by means of normative policies, and how this environment will be organized and supported.

In recent years, agent-based systems have received considerable attention in both academia and industry. The agent-oriented paradigm can be considered a natural extension to the object-oriented (OO) paradigm. Agents differ from objects in many issues which requires special modeling elements. Although there is a well-defined OO analysis and design modeling language (UML), agent-oriented development has neither a standard analysis and design modeling language nor a standard development process. In this paper, we propose a software engineering process for agent-oriented analysis and design. The process is based on existing object-oriented software engineering concepts. We also extend the Unified Modeling Language (UML) to model agents.

Tropos, a novel agent-oriented software engineering methodology, is heavily characterized, among other features, by the fact that it pays great attention
to the activities that precede the specification of the prescriptive requirements, such as understanding how the intended system would meet the organizational goals. This is obtained by means of the two requirement phases: the early requirements analysis and the late requirements analysis. Moreover, Tropos uses, along these phases, a uniform notation and an homogeneous, smooth, incremental, and iterative process, based on a set of progressive transformational steps.
This paper will take into account the application of the Tropos methodology to a
self-motivating case study: the definition of a support tool for the Tropos methodology itself. The focus here is on the early requirements and on how to manage the transition from them to the late requirement analysis.

The purpose of the Software Agents for MObile Services (SAMOS) project is to understand the role of m-services in the wireless world. M-services are an extension to the paradigm of e-services. The wireless world has its own features that make it completely different from the wired world. For instance, new communication channels need to be deployed, new user-friendly services need to be suggested, and new types of computing resources need to be involved. In addition to the traditional challenges of mobile computing, the following issues are addressed in SAMOS: How to discover m-services in an open wireless environment? How to compose m-services to create sequences? And, how to make m-services runnable on wireless devices?

Until recently, electronic markets were dominated by the combination of static offer plus fixed pricing policies. Static offer schemes assume that all users have the same criteria which may not meet the requirements of all potential buyers. A fixed price might not always refect the current market balance of supply and demand and the specific valuation of a single buyer. In this paper we propose an agent-mediated insurance brokering system using a flexible negotiation model that includes multi-attribute bidding as well as some kind of learning capabilities. Moreover, in the core of the provided brokering facility, we are using conceptual clustering procedures as an approach to better match customers and insurance product offers providing a valuable add-on to both customer's and sellers' sides. Intelligent agents engage themselves in a negotiation process by exchanging proposals and counter-proposals trying
to convince opponents to modify their bidding values. We are now developing a Java based multi-agent infrastructure specifically dedicated to the insurance e-commerce domain, exploiting Toshiba's Bee-gent framework. For both acceptability and generalisation purposes, XML (including appropriate ontology-based messages) has been chosen as our agent communication format.

During the design of an agent system many decisions will be taken that determine the structure of the system, for reasons that are clear to the designer and customers at the time. However, when later teams approach the system it may not be obvious why particular decisions have been taken. This problem is particularly acute in the case of designers attempting to integrate services from many different service providers. In this paper a mechanism for recording these decisions is described. We illustrate how design decisions can be captured and how these abstractions can then be used in as the basis of reuse in an extension of the Zeus agent toolkit.

Recently, schema matching has found considerable interest in both research and practice. Determining matching components of database or XML schemas is needed in many applications, e.g. for E-business and data integration.
Various schema matching systems have been developed to solve the problem semi- automatically. While there have been some evaluations, the overall effectiveness
of currently available automatic schema matching systems is largely unclear. This is because the evaluations were conducted in diverse ways making
it difficult to assess the effectiveness of each single system, let alone to compare their effectiveness. In this paper we survey recently published schema matching evaluations. For this purpose, we introduce the major criteria that influence the effectiveness of a schema matching approach and use these criteria to compare the various systems. Based on our observations, we discuss the requirements for future match implementations and evaluations.

As an increasing number of Web sites consist of an increasing number of pages, the users more find it more difficult to rapidly reach their own target pages. Ill-structured design of Web sites also prevents the users from rapidly accessing the target pages. In this paper, we describe two complementary approaches to Web usage mining as a key solution to these issues. First, we describe an adaptable recommendation system called the system L- R, which constructs user models by classifying the Web access logs and by extracting access patterns based on the transition probability of page accesses and recommends the relevant pages to the users based both on the user models and the Web contents. We have evaluated the prototype system and have obtained the positive effects. Second, we describe another approach to constructing user models, which clusters Web access logs based on access patterns. The user models also help to discover unexpected access paths corresponding to ill-formed Web site design.

Whenever small mobile devices with low bandwidth connections to a server execute transactions on common XML data, then efficient data exchange between client and server is a key problem to be solved. However, a solution should also consider client-side cache management for the XML data, synchronization of concurrent access to the XML data, and lost connections during transaction execution. In order to reduce data exchange between client and server, our protocol re-uses data stored in the client’s memory instead of reloading data into the client’s memory wherever possible. A key idea is that the server keeps a ‘living copy’ of the XML fragments in the client’s memory for efficient cache management. Furthermore, our protocol integrates well with a validation based scheduler in such a way that offline work and transaction completion after lost connections are sup-ported. Finally, we present some optimizations that further reduce client-server communication.

From its origin in document processing, XML has developed into a medium
for communicating all kinds of data between applications.
More recently, interest has focussed on the concept of native XML databases.
This paradigm requires ... Our research indicates that it is possible
to optimise queries over XML structures by choosing appropriate physical representations on the basis of document analysis.

Significant work has been done towards achieving the goal of placing semistructured data on an equal footing with relational data. While much attention has been paid to performance issues, far less work has been done to address one of the fundamental issues of semistructured data: schema evolution. Semistructured indexing and storage solutions tend to end where schema evolution begins. In practice, a real promise of semistructured data management will be realized where schemas evolve and change. In contrast to fixed schemas, we refer to schemas that grow and change as open schemas. This paper addresses the central complications associated with indexing open and evolving schemas: we specify the features and functionality that should be supported in order to handle evolving semistructured data. Specific contributions include a map of the steps for handling open schemas and an index for open schemas.

Most query and transformation languages for XML and semistructured data, e.g. XQuery and the precursors of XQuery and XSLT, build upon a path-oriented node selection. A node in a data item is specified in terms of a root-to-node path in the manner of the selection languages of operating systems. Constructs inspired from regular expression constructs give rise to a flexible node retrieval from incompletely specified data items.
This paper introduces Xcerpt, a query and transformation language further developing an alternative approach to querying XML and semistructured data, first introduced with the language UnQL. A metaphor for this approach views queries as patterns, answers as data items matching the queries. Formally, an answer to a query is defined as a simulation of an instance of the query in a data item.

A key characteristic of mobile applications is the need for up-to-date location-dependent information, while the physical location changes frequently. Recent improvements in wireless communication and hardware technology and Internet-based data exchanged created a new type of mobile applications whose requirements are not met by traditional relational and object database systems. In this paper we describe MAGNET, a tuplespace-based framework for dynamic information storage and retrieval addressing the needs of application in frequently changing mobile environment and discuss how this approach could enable flexible data exchange. In addition to type-free data storage and user-customized requests for data records, MAGNET enables adaptation to a changed environment by supporting constant monitoring of selected information.

The world wide web does not longer consist of static web pages. Instead, more and more web pages are created dynamically from user request and database content. Conventional search engines do not consider these dynamic pages, as user input cannot be simulated, thus providing often insufficient results.
A new approach for online integration of web databases will be presented in this paper. Providing only one sample HTML result page for a source, result pages for new requests will be found by structural recognition. Once structural recognition is established for one source, other web databases of the same universe (e.g. movie databases) can be integrated on the fly by content-based recognition. Thus, the user receives results from various sources.
Global schemata will not be produced at all. Instead, the heterogeneity of the single sources will be preserved. The only requirement is given by the existence of an extensional overlap of the databases.

With the advent of native and XML enabled database systems, techniques for efficiently storing, indexing and querying large collections of XML documents have become an important research topic. This paper presents the storage, indexing and query processing architecture of eXist, an Open Source native XML database system. eXist is tightly integrated with existing tools and covers most of the native XML database features. An enhanced indexing scheme at the architecture's core supports quick identification of structural node relationships. Based on this scheme, we extend the application of path join algorithms to implement most parts of the XPath query language specification and add support for keyword search on element and attribute contents.

UDDI, Universal Description, Discovery, and Integra-tion, represents a directory for the publication and querying of cat-egorized Web services. Publication and query are performed by utilizing UDDI’s Application programming interface (API), which employs SOAP as a communication instrument. By offering an invocation API in addition to two other types for examination, UDDI allows clients to search for and subsequently invoke specific Web services. Failures in invoking already sought and, on the application side, statically cached Web services typi-cally result in re-querying the registry.
However, an application’s reaction time in response to changes is limited due to UDDI’s replication latency, i.e. the amount of time it takes for changes to entries stored inside the UDDI repository to be propagated to all UDDI nodes.
This paper proposes a mechanism termed active UDDI, which al-lows the extension of UDDI’s invocation API in order to enable fault-tolerant and dynamic service invocation.

The recent evolution of internet technologies, mainly guided by the Extensible Markup Language (XML) and its related technologies, are extending the role of the World Wide Web from information interaction to service interaction. This next wave of the internet era is being driven by a concept named Web services. The Web services technology provides the underpinning to a new business opportunity, i.e., the possibility of providing value-added Web services. However, the building of value-added services on this new environment is not a trivial task. Due to the many singularities of the Web service environment, such as the inherent structural and behavioral heterogeneity of Web services, as well as their strict autonomy, it is not possible to rely on the current models and solutions to build and coordinate compositions of Web services. In this paper, we present a framework for building reliable Web service compositions on top of heterogeneous and autonomous Web services.

Current mechanisms for the description of Web Services and their composition are either to coarse – by specifying a functional interface only – or too fine –by specifying a concrete control flow amongst services.
We argue that more adequate specifications can be built on the notion of depen-dency of activities and coordination activities to manage these dependencies. We
propose a Dependency Markup Language to capture dependencies amongst ac-tivities
and generalizations/specializations amongst processes. With that, we can
describe composite services at more suited levels of abstraction and have several options to use such descriptions for service coordination, service discovery and service classification.

Web Services (WSs) are touted as a new promising paradigm for developing and deploying distributed, Internet-based business applications. Recently, we have witnessed the emergence of web-service description and request languages as well as composition protocols. Transaction management is crucial for implementing reliable and robust web-based business transactions with cohesive web-services.
However, existing service composition protocols tend to provide minimal support for transaction management. This support basically mimics traditional database mechanisms for ensuring ACID-properties of web-services, apparently in an arbitrary way. Ergo, sound theoretical underpinnings for incorporating transactional acidity in web-service composition languages is currently lacking.
This paper outlines a theoretical three-dimensional framework for ACID criteria of e-business transactions. This framework serves as the foundation of a transaction model that relies on “traditional” atomicity spheres.

In the paper the proposal for modeling flexibility of the Web Services with feature diagrams is introduced. Feature diagrams allow presenting the commonality and above all variability of described concept. In the paper the classification of Web Services features from the users' point of view is given. The comparison of Web Services with the orthogonal component concept is also discussed.

Web services are interoperable (software) components that can be used in application integration and component-based application development.
This paper analyses possible contributions of the emerging Web service archi-tecture to settle open issues that both application integration as well as compo-nent-based application development have in common and thereby focuses on
the specification of components. Within the Web service architecture, specifica-tion is standardized by the UDDI framework, which is at first analyzed based
on some general requirements for specification frameworks. Hereafter various
extensions to the UDDI framework are proposed and elaborated in detail. They
improve the specification of Web services by providing additional information
about various aspects: security, performance, behaviour, coordination, imple-mented terminology (semantics), and implemented processes (pragmatics). Ac-cordingly, a mix of specialized (formal) notations for the particular specifica-tions is proposed. The resulting specification framework is ordered using a
thematic grouping that consists of white, yellow, blue and green pages.

Supplying integrated data model with multiple structures for addressing diverse requirements from different production lifecycles and control levels is the natural development of automation systems. Data processing, presentation and manipulation require well-designed computation model that consists of interrelated groups of function components or applications that can be realized in the form of web services. Binding the available web services to the designed data model becomes a challenging task if a great amount of web services is confronted. In this paper we will use ontology technology to address the binding problem. We will present the required ontology model including the formal expression of ontology, object model, mapping to XML representation and the corresponding system architecture for binding web services.

In this paper we extend current typical Web service architectures by providing a Web Service Notification Framework (WSNF). Besides the three standard roles found in current frameworks (i.e., the service provider, the service requestor, and the service registry), our approach introduces an additional role that we call the service notifier. The framework is designed in four layers: the Proxy Layer, the Web Server Layer, the Application Notification Server Layer, and the Application Worker Layer. Since the WSNF itself is a service provider, this framework is reflective in the sense that it checks and notifies itself about changes. The framework is documented using design patterns. The set of patterns applied in the framework design includes the following patterns: the singleton, the delegation, the factory method, the observer, the mediator, the notifier, which is a combination of the mediator and the observer, the item description, and the proxy. The notifier pattern is in fact a publisher-subscribe pattern with push semantics. The framework uses a requestor profile to support notifications related to a category of events related to changes, failures, and version control problems of Web services.

Field devices are becoming more and more 'intelligent'. This report describes how ABB can use this intelligence to offer service capabilities via internet standards and to integrate these devices into the Industiral-IT world.

Academic and industrial bodies are considering the issue of Web Services as being the next step forward. A number of efforts have been made and are evolving to define specifications and architectures for the spreading of this new breed of web applications. One such work revolves around the Semantic Web. Lead researches are trying to combine the semantic advantages that a Semantic Web can provide to Web Services. The research started with the now
standardized RDF (Resource Description Framework) and continued with the creation of DAML+OIL (DARPA Agent Markup Language and Ontology Inference Layer) and its branches, particularly DAML-S (where S stands for Services).

In this paper, we propose a decentralized model for dynamic optimization of queries well adapted to wide-area distributed databases, and its implementation using mobile autonomous agents. Agents_ autonomy allows the execution plan to react dynamically to estimation errors without being penalized by time overheads that usually results from the use of a centralized monitor. Performance evaluation shows the benefits of this approach for standard hash join algorithms. Response time can significantly be reduced : from 3% to 60% when the error on selectivity factor exceeds 40%, and from 11% to 400% when estimation error on the size of a temporary relation is greater than 30%. Performance results serves as a basis for the definition of a strategy for agent mobility.

As wireless mobile applications are becoming more and more popular, an increasing number of applications requires that the content to be displayed on the user's device is generated dynamically. Just like many electronic-commerce applications need to generate web content depending on user input and data retrieved from a database, WAP (Wireless Application Protocol) based applications as well have to access databases and produce output in WML
(Wireless Markup Language) or its scripting language WMLScript. In this paper, the basic technologies for creating static and dynamic WAP content are discussed. JSP (Java Server Pages) is chosen as an appropriate technology that supports the generation of dynamic usertailored content. A mobile-shopping example is used to illustrate the concepts. The underlying database is accessed through a JDBC-ODBC driver. Parameter passing across the heterogeneous
architecture of the mobile solution is discussed.

This paper reports about our experience in developing the ERX Data Management System, a system devised to collect data coming from different XML data sources, and store them into a database in a way independent of the source format; its query language, named ERX-QL, is able to query the database and generate new XML documents.
We developed the ERX Data Management System to explore the possibility of integrating three different basic technologies, Relational DBMS, Java and XSLT, under a unifying framework which makes the system interoperable w.r.t. the particular adopted technology (for example
Relational vs Object-Oriented database technology); hence, this framework is based on an Entity-Relationship-like Data Model (ERX), which is not tied to any specific technical and/or commercial solution. The paper discusses the architecture of the ERX system, and the adopted technical solutions.

We present the MicroDoc Persistence Frameworks for Java (MPF/J), an Object-Relational (O/R) mapping suite developed for overcoming the "impedance mismatch" between the object world and the world of relational databases. We discuss some issues that arise during the development of the frameworks that we consider worth investigating further. We also report on our experiences in
applying the frameworks in large-scale applications.

In the following paper several persistence approaches evaluated at SAP are analyzed and a number of open issues are identified. The resulting architecture, which is currently being implemented at SAP as part of its J2EE engine to enable its application developers to produce real world J2EE applications, is presented.

With the recent release of version 3.0, the Java Community Process once again extended JDBC, the Java database API for relational database access, mainly adding some features to support highly scalable enterprise-level applications running within J2EE application server environments even better.
Most of these concepts and features being also available for JDBC 2.x environments (at least as part of vendor-specific or add-on solutions), we will present some best practices and common pitfalls regarding Java database access from our project work as members of the Sun Java Center in Germany. We will take a look at how to use resource pooling properly, minimize network roundtrips, chose the appropriate tier for data-intensive operations and do some application level caching of frequently accessed, but fairly static master data.

XML is quickly becoming the industry standard data exchange format for business applications.
Since most of the data is stored in relational tables, there must be a way to transform relational data into XML. For a XML document to be readable for every business associate relational database, a mapping must be provided to specify how a XML document fits a specific database model. This paper proposes AXIS (Automatic XML Interchange System), which is an architecture implemented in Java that allows the creation of such mapping and, afterwards, the conversion of relational data to XML and back to relational data.

This paper presents the basic ideas of constructing a product line
content & knowledge base on top of arbitrary configuration management sys-tem.
Its need stems from the fact that evolving product lines arise a number of
significant challenges, which can only be mastered with sound information
base. The complexity of a product line engineering and its sheer number of ad-ditional artifacts and methods aggravates the intellectual control of a product
line and its change over time. Management activities like product design, building of road maps or effort estimation become more difficult than for single product engineering and ask for more sophisticated information. We think that the problems can be solved with the explicit depiction of product line content & knowledge. Only then we can understand and control how a product is constituted from single software artifacts, what are their dependencies and relations, and how changes on shared assets affect the products in a product line. The product line content & knowledge base is a prerequisite for product line management services and processes, which makes it possible to manage the evolution of a product line and to control its consistency and completeness.

Class evolution is a key issue in object oriented systems evolution. In particular much research has focused in topics raised by class evolution either through coercion or versioning. In this paper dynamic attribute addition in terms of versioning is addressed. Dynamic attribute addition in this context concerns modifications of variables of objects and classes at runtime. As a means to an end an approach based at the notion of metaclasses is
proposed. Finally an evaluation of the benefits and the drawbacks that emerge from its use is established.

Do libraries written without explicit support for Design by Contract
in the language or the design methodology contain implicit contracts? To help
answer this question, we have performed an empirical study of some existing
non-contracted library classes from the .NET Collections library. This paper
reports on what we have found, and discusses whether the results could be used
to improve the design of the classes and make them easier to learn and use.

For programmers who are not involved in the development
of a graphical user interface (GUI), it is usually not an easy task to
adapt or extend the GUI. In this paper a possible solution being based
on the plug-in concept is proposed which makes extensions of the GUI
and independent development of GUI components much easier. Further-
more, GUIs designed that way can be easily extended with individual
functionality for each user.

Federated Information Systems are based on gathering information from different heterogeneous data sources. The Internet - a Meta FIS in one sense - demands for the ability to query many different information sources. Obviously, most of them are structured very differently. Considering databases, XML files, other structured text files or Web Services as information supplier the complexness of integrating the information with their various describing models is not easy to handle.
Even companies that only want to setup a global information system (e.g. a Data Warehouse) are faced with integration problems. As a lot of departments were able to develop their own local information pools there can be a variety of different sometimes redundant data sources even inside a company.
In this paper an new approach of building such a global information
system is described. Besides the theoretical aspects it is mainly
shown that the system is really working and can easily be adapted
to the special needs, a certain Federated Information System has
to fulfill.

Many data structures for images are limited to dimension two. Furthermore, common transformations for images are usually not supported (efficiently). In this paper, efficient Java data structures for images are discussed and their performance is compared.
Keywords: image processing, data structures, Java

Component-based software, particularly distributed component-based software, makes heavy use of interfaces to define the interactions among components. Each of these interfaces is usually presented in the form of an API, as a specification of the capabilities of the relevant component. However, while the predominant API model captures the behavior of individual interface members, it neglects the interactions among those members. We propose an approach that incorporates such interactions into an interface specification, and provide a practical application of the approach.

In einem an der Fachhochschule bearbeiteten Thema zum digitalen Produktdaten Management wurden neben Schnittstellenuntersuchungen zwischen den einzelnen Prozessschritten auch die Möglichkeiten zur interaktiven 3D Produktpräsentation im Internet untersucht. Der Beitrag beginnt mit einem kurzen Überblick zur Geschichte von 3D Computergrafiken im Internet. Aufbauend auf einer Diskussion des klassisches Standard VRML 97 werden die neuen Ansätze des W3C Konsortiums mit X3D und konkurrierende Entwicklungen, hier Viewpoint Experience Technology VET, diskutiert. Abschließend werden einige praktische Projektergebnisse vorgestellt.

Mit dem starken Wachstum der Telekommunikationsnetzwerke nimmt auch die Bedeutung des Netzwerkmanagements zu. Traditionelle Netzwerkmanagementaktivitä- ten, zu denen auch das Netzwerkfehlermanagement gehört, werden gegenwärtig un-
ter Einbeziehung der menschlichen Arbeitskraft ausgeführt. Jedoch werden diese Aktivitäten zunehmend mehr nachgefragt und von ihrer Charakteristik her komplexer, so daß die Idee der Automation bzw. Teilautomation von Netzwerk-managementaktivitäten zunehmend an Attraktivität gewinnt. In diesem Zusammenhang ist es angebracht, den Ablauf des Fehlermanagements in einem Network Control Center zu analysieren, um Ansatzpunkte für eine Auto-matisierung bzw. Teilautomatisierung des Netzwerkfehlermanagements zu finden.

Due to the characteristics of mobile networks such as low speed, high error bit rate, variable link throughput etc, the applications over the wireless channel face with many challenging problems, especially multimedia applications, where the volume of data is huge. Without a suitable control, the Quality of Service (QoS) of such applications is adversely affected and the connection quality may become unacceptable. In this paper, we propose a dynamic Packet size mechanism(DPSM) adapting with a rate control proactive protocol at the base station of the wireless network. We argue that adaptation is necessary in a changing environment where static configuration of error control does not yield the best performance for many situations.

Im vorliegenden Papier wird ein Distributionssystem für multimediale Inhalte auf Basis des Peer-to-Peer-Paradigmas vorgeschlagen, welches bekannte
Nachteile dieser Technologie durch die Einführung von relativer Lokalität und
einer losen Struktur umgeht. So wird der große Kommunikationsaufwand, der
häufig in solchen Systemen auftritt, minimiert. Zusätzlich skaliert das System
auch bei einer großen Anzahl Teilnehmer gut,ermöglicht das Publizieren von
Inhalten an beliebigen Knoten, kommt ohne breitbandig angebundene
Kommunikationspartner aus und bietet sichere und zuverlässige Kommunikation.

Zentrale ECA-Regeln wurden für zentrale aktive Datenbanksysteme entwickelt. In verteilten aktiven Datenbanksystemen tritt zusätzlich das Problem der Unerreichbarkeit von Teilsystemen auf und damit die Unentscheidbarkeit von ECA-Bedingungen, die sich auf entfernte Systeme beziehen. In diesem Papier wird daher eine entsprechende Erweiterung der ECA-Regeln für verteilte aktive Datenbanksysteme vorgeschlagen, um auch bei Unerreichbarkeit und Unentscheidbarkeit der ECA-Bedingungen reagieren zu können. Dazu wird zunächst
die ECA-Auswertung zu einer strikten Funktion mit dem Unerreichbarkeitszustand
Ωerweitert und dann die ECA-Regeln um Alternative Aktionen AA angereichert. Der Einsatz und Vorteil dieser erweiterten ECA-Regeln wird am Beispiel der Erhaltung der Datenkonsistenz in verteilten aktiven Datenbank-systemen gezeigt.

Der Softwareentwicklung fehlt oft eine detaillierte methodische Unterstützung von technischen Softwareentwicklungsaktivitäten. Eine Autorin dieses Papiers hat das Konzept der Agenda entwickelt, das zum Ziel hat, Softwareentwicklungs-wissen als "methodische Essenzen" von Softwareentwicklungsaktivitäten
explizit zu repräsentieren. Zur logischen Modellierung von Anwendungswelten aus Benutzersicht wird eine Agenda entwickelt, die es erlaubt diese Anwendungswelt methodisch in Konzepten der Handlungspsy-chologie zu erheben.

Das Universitätsrechenzentrum der Friedrich-Schiller-Universität Jena, speziell der Bereich Multimedia- und Teledienste, befasst sich mit der Übertragung und Bearbeitung von Audio-Video- bzw. Grafikdaten in Netzwerken. In den letzten Jahren wurden verschiedene Konzepte für:
- Teleteaching,
- Teleseminare,
- OP-Übertragungen im medizinischen Bereich und
- Videokonferenzen
entwickelt und erfolgreich in die Praxis überführt.
Heute ist die FSU Jena eine der Universitäten, welche das Teleteaching-Konzept im regulären Studienbetrieb in Zusammenarbeit mit der TU Ilmenau und der BU Weimar einsetzt.
Bei den aufgeführten Systemen handelt es sich um synchrone Systeme mit getrenntem Grafikkanal. Da bei diesen Systemen eine hohe Qualität der Audio- Videoübertragung notwendig ist, werden die Daten in MPEG-2 encodiert dann im IP Netz übertragen.
Voraussetzung dafür ist aber die dazu notwendige Kapazität der Datenleitungen. Diese ist zwischen den Universitäten, bedingt durch das G-WiN, garantiert.
Viele universitäre Veranstaltungen haben aber andere Zielgruppen als bei einem Teleteaching Verbund. Internationale Kongresse und auch viele Lehrveranstal-tungen können und sollten einem breiten Nutzerkreis zugänglich gemacht werden. Dabei wird kein besonderer Wert auf eine bidirektionale Kommunikation gelegt(wie sie im synchronen Teleteaching-Systemenunabdingbar ist), sondern eine Verteilung an viele Interessenten mit unterschiedlichen Datenanschlüssen. Die Qualität sollte dabei dem Übertragungsmedium angepasst sein.

Der vorliegende Praxisbericht beschreibt exemplarisch die Vorgehensweise bei der Implementierung einer vorhandenen Datenstruktur in XML am Beispiel eines Produkthandbuches. Besonderes Augenmerk wurde dabei auf die Medienneutralität der Rohdaten, den Export der Daten im XML–Format und die Möglichkeiten der Anreicherung der Rohdaten mit Darstellungsinformationen gelegt. Der Bericht fasst die gesammelten Erfahrungen zusammen und beleuchtet die eingesetzten Technologien.

Im folgenden Beitrag werden ausgehend von der Definition der Begriffe Dienst, Dienstmanagement und Dienstkonfiguration Anforderungen an ein experimentelles Architekturmodell für die Untersuchung unterschiedlicher Realisierungsaspekte eines Konfigurationsmodells für Dienste aufgestellt. Anhand dieser Anforderungen wird eine konkrete Modellarchitektur vorgestellt, die eine flexible Betrachtung unterschiedlicher Modellbestandteile sowie deren Implementierung ermöglicht.

Providing Quality of Service (QoS) is a challenging issue especially in the heterogeneous wireless network environment. Traffic scheduling is considered as the key mechanism to support QoS with respect to protection of flows and fair allocation of the limited link bandwidth. However, scheduling schemes developed for wired networks can not be directly applied to wireless networks due to bursty and location-dependent channel errors. In this paper, we propose a scheduling scheme called Packetized Wireless Scheduler (PWS) for providing both fairness and protection. The key idea of PWS is to keep track of the channel state and to compensate the flows which have received less service due to poor quality of their wireless channel. Since our scheme uses a portion of the link bandwidth for giving an extra compensation service, our scheme can achieve fairness guarantees and protection to individual flows. Furthermore, this bandwidth portion facilities the handoff while making efficient use of the link bandwidth.

In diesem Paper werden Prozesse und Szenarien zum Einsatz von UDDI in B2B-Systemen aufgeführt. Des Weiteren wird verdeutlicht, weshalb UDDI zu einer Zunahme des B2B-Momentums führen kann.

Das Lightweight Directory Access Protocol (LDAP) entwickelt sich ähnlich dem Hypertext Transfer Protocol (HTTP) zu einem Basisprotokoll für Internetanwendungen mit breiter Unterstützung durch die Anbieter und Hersteller. Inspiriert durch dieses Integrationspotential entwickeln sich
Verzeichnisdienste immer mehr zu Kernkomponenten für internetbasierte
Informations- und Kommunikationsinfrastrukturen. Detaillierte Analysen und
erste Erfahrungen bei der Bereitstellung einer solchen Infrastruktur lassen
konkrete Rückschlüsse auf den Entwurf von integrierenden Verzeichnisstrukturen im Umfeld einer Hochschule zu.

In diesem Artikel wird eine Möglichkeit zur formalen Beschreibung der Verarbeitung von XML-Dokumenten vorgestellt. Auf dieser Basis wird ein
Vorschlag für die Architektur eines System zur XML-Bearbeitung entwickelt.

The Unified Process (UP) has emerged as a popular modern process for software development_ and with good reason, as it includes skillful best practices such as iterative and adaptive incremental development, and early attention to high-risk and high-value issues. Furthermore, the UP encourages flexible adoption within its process framework, providing a structure that can scale up to projects involving hundreds of developers, or down to projects of just a few.
Contrary to some misperception, the UP encourages a light approach. Knowing and adopting the critical elements of the UP, avoiding some common misunderstandings, and reducing attention to its many optional elements, are keys to its successful_and agile _application. In this tutorial you will learn the essential and most useful UP concepts and practices, the keys to its successful introduction in an organization, and how to apply the UP in an adaptive and agile spirit.
Topics include:
_ The key UP ideas to know and apply.
_ The motivation and business case for the UP.
_ What UP artifacts are really worth creating?
_ UP anti-patterns: common worst-practices in adoption and use.
_ How to adopt the UP within an organization.

Continuing from the morning tutorial_s introduction to key UP ideas and practices, the afternoon session examines more high-impact topics for success with the UP.
For example, many Extreme Programming (XP) practices and values are either part of the UP, or specializations of more general UP guidelines. What are these, and which may be adopted consistent with and within a UP project? Nevertheless, this tutorial motivates the need for more than pure XP on many projects, and promotes the skillful capacity of the UP to provide a variety of optional practices and artifacts on larger or higher-ceremony projects. You will learn why a combination of primarily the UP with some XP practices is an excellent process approach.
You will learn about the following:
_ XP practices within the UP.
_ Challenges of pure XP.
_ How to plan an iterative UP project.
_ Tips for good UP artifacts and models.

In den letzten Jahren ist die Bedeutung der Thematik "`XML und Datenbanken"'
ständig gestiegen. Viele Workshops, Diskussionsrunden, Veröffentlichungen
und Sonderhefte von Zeitschriften standen und stehen unter dem Titel.
Gleichzeitig ist das Gebiet sehr dynamisch und es gibt ständig zahlreiche Neu- und Weiterentwicklungen.
In diesem Tutorial wollen wir verschiedene Ansätze, Veröffentlichungen und
Implementierungen vorstellen, sie klassifizieren und einordnen. Einige
Schwerpunkte werden die Speicherung von XML-Dokumenten, Indizierungsverfahren,
Anfragesprachen für XML-Dokumente, sowie das Generieren von XML-Dokumenten
aus Datenbanken sein.
Ausgehend von einer Klassifikation von XML-Dokumenten wird ein allgemeines
Architekturmodell für XML-Anwendungen entwickelt.
Auf dieser Architektur aufbauend werden verschiedene Verfahren zur Speicherung
von XML-Dokumenten vorgestellt.
Die dabei eingesetzten Verfahren sind teilweise an Verfahren aus den Bereichen
Datenbanken und Dokumentenverarbeitung angelehnt.
Darüber hinaus haben sich auch neue Verfahren etabliert, die speziell auf XML-Anwendungen zugeschnitten sind.
In dem Tutorial wird eine Systematisierung der zahlreichen bekannten Ansätze zur Speicherung von XML-Dokumenten entwickelt.
Indexstrukturen für XML-Dokumente werden ebenfalls vorgestellt.
Eng mit der Speicherung von XML-Dokumenten verbunden, sind Anfragen an die gespeicherten Dokumente.
Ausgehend von generellen Anforderungen an Anfragesprachen werden die
Erfordernisse für spezielle XML-"Anfragesprachen dargelegt.
Mit XQuery wird ausführlich der absehbare Standard im Bereich Anfragesprachen vorgestellt.
Einige der vorgestellten Verfahren benötigen explizit angegebene
Schemainformationen zur Speicherung der XML-Dokumente.
Die konzeptuelle Modellierung von Schemata ist deshalb ein weiteres Thema des
Tutorials.
Die Speicherung von XML-Dokumenten ist nicht die einzige Verbindung der Gebiete XML und Datenbanken.
Viele XML-Dokumente sollen aus Daten generiert werden, die in Datenbanken
gespeichert sind, für diese Aufgabe stehen ebenfalls verschiedene Verfahren zur Verfügung.
Es gibt eine ganze Reihe von kommerziellen Systemen zur Verwaltung und zur Speicherung von XML-Dokumenten von XML-Datenbanken bis hin zu XML-Datentypen objekt-relationaler Datenbanken, diese werden im Detail vorgestellt.
Das Tutorial wird einen umfassenden Einblick in das sehr dynamische Gebiet
"'XML und Datenbanken"' geben.

Agent systems are becoming increasingly popular and there are a number
of agent development platforms that support building of agent
systems. This tutorial will enable participants to become familiar
with a design methodology for building such systems, that has been
developed as a result of industrial and pedagogical needs.

The methodology covers all stages of SW development - specification,
architectural design, detailed design, implementation, testing and
modification. This tutorial will focus primarily on the specification
and design stages.

The specification and architectural design phases are quite generic
and applicable to any kind of agent system. Focus is on goals and
scenarios, groupings of functionalities into agents, communication
protocols and overview of the system.

The approach to design is hierarchical allowing the designer to work
at arbitrarily many levels of abstraction, making the methodology
easily scalable for large systems.

The detailed design techniques are developed specifically for BDI
style systems such as JACK, PRS, JAM and dMars. In detail design we
look at design of the capabilities the individual agents require. At
this level we cover design of plans, events and data. We have
developed a graphical documentation style which allows the designer to
clearly organise the relationships between events, plans and data, and
to visualise how these work together to achieve the agent goals.

A common problem when new users start to use an agent development
environment is that the code they write does not really fit the agent
paradigm and does not make use of the power available in the system.
The design methodology taught in this tutorial will assist developers
to understand and think within the agent paradigm, thus obtaining
greater benefit from the agent development environments which they
use.

The tutorial will contain practical work where participants work through
examples of the different design stages. Due to time constraints some
stages will be covered in less detail than others.

Enterprise Application Integration (EAI) und Enterprise Nervous Systems (ENS) sind Technologien, die heute zum Baukasten eines Software-Architekten auf Unternehmensebene gehören. Neben erheblichen Kostensenkungs- und Beschleunigungspotentialen durch den Einsatz dieser Technologien gibt es aber auch Risiken, die durch einen falschen oder nicht angepassten Einsatz von EAI und ENS entstehen.
Das Tutorial konzentriert sich auf genau die Aspekte von EAI und ENS, die Profis benötigen, um sich schnell einzuarbeiten und einen Überblick über das Thema zu bekommen
Wenn Sie das Tutorial besucht haben, kennen Sie:
 wichtige Anwendungsfelder, bei denen es sich lohnt, mit Methoden der EAI zu arbeiten
 die wesentlichen Felder von Architekturentscheidungen, bei denen Sie sich festlegen müssen, wenn Sie eine EAI-Lösung für Ihr Unternehmen entwerfen wollen
 wesentliche Features von Integrationsservern
 zwei Fallstudien und einen Vergleich zwischen einer selbstgebauten EAI-Lösung und einem High-End-Produkt.
 die Bedeutung von .NET und J2EE für EAI
 die Rolle von Web Services in EAI-Konzepten
 "Sales-Lines" von EAI- und ENS-Verkäufern
Das Tutorial wendet sich vor allem an IT-Manager, die über den Einsatz von EAI Technologien entscheiden, an Unternehmensarchitekten, die dafür die Umsetzungspläne entwerfen, sowie an Softwarearchitekten und -designer.

Web development is the cool new paradigm. How do we stop ourselves from
forgetting the lessons of previous paradigms and just hacking our way
through?
The web's core mechanisms lend themselves all too easily to cut-and-paste
re-use, ad-hoc scripts, direct-to-database code, and fragmented business
logic. In the name of time-to-market, too many of us abandon what we know
and take the path of least resistance. There are capable and articulate people
telling us this is exactly what we should be doing.
We believe, that the lessons of objects do apply to the web. If we apply
them wisely we can have good time-to-market for version 1.0, ship version 2.0
successfully, and improve the user experience along the way. But it's not
obvious how to apply these lessons. What, if anything, is MVC for the web?
What are the architectural layers? How do we support multiple channels
within these layers, when presentation differences can easily creep into the
domain logic? What about EJB?

This tutorial surveys current web technologies with an emphasis on OO
usage, provides best practices and examples from Java and Smalltalk, discusses
myths and truths about components, and describes architecture and development
practices that support good practices.

OO Remoting frameworks play a vital role in the IT industry. They come in different flavours, most prominently CORBA, DCOM, .NET Remoting and, most recently, XML webservices.
While each of these technologies use different APIs, protocols or implementation techniques, they are all based on the same patterns. From a high-level view, they all implement the Broker pattern described in the POSA1 book. However, a closer view on the subject reveals several finer grained patterns around the areas of quality of services, remoting framework design, asynchronous invocations, and more.
This tutorial presents a collection of about 40 patterns describing how these oo remoting middlewares work. It also provides real-life examples using CORBA, .NET remoting and webservices.
The tutorial will introduce the patterns one by one, and illustrate them using examples from the mentioned technologies. This provides a step-by-step introduction to the internals of the full-fledged remoting frameworks in use today.

Web Services is one of the hot areas in web technology supporting the remote invocation of business functionality over the Internet through message exchange. Research activities as well as industrial developments focus on implementing the mechanisms required for remote invocation and automation of Web Services (using standards such as UDDI, WSDL, X-lang, WSFL, e-speak, .NET etc). Concurrently, the idea and vision of the Semantic Web is catching on and researchers as well as companies have started to realize the benefits of this great vision, which includes ontologies that allow machine-supported data interpretation.

While both efforts are very powerful in themselves, their combination, termed Semantic Web enabled Web Services (SWWS) opens tremendous possibilities. Web services will transform the web from a static collection of information into a distributed device of computation. Semantic Web technology makes the World Wide Web machine-interpretable. Semantic Web enabled Web Services, such as the DAML-S effort, will allow the automatic Discovery, selection and execution of inter-organization business logic making areas like dynamic supply chain composition a reality.

This tutorial brings together theories, challenges, issues, languages and tools from the Semantic Web, Web Services and Agent Technology. We will present the current state of the art in Web-Based Services and sort through the increasing array of relevant tools, languages and theories both from academia and industry. The tutorial includes an exploration of the following:

* Current state of the art in web service research and industrial
standards.
* Vision and implications of the Semantic Web and Web Service symbiosis.

* Exploration of the current work and approaches to SWWS

Overview

* Introduction to the Semantic Web and Web Services
* Web Services: The Vision & Truth
* Web Services Modeling Framework
* Semantic Web Enabled Web Services: DAML-S
* Mediation & Matchmakign
* Advertising Services
* Service Process Description & Invocation
* Discussion & Wrap Up

1.Gliederung
•Einleitung und Motivation
•Einführendes Beispiel
•Struts Details
•Beispiel und Realisierung
•Bewertung
•Zusammenfassung

2.Inhalt
Das Tutorial zeigt an ausgewählten Beispielen, die Erstellung von einfachen Web-Anwendungen unter Verwendung des JSP Frameworks Struts und weiterer Tools.
Struts ist ein Framework der Open Source Projekte der Apache Foundation.
Das Framework unterstützt und vereinfacht die Entwicklung des Controllers und der View. Die Entwicklung der Business-Logik wird von Struts nicht beeinflusst.

Der Tradition von Kernighan & Ritchie folgend, beginnt der praktische Teil mit dem „Hello World„ Beispiel.
Im weiteren Ablauf des Tutorials werden folgende Punkte im Struts Kontext behandelt:
•Grundlagen
•MVC (Model View Controller)
•Designpattern
•JSPs, JavaBeans und Taglibs
•Integration mit EJB

•Nutzung von JNDI und JDBC
•Konfiguration
•Erweiterungen für eigene Anwendungen
•Interne Architektur

Nach der Einführung wird an Hand realer Beispiele der Einsatz von Struts demonstriert. Dazu werden Lösungen unter anderem für folgende Geschäftsanforderungen entwickelt:
•Bereitstellung von Content
•Abrechnung
•Personalisierung
Hierfür werden JSPs, Taglibs (eigene als auch Struts Taglibs) und JavaBeans für die Präsentationsschicht verwendet. Die Web-Anwendung wird durch die Anbindung des Business und Resource-Tiers mit JNDI und JDBC vervollständigt.
Zum Abschluss wird der Einsatz von Struts unter den technischen Kriterien (Sicherheit, Wartbarkeit, Erweiterbarkeit und Architektur), den Nutzungskriterien (Einarbeitung, Einfachheit) und den Qualitätskriterien (Robustheit, Performance) bewertet.

3.Einordnung
•Level : Intermediate, grundlegende Kenntnisse der Anwendung von JavaServer Pages und Servlets werden erwartet
•Zielgruppe : Designer , IT Berater , technische Projektleiter , Java Developer
•Sprache: deutsch

In jüngster Zeit konnten sich Anwendungen der Extensible Markup Language (XML) im Markt breit etablieren. Die mit der generischen Metasprache XML definierten Vokabulare und Sprachen finden Einsatz vom Datenaustausch bis hin als native
Applikationsdatenspeicherungsform.
Ausgehend vom Primärstandard des World Wide Web Consortium (W3C) entwickelt sich derzeit ein dynamisches Geflecht ineinander verzahnter und aufeinander aufbauender Standards.
Den, gemessen an seiner Wirkungsmacht, wichtigsten Standard dürfte "XML Schema" darstellen, der zu Grundlage der XML-Sprachen der zweiten Generation wurde.
Ausgehend von dieser XML-Sprache zur Definition eigener XML-Sprachen stehen wir derzeit einer Entwicklung des Internets in eine neue Anwendungsform gegenüber. Nach den ausschließlich textbasierten Anwendungen der Frühzeit (etwa: Telnet, FTP, Gopher, ...), dem darauf folgenden Übergang zur Übertragung zum präsentationsorientierten Datentransfer durch die Entwicklung des World Wide Web bewegen wir uns heute hin zu einer zunehmend interaktiven pervasiven und in
letzter Konsequenz nicht mehr sichtbaren Applikationform deren erste Anzeichen heute in den Frühformen dienstorientierter Angebote zu sehen sind.