Abstract: An important problem in designing infrastructure tosupport business-to-business integration (B2Bi) is how to cancel along-running interaction (either because the user has changed theirmind, or in response to an unrecoverable failure). We review thefault-handling and compensation mechanism that is now used in mostworkflow products and business process modelling standards. Wethen use an e-procurement case-study to extract a set of requirementsfor an effective cancellation mechanism, and we show that thestandard approach using fault-handling, and compensationtransactions is not adequate to meet these requirements.

Abstract: While developments in distributed object computing environments, such as the Common Object Request Broker Architecture (CORBA) by the Object Management Group (2000) and the Telecommunication Intelligent Network Architecture (TINA) by H. Mulder (2002), have enabled interoperability between domains in large open distributed systems, managing the resources within such systems has become an increasingly complex task. This challenge has been considered for several years within the distributed systems management research community and policy-based management has recently emerged as a promising solution. Large evolving enterprises present a significant challenge for policy-based management partly due to the requirement to support both mutual transparency and individual autonomy between domains according to C. Bidan and V. Issarny (1998), but also because the fluidity and complexity of interactions occurring within such environments requires an ability to cope with the existence of multiple, potentially inconsistent policies. This paper discusses the need for providing both dynamic (run-time) and static (compile-time) conflict detection and resolution for policies in such systems and builds on our earlier conflict detection work (Dunlop et al., 2001, 2002) to introduce the methods for conflict resolution in large open distributed systems.

Abstract: Model-driven architectures (MDA) separate the business or application logic from the underlying platform technology and represent this logic with precise semantic models. These models are supposed to span the entire life cycle of a software system and ease the software production and maintenance tasks. Consequently, tools will be needed that support these tasks. In this paper, we present a method that implements model-driven transformations between particular platform-independent (business view) and platform-specific (IT architectural) models. On the business level, we focus on business view models expressed in ADF or UML2, whereas on the IT architecture side we focus on service-oriented architectures with Web service interfaces and processes specified in business process protocol languages such as BPEL4WS.

Abstract: The MOF (Meta Object Facility) query, view and transformation RFP, issued by OMG will result in a key enabling technology for model-driven development of large distributed systems. We have designed a transformation language which will meet the requirements of this RFP, and several others besides. The language is declarative and patterns based. Transformation descriptions are explicitly reusable and modular. Rules that make up such descriptions may be aspect-driven, allowing for transformations to be written to address semantic concepts rather than structural features. This paper introduces the language and its rationale, and shows how it is used to solve s small but non-trivial MDA problem.

Abstract: The research vision of the Unified Component Meta Model Framework (Uniframe) is to develop infrastructure for components that enables a plug and play component environment where the security contracts are a part of the component description and the security aware middleware is generated by the component integration toolkits. That is, the component providers will define security contracts in addition to the functional contracts. These security contracts will be used to analyze the ability of a service to meet the security constraints when used in a composition of components. A difficulty in progressing the security related aspects of this infrastructure is the lack of a unified access control model that can be leveraged to identify protected resources and access control points at the model level. Existing component technologies utilize various mechanisms for specifying security constraints. This paper will explore issues related to expressing access control requirements of components and the resources they manage. It proposes a platform independent model (PIM) for the access control that can be leveraged to parameterize domain models. It also outlines the analysis necessary to progress a standard transformation from this PIM to three existing platform specific models (PSMs).

Abstract: Setting up electronic business-to-business relationships is time-consuming and costly. It has been eased to a certain extent by standard such as RosettaNet, which use XML and XML Schema technologies to define standardized syntax messages used in interactions. However, this standardization has necessarily maintained some flexibility to allow companies with different internal processes to comply with the standard. Furthermore, the standard is syntactic, rather than semantic. Semantic constraints on interactions are currently represented informally. In this paper, we describe an application of Semantic Web technology to enhance RosettaNet and further reduce cost and time. Businesses can represent the possible ways they are able to interact as semantic and syntactic constraints. Two businesses can determine if they are able to without altering their business process by sharing constraints, and finding if the overall set is satisfiable. If it is not, they can use the data to determine what changes need to be made to their business processes. They can also use the other business' constraints to verify or generate documents which meet the constraints, and so are usable by the other business. The system integrates with current RosettaNet standards and tools through the use of a translation suite able to transform XML Schema into DAML+OIL and XML into RDF.

Abstract: As the desire for business intelligence capabilities for e-business processes expands, existing workflow management systems and decision support systems are not able to provide continuous, real-time analytics for decision makers Business intelligence requirements may appear to be different across the various industries, but the underlying requirements are similar nformation that is integrated, current, detailed, and immediately accessible In this paper we introduce an agent-based architecture that supports a complete business intelligence process to sense, interpret, predict, automate and respond to business processes and aims to decrease the time it takes to make business decisions In fact, there should be almost zero-latency between the cause and effect of a business decision Our architecture enables analysis across corporate business processes notifies the business of auctionable recommendations or automatically triggers business operations, effectively closing the gap between business intelligence systems and business processes

Abstract: This paper aims at demonstrating the benefits and importance of the service concept in the model-driven design of distributed applications. A service defines the observable behaviour of a system without constraining the system's internal structure. We argue that by specifying application-level interaction aspects as a service, and designing application parts is not constrained by interaction patterns provided by a middleware platform. Therefore, a level of platform-independence can be achieved, so that the design of application parts can be reused across a large set of middleware platforms. The service concept is also used in our approach to describe an abstract platform that defines what characteristics of a potential target middleware platform are considered in platform-independent design. We discuss the trade-offs a designer is confronted within the definition of an abstract platform, and discuss alternatives for platform-specific realization.

Abstract: An important problem in designing infrastructure to support business-to-business integration (B2Bi) is how to cancel a long-running interaction (either because the user has changed their mind, or in response to an unrecoverable failure). We review the fault-handling and compensation mechanism that is now used in most workflow products and business process modeling standards. We then use an e-procurement case-study to extract a set of requirements for an effective cancellation mechanism, and we show that the standard approach using fault-handling, and compensation transactions is not adequate to meet these requirements.

Abstract: Distributed system design is a highly complicated and non-trivial task. The problem is the characterised by the need to design multi-threaded, multi-processor, and multimedia systems. Design frameworks such as open distributed processing (ODP), the ITU/ISO standard, define a number of viewpoints from which the design of a distributed system should be approached. To use the framework, a design language for each of these viewpoints must be defined. This paper defines a computational viewpoint language based on the Unified Modelling Language (UML) and Component Quality Modelling Language (CQML). The use of this approach to provide the ODP viewpoint languages enables standard UML tools to be used as part of an ODP compliant design process; and in addition, it will potentially enable the use of Meta Object Facility (MOF) based generation tools for constructing tool support for our language.

Abstract: The architectural design of distributed enterprise applications from the viewpoints of different stakeholders has been proposed for some time, for example, as part of RM-ODP and IEEE 1471, and seems now-a-days to gain acceptance in practice. However, much work remains to be done on the relationships between different viewpoints. Failing to relate viewpoints may lead to a collection of viewpoint models that is inconsistent, and may therefore lead to an incorrect implementation. This paper defines an approach that helps designers to relate different viewpoints to each other. Thereby, it helps to enforce the consistency of the overall design. The results of this paper are expected to be particularly interesting for Model Driven Architecture (MDA) projects, since the proposed models can be used for the explicit definition of the models and relationships between models in an MDA trajectory.

Abstract: Distributed systems are inherently complex, and therefore difficult to design and develop. Experience shows that new technologies - such as components, aspects, and application frameworks - can be effectively used for building distributed applications. However, our experience also shows that most of the applications built in that way are difficult to be re-used, documented, and maintained. Probably, one of the major reasons is the lack of a clear separation between the concepts used at different levels (application domain, application architecture, supporting application platform, programming language, etc.). In this paper we present our experience with a platform we developed for building distributed applications using components and aspects. In particular, we show how many of the (conceptual) problems we hit when trying to document, re-use, and implement it in different contexts can be naturally solved with te adoption of the MDA concepts. In addition, we describe the process we followed for identifying and separating the entities that live in different "models" (in the MDA sense), and the required transformations between them. MDA offers a good framework for specifying different views of our model, and mappings to platform-specific profiles. In this way, we are able to address the particular needs of different stakeholders: from the designer interested in developing new applications following our (component and aspect-based) modeling approach, to the software vendor that wants to implement a propriety version of our supporting middleware framework in CORBA, EJB or .NET.

Abstract: Component-based software engineering, separation of concerns, model-driven architecture, and aspect-oriented programming are four active research areas tat have been around for several years now. In this paper, we present how these four paradigms can be put together in the context of a new software development method and we show how they can complement each other are different stages in the development life-cycle of enterprise, middleware-mediated applications. Different software development methods, such as Fondue, Catalysis, KobrA, and the Rational Unified Process, are also analyzed, pointing out their differences and limitations. In the end, requirements for a dedicated tool infrastructure that would support the new development approach are discussed.

Abstract: Integrating business and information technology (IT) is essential for enterprises to be competitive. The integration of business and IT forces project teams to analyze and design a hierarchy of systems such as: groups of companies collaborating in business systems, people and IT systems collaborating in business processes, software components collaborating in IT systems, and programming language objects collaborating in software components. The current tools, and in particular MDA, have not been tailored for the design of hierarchical systems. As a result the project teams have difficulties designing integrated business and IT systems. In this paper we present a technique for supporting the design of hierarchical systems. We were inspired by Miller's general theory of living system, a theory that addresses the analysis of hierarchical living systems. We provide concrete guidelines on how to introduce levels in UML-based system modeling, in general, and in MDA in particular. This allows the project team to develop one, common, integrated enterprise (or project) model. This in turn enables the different specialists to reason about and design business and IT systems that are truly integrated. The overall benefit is an increase in the project success rate.

Abstract: In this paper we sketch a framework supporting contract enactment within the context of virtual organisation units that are dynamically created in order to achieve a common objective by securely sharing resources, services and information. The framework is built on top of a joint extension of the policy deployment architecture for peer-to-peer communities (Dimitrakos et al., 2002) and the contract enactment capability (Milosevic et al., 2002) that enables monitoring, mediation, arbitration and enforcement of electronic contracts in multiple, simultaneous closed collaborations. A longer-term goal is to deliver a scalable method of setting up contract enforcement and contract performance management infrastructures for interorganisational information systems that allow the on-demand creation and dynamic evolution of secure virtual organizations based on the ad-hoc integration of systems across enterprise boundaries.

Abstract: One of the most significant limitations of current middleware platforms, both commercial and research, is that they typically support only a small, pre-defined, set of fundamental binding types (e.g., remote method invocation). This restriction limits the scope of platforms in that they cannot easily accommodate, or easily be extended to accommodate, richer or more specialized forms of interaction (e.g. events, media streaming, multicast, and many others discussed in the paper). This paper describes a highly extensible, component-oriented framework for the definition and implementation of such binding types. We motivate and specify the framework in detail and evaluate it by providing examples of its use.

Abstract: The expression of contracts in computer readable form, and the development of automated tests for completeness and well-formedness of contracts, has opened the door to significant advances in automating contract negotiation. To meet the needs of automation, such negotiations must follow explicitly specified message-exchange protocols. But to meet the needs of the negotiating parties, these protocols must be independent of the decision-making processes driving them as well as neutral to the outcome of the negotiations. In this paper we illustrate how both needs may be simultaneously met by a small set of conversation policies employed within a general purpose conversation support architecture.

Abstract: Large-scale information processing environments must rapidly search through massive streams of raw data to locate useful information. These data streams contain textual and numeric data items, and may be highly structured or mostly freeform text. This project aims to create a high performance and scalable engine for locating relevant content in data streams. Based on the J2EE Java Messaging Service (JMS), the content-based messaging (CBM) engine provides highly efficient message formatting and filtering. This paper describes the design of the CBM engine, and presents empirical results that compare the performance with a standard JMS to demonstrate the performance improvements that are achieved.

Abstract: The Meta-Object Facility (MOF) provides a standardized framework for object-oriented models. An instance of a MOF model contains objects and links whose interfaces are entirely derived from that model. Information contained in these objects can be accessed directly, however, in order to realize the Model-Driven Architecture@trade; (MDA), we must have a mechanism for representing and evaluating structured queries on these instances. The MOF Query Language (MQL) is a language that extends the UML's Object Constraint Language (OCL) to provide more expressive power, such as higher-order queries, parametric polymorphism and argument polymorphism. Not only do these features allow more powerful queries, but they also encourage a greater degree of modularization and re-use, resulting in faster prototyping and facilitating automated integrity analysis. This paper presents an overview of the motivations for developing MQL and also discusses its abstract syntax, presented as a MOF model, and its semantics.

Abstract: This paper presents an approach to support the MDA like design of component based distributed applications through the provision of a suitable MOF based modeling infrastructure. This infrastructure is open to a variety of modeling techniques and features the transformation of models based on different meta models. As a concrete example, we will show how EDOC and CCM can be integrated with this modeling infrastructure and consequently how EDOC models are transformed to CCM models.

Abstract: This paper contributes to service level management of complex Web-based e-business environments using WBEM/CIM. Such e-business environments usually consist of Web servers and Web containers to realize client access, and EJB containers or CORBA components for modeling the application business logic. Since the DMTF does not define a model providing a unified view upon such complex environments, the definition of a management information model is the core part of the work presented. Currently, the information model mainly focuses on performance aspects, like application response times, which are integral part of many SLAs. The paper also presents a framework that was developed to efficiently implement the information model. The framework increases the portability of CIM providers, which are responsible for retrieving management information, between different CIMOMs by providing an abstraction layer. In addition, the framework simplifies the development of providers by offering support for caching etc.

Abstract: The aspect integrator platform (AIP) from ABB was designed to build the next generation of industrial automation applications. This platform is part of a set of products that provide the means to model, control and supervise continuous or discrete processes in various market domains, ranging from chemical and metal to paper and consumer industries. Each product works at a different level in the manufacture process, but all of them rely on a common architecture for interoperability. The current AIP architecture provides considerable flexibility in terms of modeling domain information and dynamically modifying it at run-time. This flexibility imposes further requirements on the installation and maintenance of applications because dependencies among its components change dynamically. In this paper, we study the different kind of dependencies that can arise between components and show them in the context of an example from automotive industry. We show how dependency tracking and consistency of domain information can be supported by representing the actual platform concepts in XML due to the structuring and validation properties of XML schemas.

Abstract: Market drivers to deliver software-based business solutions faster and cheaper have promoted the evolution of software system architectures toward assemblies of encapsulated components offering well-defined services - a service-oriented architecture. Software vendors are eager to adopt and exploit new technologies, such as XML and Web services, to meet the market demands, but face significant challenges due to their existing software asset base and entrenched development processes. This paper presents a case study of the use of a methodology and toolset, known as CAIDE (Computer Aided Interface Design Environment), developed to address these challenges for a complex family of telecommunications applications. Our main objective was to provide a simple but expressive high-level meta-model for specifying system interfaces, and to automatically generate XML schemas for the interfaces consistently across the application family, constraining the use of schema constructs according to enterprise-wide policies, and promoting reuse by composition.

Abstract: Today's autonomous and heterogeneous information systems have an increasing necessity of exchanging data. As widely known, middleware systems have been successfully adopted as infrastructure for communicating those systems. In addition to provide basic communication services, however, the necessity of bringing together business services to the middleware is apparent in many domain-specific applications. In this context, we propose a MOM (message oriented middleware)-based solution for remote monitoring of equipment for maintenance of mines. This solution is actually under operation and has been developed with the sponsorship of Modular Mining System/spl copy/, world's leader in mine management technology, and incorporates particular requirements of the communication between mining companies and equipment manufacturers, whilst it takes advantages of the communication model of MOM.

Abstract: This paper investigates the problem of authoring the construction of large distributed enterprise applications form high-level specifications of business logic. How far can we go on trying to apply a model centric approach as the one promoted by the OMG, the Model Driven Architecture? This is the basic question to which we try to bring some partial answers. For this purpose the paper presents an experiment that consists of providing concrete implementations of EDOC/ECA specifications by the Object Management Group (2002) on top of the OpenCCM middleware platform by Object Management Group (2002) and OpenCCM. The roles played by aspect modeling and platform modeling will be discussed. A framework for automating the projection of business specifications into executable code has been defined and implemented. It involves the usage of distinct technologies such as pure meta-modeling, model transformation and the appliance of PAC-AMMODEUS principles by L. Nigay (1994) - presentation, abstraction, control - to achieve software construction in an efficient and innovative way.

Abstract: The paper describes a CORBA components based service development environment and reports important lessons learned from service design, implementation and usage. A declared project goal was to evaluate service programmability, speed and flexibility in the creation of complex services based on simple building blocks. We implemented an OSA/Parlay gateway with a Parlay call control interface to control a SIP (session initiation protocol) proxy. A Parlay framework performs registration, trust and security, discovery, service agreement management, service profiling and subscription tasks. The software is implemented in Java using CORBA component model (CCM). User profiling and service chaining possibilities are extensively used in a complex scenario including external voice server, Web based groupware and call setup functionality provided via Parlay APIs (application programming interface).

Abstract: Dynamic evolution is an important phenomenon in distributed systems that undergo changes without being shut down. Examples include 24x7 global financial market systems and mobile phone switching networks. Building and keeping these systems operational requires sound software engineering techniques since system unavailability is extremely expensive and is often prohibited in many business contexts. In this spirit, we present temporal extensions to the UML (Unified Modeling Language) notation to incorporate design concerns for dynamic evolution in distributed system development. In the system structure space, this paper introduces the temporal system structure, the transformational association, the transformational link, and the state transfer map to relate successive changes to each other. In the transformation space, this paper introduces the use of exclusion control to regulate and maintain service continuity during a transformation, and the transformation diagram to specify a transformation per se with respect to time.

Abstract: Collaboration in a business system requires a business process specification defining the procedure of the business scenario. The business process specification is generated from a business process model. ebXML, which is the XML-based B2B standard framework for organizations of any size using the Internet, recommends process analysts and modelers to use the UN/CEFACT (United Nations Centre for the Facilitation of Procedures and Practices for Administration, Commerce and Transport) Modeling Methodology (UMM). The artifacts of the modeling are UML (Unified Modeling Language) diagrams and worksheets. They can be transformed into an ebXML business process (BP) specification and other business models. The artifacts and transformed results are registered in the business library for being shared with ebXML systems and being re-used in other modeling tools. This paper reports on our implementation of an ebXML BP modeling toolkit that accepts the architecture suggested in the ebXML and considers the required functions of modeling. These functions include modeling business processes based on UMM, generating a BP specification, transforming the processes using a metaframework, and registering them in the ebXML registry. The business process modeling toolkit is made up of the business process modeler, business process editor, and built-in registry client. The business process modeler not only models the business process with UML diagrams but also generates the business process specification, reverses it, and exports XMI of the business process. The business process editor is used only for editing the business process specification. The built-in registry client stores the business process model, the business process specification, or the XMI document, and searches and loads them.

Abstract: This paper compares two separately developed systems for monitoring activities to business contracts, describes how we integrated them and exploits the lessons learned from this process to identify a core set of requirements for a Business Contract Language (BCL). Concepts in BCL needed for contract monitoring include: the expression of coordinated concurrent actions; obliged, permitted and prohibited actions; rich timeliness expressions such as sliding windows; delegations; policy violations; contract termination/renewal conditions and reference to external data/events such as change in interest rates. The aim of BCL is to provide sufficient expressive power to describe contracts, including conditions which specify real-time processing, yet be simple enough to retain a human-oriented style for expressing contracts.