Abstract: IBM Pattern-based Process Model Accelerators for WebSphere Business Modeler provide users of this tool with a set of plug-ins that add patterns, transformations and refactorings to the business process modeling environment. In addition, a feature to automatically detect control-flow errors is now available. By using the accelerators users can move away from a traditional business process modeling approach where process models are drawn by dragging and dropping elements on the drawing canvas that are then manually connected. The accelerators make it possible to create business process models of higher quality by composing them from larger building blocks or by applying semantically correct change operations to a model with a single click. Models will contain significantly less modeling errors, modeling becomes a much more fun exercise and users will experience productivity gains of about 70 % compared to the traditional approach.

Abstract: Precision and consistency are important prerequisites for class models to conform to their intended domain semantics. Precision can be achieved by augmenting models with design constraints and consistency can be achieved by avoiding contradictory constraints. However, there are different views of what constitutes a contradiction for design constraints. Moreover, state-of-the-art analysis approaches for proving constrained models consistent either scale poorly or require the use of interactive theorem proving. In this paper, we present a heuristic approach for efficiently analyzing constraint specifications built from constraint patterns. This analysis is based on precise notions of consistency for constrained class models and exploits the semantic properties of constraint patterns, thereby enabling syntax-based consistency checking in polynomial-time. We introduce a consistency checker implementing these ideas and we report on case studies in applying our approach to analyze industrial-scale models. These studies show that pattern-based constraint development supports the creation of concise specifications and provides immediate feedback on model consistency.

Abstract: We consider workflow graphs as a model for the control flow of a business process model and study the problem of workflow graph parsing, i.e., finding the structure of a workflow graph. More precisely, we want to find a decomposition of a workflow graph into a hierarchy of sub-workflows that are subgraphs with a single entry and a single exit of control. Such a decomposition is the crucial step, for example, to translate a process modeled in a graph-based language such as BPMN into a process modeled in a block-based language such as BPEL. For this and other applications, it is desirable that the decomposition be unique, modular and as fine as possible, where modular means that a local change of the workflow graph can only cause a local change of the decomposition. In this paper, we provide a decomposition that is unique, modular and finer than in previous work. It is based on and extends similar work for sequential programs by Tarjan and Valdes. We show that our decomposition can be computed in linear time based on an algorithm by Hopcroft and Tarjan that finds the triconnected components of a biconnected graph.

Abstract: Although the business process community has put a major emphasis on patterns, notably the famous workflow patterns, only limited support for using patterns in today’s business process modeling tools can be found. While the basic workflow patterns for control flow are available in almost every business process modeling tool, there is no support for the user in correctly applying these simple patterns leading to many incorrectly modeled business processes. Only limited support for pattern compounds can be found in some tools, there is no active support for selecting patterns that are applicable in some user-determined context, tools do not give feedback to the user if applying a pattern can lead to a modeling error, nor do they trace the sequence of applied patterns during the editing process. In this paper, we describe an extension of a business process modeling tool with patterns to provide these capabilities. We distinguish three scenarios of pattern application and discuss a set of pattern compounds that are based on the basic workflow patterns for control flow. We present an approach where business users receive help in understanding the context and consequences of applying a pattern.

Abstract: Business information systems and enterprise applications have continuously evolved into Business-IT systems over the last decades, directly linking and integrating Business Process Management with recent technology evolutions such as Web services and Service-Oriented Architectures. Many of these technological evolutions include areas of past academic research: Business rules closely relate to expert systems, Semantic Web technology uses results from description logics, attempts have been made to compose Web services using intelligent planning techniques, and the analysis of business processes and Web service choreographies often relies on model checking. As such, many of the problems that arise with these new technologies have been solved at least in principle. However, if we try to apply these ``in principle'' solutions, we are confronted with the failure of these solutions in practice: many proposed solution techniques do not scale to the real-world requirements or they rely on assumptions that are not satisfied by Business-IT systems. As has been observed previously, research in this area is fragmented and does not follow a truly interdisciplinary approach. To overcome this fragmentation, we propose the vision of a compiler for Business-IT systems that takes business process specifications described at various degrees of detail as input and compiles them into executable IT systems. As any classical compiler, the parsing, analysis, optimization, code generation and linking phases are supported. We describe a set of ten research problems that we see as critical to bring our compiler vision to reality.

Abstract: Business-driven development is a methodology for developing IT solutions that directly satisfy business requirements. At its core are business processes, which are usually modeled by combining graphical and textual notations. During business-driven development, business process models are taken to the IT level, where they are implemented in a Service-Oriented Architecture. A major challenge in business-driven development is the semantic gap between models captured at the business and the IT level. Model transformations play a major role in bridging this gap. This paper presents a transformation framework for IBM WebSphere Business Modeler that enables programmers to quickly develop in-place model transformations, which are then made available to users of this tool. They address various user needs such as quickly correcting modeling errors, refining a process model, or applying a number of refactoring operations. Transformations are combined with quality assurance techniques, which help users to preserve or improve the correctness of their business process models when applying transformations.

Abstract: This paper explores the emerging paradigm of business-driven development, which presupposes a methodology for developing IT solutions that directly satisfy business requirements and needs. At the core of business-driven development are business processes, which are usually modeled by combining graphical and textual notations. During the business-driven development process, business-process models are taken down to the IT level, where they describe the so-called choreography of services in a Service-Oriented Architecture. The derivation of a service choreography based on a business-process model is simple and straightforward for toy examples only for realistic applications, many challenges at the methodological and technical level have to be solved. This paper explores these challenges and describes selected solutions that have been developed by the research team of the IBM Zurich Research Laboratory.

Until today, planning operators are mostly considered as atomic transitions that change the value of boolean or numeric state variables. This remains also true if nondeterministic effects are added to operator descrip- tions. Solely, the compound tasks used in HTN plan- ners encapsulate more complex behavior, but it is dif- ficult to model nondeterminism and iterations using HTN representations. In many real-world applications however, in particular in technical environments such as hardware and software systems (for example net- works, server farms, or embedded controllers), more expressive planning operators that encapsulate nonde- terministic and iterative behavior are needed. In this paper, we propose to use nondeterministic com- municating automata as the operators for a planning system. We show how to model such operators, de- fine the planning problem with communicating au- tomata and present a first, preliminary planner involv- ing model checking techniques.

Abstract: During the construction of service-oriented architectures, service modelers concern themselves with the characteristics of good services and how such services can be designed. For instance, they look for advice regarding interface granularity and criteria to assess whether existing software assets are fit for reuse in service-oriented environments. There are no straightforward answers to such questions – service identification, specification and realization techniques are required. Service identification and specification are well covered by existing methodologies; for service realization, architectural decision models can be leveraged. At present, the construction of architectural decision models is an education - and labor-intensive undertaking; if such models exist at all, they often are isolated from other artifacts. In this paper, we propose a new engineering approach to service modeling that leverages reusable architectural decision models as its central service realization concept. We outline a multi- level decision tree and position it as a prescriptive service realization methodology for three engagement types observed in practice. The benefits of service engineering with reusable architectural decision models are semiautomatic decision identification in analysis models, improved decision making quality, and better decision enforcement and risk mitigation capabilities.

Abstract: A high level of detail and well-formedness of models have become crucial ingredients in model-driven development. Constraints play a central role in model precision and validity. However, the task of constraint development is time-consuming and error-prone because constraints can be arbitrarily complex in real-world models. To overcome this problem, we propose a solution that we call modeldriven constraint engineering. In our solution, we define the notion of computation-independent constraints that are provided in the form of meta-model integrated patterns. The parameterized patterns are transformed into platform-independent or platform-independent constraints by a model transformation. In addition, we show how our approach can be supported by a tool.

Abstract: Business process modeling is gaining increasing importance with more and more people getting involved with business process modeling projects. The output of these projects are process models, which become a direct input into the software development process. Consequently, the impact of the process models on the IT systems and the operational efficiency of an enterprise is increasing. With that, the associated economic risk of using badly designed process models is growing as well. In this report, we address the problem of quality assurance for business process models. Based on hundreds of real world business process models that we reviewed over the past two years, we extracted typical modeling errors that we generalized into anti-patterns. These anti-patterns cover six common process modeling scenarios ranging from the modeling of branching and iterative behavior, over the modeling of data flow, to the reuse of process models in composite processes. For each scenario, an example illustrating typical errors is introduced and then generalized into an anti-pattern, which highlights the modeling error. Then, one or several patterns are presented that show a correct solution to the modeling scenario, followed by a summarizing recommendation.

Abstract: Reference models capture best-practice solutions for a specific industry such as retail, banking, or insurance. The models usually cover the whole range of solution components such as productmodels, business rules, datamodels, and service models. Over the past years, business process reference models have gained increasing attention. Process merging is a technique that brings together several process models to create a new process model. In this paper, we introduce process merging for a scenario which focuses on the improvement of an existing AS-IS business process by using a reference process model. We describe an approach that enables a business architect to establish correspondences between two process models in a systematic way and show how these correspondences define concrete refactoring operations that serve to improve the AS-IS model.

Abstract: We have published a repository for storing business processes and associated metadata. The BPEL Repository is an Eclipse plug-in originally built for BPEL business processes and other related XML data. It provides a framework for storing, finding and using these documents. Other research prototypes can reuse these features and build on top of it. The repository can easily be extended with new types of XML documents. It provides a Java API for manipulating the XML files as Java objects hiding the serialization and de-serialization from a user. This has the advantage that the user can manipulate the data as more convenient Java objects, although the data is stored as XML filles compliant with the standard XML schemas. The data can be queried as Java objects using an object-oriented query language, namely the Object Constraint Language (OCL). Moreover, the extensible design allows the OCL query engine to be replaced with another engine based on other query language.

Abstract: We present the results of a case study where we investigated a semantic mapping of UML2 activity diagrams to the Pi-calculus. Our study was initiated by recent discussions on the role of the Pi-calculus for future business-process management systems as well as our interest in developing formal analysis techniques for activity diagrams. The study revealed interesting insights into the semantic expressivity of activity diagrams and the semantic nature of the different modeling elements, in particular of object nodes and activity final nodes. We show that for certain types of diagrams, a semantic mapping of object nodes, in particular of pins, to message reading and receiving operations is insufficient and propose an encoding of pins as Pi-processes. Our results motivated us to present a novel classification of activity diagrams based on their semantic expressivity.

Abstract: The report describes a business method for business transformation and tooling that has been developed to enable the business method. Business transformation deals with the strategic alignment of Business and IT to deliver enduring on-demand value of continual business innovation and improvement. It comprises three main challenges: (1) analysis and modeling of business strategy and operations to drive business transformation, (2) efficient generation of an IT solution from a business model using techniques from Model- Driven Development (MDD) of software systems, (3) monitoring and dynamic management of business performance for continual improvement. The report addresses to the first two challenges in the above list: analysis and modeling of business operations, and the efficient generation of an IT solution from a business model.

Abstract: Business process integration and automation are among the most significant factors driving the information technology industry today. In addressing the manifold technology challenges of integration and automation, new standardization efforts aim at improving the interoperability of businesses by moving toward a declarative specification of business processes, that is, one which describes what a business process does and not how it is implemented. At the same time, Model Driven Architecture® focuses on improving the software-engineering methods with which business process solutions are implemented by separating the business or application logic from the underlying platform technology and representing this logic with precise semantic models. In this paper, we present an approach to the model-driven generation of programs in the Business Process Execution Language for Web Services (BPEL4WS), which transforms a graphically represented control-flow model into executable code by using techniques that originated in compiler theory. We discuss the underlying algorithms as well as general questions concerning the representation and analysis of model transformations. We study a declarative representation of transformation rules, where preconditions and postconditions are represented in the Object Constraint Language. By adopting a declarative approach, we pave the way for future automatic consistency checking of transformation rules and bidirectional reconciliation of evolving models.

Abstract: The scalability of recent planning algorithms allows developers to automate planning tasks, which so far have been reserved to humans. However in real-world applications, synthesizing a plan is just the beginning of a complex life-cycle management process. Plans must be organized in large collections, where they can be grouped along different purposes and are amenable to the search, inspection, evaluation, and modification by human experts or automated reasoning systems. Eventually, plans will outlast their utility and be replaced. We present our solution to plan life cycle management for an autonomic computing application. We focus in particular on the automatic synthesis of plan metadata for plans containing conditional and parallel actions, well-structured loops, and non-deterministic choices. The plans are of unknown origin, i.e., their underlying action model, which could provide us with pre- and postconditions, is not available. New analysis techniques are presented that uniformly generate metadata for plans, thus allowing a system to embed plans into context and organize them in meaningfully structured plan repositories.

Abstract: We present a novel transformation method that allows us to map unstructured cyclic business process models to functionally equivalent workflow specifications that support structured cycles only. Our solution is based on a continuation semantics, which we developed for the graphical representation of a process model. By using a rule-based transformation method originally developed in compiler theory, we can untangle the unstructured flow while solving a set of abstract continuation equations. The generated workflow code can be optimized by controlling the order in which the transformation rules are applied. We then present an implementation of the transformation method that directly manipulates an object-oriented model of the Business Process Execution Language for Web Services BPEL4WS. The implementation maps abstract continuation equations to the BPEL4WS control-flow graph. The transformation rules manipulate the links in the graph such that all cycles are removed and replaced by equivalent structured activities. A byproduct of this work is that, if a continuation semantics is adopted for BPEL4WS, its restriction to acyclic links can be dropped.

Abstract: Model-driven architecture envisions a paradigm shift as dramatic as the one from low-level assembler languages to high-level programming languages. In order for this vision to become reality, algorithms are needed that compile models of software systems into deployable and executable implementations. This paper discusses two algorithms that provide such transformations for process graph models in a business process or workflow environment and produce executable programs based on Web services and orchestration languages. The reverse transformations back from executable programs to process graphs are also described.

Abstract: The modeling, design, and implementation of inter-organizational systems (IOS) is a challenging new problem. In contrast to previous systems, where components have clearly defined interfaces and serve a well-defined purpose, components of IOS exist in a distributed environment, where each component of the system may exist at a separate corporation and must conform to the interface of partner components. This creates a complicated problem for designers. In this paper, we investigate to which extent control flow, communication, and data manipulation patterns can help to ease the manual design process of IOS implemented in the Business Process Execution Language for Web services (BPEL4WS). By applying patterns of all three types in an iterative fashion we go from an abstract representation of the example process to a graphical solution with a one-to-one mapping to executable BPEL4WS code.

Abstract: In a previous work, we had analyzed the gaps in the prevalent approaches (i.e., Semantic Web Services and WSDLdescribed Web Services) for the problems of modeling, composing, executing, and verifying Web services, and derived challenges for the AI planning community. The challenges were in representation of complex actions, handling of richly typed messages, dynamic object creation and specification of multi-partner interactions. An important question that constantly arose was how the goals for automatic composition would be derived. In this paper, we revisit this issue in the light of new trends in software engineering towards Model Driven Architecture and early deployment of Web service composition solutions. We argue that Web services composition can not be seen as a one-shot plan synthesis problem defined with explicit goals but rather as a continual process of manipulating complex workflows, which requires to solve synthesis, execution, optimization, and maintenance problems as goals get incrementally refined. We then identify additional issues that become important in applying planning techniques.

Abstract: Composition ofWeb services has received much interest to support business-to-business or enterprise application integration. On the one side, the business world has developed a number of XML-based standards to formalize the specification of Web services, their flow composition and execution. This approach is primarily syntactical: Web service interfaces are like remote procedure call and the interaction protocols are manually written. On the other side, the Semantic Web community focuses on reasoning about web resources by explicitly declaring their preconditions and effects with terms precisely defined in ontologies. For the composition of Web services, they draw on the goal-oriented inferencing from planning. So far, both approaches have been developed rather independently from each other. We compare these approaches and discuss their solutions to the problems of modeling, composing, executing, and verifying Web services. We discuss what makes the Web service composition so special and derive challenges for the AI planning community.

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 platformindependent (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: Model-to-model transformation is a key technology for the OMG’s Model Driven ArchitectureTM. The need for standardization in this area lead to the MOF 2.0 Query/Views/Transformations Request for Proposals (RFP) from the OMG. The RFP elicited eight separate submissions. This paper makes the following contributions: Terminology for queries, views, and transformations is introduced that is based on the terminology used in the submissions, but which is edited for consistency. A set of common transformation scenarios is described, which is motivated by the authors’ practical experiences with transformations. The submissions are reviewed, compared to each other, and their highlights discussed. Based on the review and the experience of the authors in developing model-driven transformations, recommendations for the final standard are presented.

Abstract: We discuss the key features of autonomic computing and their relationship to AI systems. We present a generic architecture for autonomic computing systems and propose a computational model based on communicating automata networks to implement such architectures. We illustrate this approach with an intelligent device discovery tool that analyzes the inventory and topology of large computer networks.

Abstract: Today’s business applications and their underlying process models are becoming more and more complicated, making the implementation of these processes an increasingly challenging task. On the one hand, tools and methods exist to describe the business processes. On the other hand, different tools and method exist to describe the IT artifacts implementing them. But a significant gap exists between the two. To overcome this gap, new methodologies are sought. In this paper, we discuss a pattern-based modeling and mapping process. Starting from a business process model, which emphasizes the underlying structural process pattern and its associated requirements, we map this model into a corresponding IT model based on nondeterministic automata with state variables. Model checking techniques are used to automatically verify elementary requirements on a process such as the termination and reachability of states. Using an example involving coupled, repetitive activities we discuss the advantages of an iterative process of correcting and refining a model based on insights gained in the interleaved verification steps.