No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Facilitating the Flexible Modeling of Human-Driven Workflow in BPEL
Abstract
BPEL can automate orchestrations for cross-organizational Web services; however, it meets a serious challenge from modeling human-intensive business activities. This paper distinguishes human-driven workflow from automated process, and uses state machine to model human-driven workflow, then transforms state machine-style workflow to BPEL process, finally integrates BPEL-style human-driven process with automated process. The goal of our work is to utilize the flexibility and efficiency of state machine to model complex and dynamic business process, and provides a novel procedure to model human-intensive business activities to complement the limitation of BPEL. This procedure has been implemented in DartFlow - a service composition platform for the sharing of the knowledge and services.
... In some approaches, state machines have been used for modelling business processes, including transformation into WS-BPEL. Especially, state-oriented approaches have proven to be successful for modelling high level human-driven workflows (Shi et al., 2008). However, UML activity diagram notation provides many of the workflow modelling constructs and is closer to BPMN. ...
The development of services-based systems starts from defining business requirements to be implemented as high-level business processes. In this paper, we describe a scenario-driven approach for developing business processes specified as WS-BPEL descriptions. We aim for simplicity in the business level notation and leverage example-like modelling principles in order to enable process sketching. The first step in our approach is to identify the essential functional requirements for business processes. The requirements are modelled as simple scenarios, each of them defining a sample run through the process, i.e., required behaviour that the underlying service-based system should allow. The scenarios, specifying sent and received messages among the services, are synthesised into a state machine. The state machine is transformed into an initial process model given in UML activity model notation. To enable mapping into WS-BPEL code, the transformation exploit domain-specific rules, i.e., our target model consists of a subset of UML with WS-BPEL specific constraints and stereotypes. The initial process model can be further refined to enable generation of executable WS-BPEL descriptions. We apply the approach on two cases, a simple process for managing loan requests and an industry case study from a logistics provider are presented.
... In some approaches, state machines have been used for modeling business processes. State-oriented approaches have proven to be especially successful for modeling high level human-driven workflows as described in [59] by Shi et al.. They have also implemented a model transformation from state diagrams to WS-BPEL. ...
Service-oriented architecture (SOA) is a software architectural style, which relies on reusable and composable services. In addition to software-orientation, SOA includes a business viewpoint, so that business requirements can be captured as high level business processes. Business processes can be implemented, for example, as an orchestration of different service components. Individual services participate in the overall execution of business processes by providing elementary service activities. In addition to flexibility and services reuse, bridging of business and information technology (IT) views is one of the claimed benefits of SOA.
Development of service-based systems includes a range of different activities. However, development of service-based systems is still lacking systematic and tool vendor independent practices and development methods. In this thesis, a development process for a service provider, called Service Product Development Process (SPDP), is presented. It consists of several development phases and related activities. The input for SPDP includes high level business process requirements. The result of the process is a new service-based product to be added to the service provider’s product portfolio.
The purpose of this thesis is to study the applicability and the benefits of applying a scenario-driven approach, a type of requirement-driven development, for the development of service-based systems. Scenarios are used to capture functional system requirements as simple message sequences given as UML sequence diagrams. The scenario-driven approach is applied to different phases of SPDP including business process development, service specification, and service realization. The proposed scenario-driven approach is not limited to the SPDP context. It is rather a general purpose framework for development of service-based systems or products, called SceDA.
SceDA includes three independent scenario-based methods, which are targeted to support different development phases of service-based systems. One of the three methods is used for scenario-based business process development. The other two methods are targeted at service development, in particular, service specification and service realization. Service specification is supported by a method for automatically mining and re-documenting the development rules as scenarios. To support service realization, a method for generating source code for individual service and client applications has been developed. Each method includes a description of the developed tool support and a case study.
Case studies are used for constructing and evaluating the three scenario-based methods developed. Each method is applied as a case study in the context of development phases of SPDP. In the first case study, scenario-driven business process development method is applied. Two other case studies concern constructing and using scenarios for application development. One case study utilizes the scenario mining method. In the other case study, the code generation method is applied.
... However, those extensions do not add the capability of event-driven human interactions to BPEL. An event-driven approach was proposed in [25], where BPEL processes are divided into the actual business processes and processes dedicated to user interactions. This method introduces asynchronous communication to a workflow-based BPEL process, but it does not provide an object-oriented access to the business process. ...
Service-orientation and object-oriented design are common practice in the field of business application development. Business process execution languages help to facilitate the orchestration of Web services in service-oriented architectures (SOA). However, using business processes from within object-oriented and event-driven applications is difficult as asynchronous event handling is missing in workflow-based business process modeling languages. The present article presents an approach for integrating BPEL business processes into object-oriented applications. We propose BPEL remote objects (BPELROs) that can be accessed asynchronously in an object-oriented manner. We present a method how state-based business processes can be implemented using BPELROs. It is shown how to apply BPELROs for software modernization tasks and we also evaluate the performance of BPELROs on different BPEL engines.
The development of services-based systems starts from defining goals for business processes to be implemented, e.g., as a Web service orchestrations specified in WS-BPEL. In this paper, we propose a scenario-driven approach for modeling business processes. We aim for simplicity in the notation and leverage example-like modeling principles in order to improve process sketching. The first step in our approach is to identify the essential business requirements and model them using a simple scenario notation. The scenarios, given as UML sequence diagrams, are synthesized into a state machine, which is translated into a WS-BPEL flavored process skeleton given as UML activity diagram. The process skeleton can be further refined into executable process model.
The agility of SOA (service-oriented architecture) can response changes of business process effectively. To meet the requirements of rapid building business system for personality and high-speed changes based on business model, SOA was introduced. In this paper, firstly, the information system architecture based on SOA was built, moreover, Ajax (asynchronous Javascript and XML) technology was adopted to create clients based on traditional B/S(browser/server) structure, which enhanced interaction and feasibility; Secondly, the method for rapid building business system was proposed, also the algorithms for workflow control and code generator was brought forward; Finally, the code generators, to reduce the complexity of the software development, is also provided.
Business Process Management (BPM) creates a new layer in IT architecture. Older integration technologies act as middleware (they sit below the applications that they connect) but BPM sits above them. Since a BPM system integrates and organises IT assets from the users' point of view, its basic capabilities should cater naturally for human collaboration. This requires three fundamental capabilities: 1. Flexible process topology 2. Event-driven and declarative activity management 3. A collaborative perspective We consider how the XML standards proposed for BPM measure up against these criteria, and hence to what degree they support collaboration. We conclude that while BPML and BPEL4WS provide the required flexibility, none of them deliver the other 2 capabilities. We then present an alternative formal system for BPM, based on Role Activity Theory, an established formal framework for describing human and organizational collaboration. This system is defined by the XML language Playwright, and supported by the BPM engine RADRunner.
We formally define an abstract executable semantics for the Business Process Execution Language for Web Services in terms of a distributed ASM. The goal of this work is to support the design and standardization of the language. "There is a need for formalism. It will allow us to not only reason about the current specification and related issues, but also uncover issues that would otherwise go unnoticed. Empirical deduction is not sufficient." - Issue #42, OASIS WSBPEL TC. The language definition assumes an infrastructure for running Web services on some asynchronous communication architecture. A business process is built on top of a collection of Web services performing continuous interactions with the outside world by sending and receiving messages over a communication network. The underlying execution model is characterized by its concurrent and reactive behavior making it particularly difficult to predict dynamic system properties with a sufficient degree of detail and precision under all circumstances.
Web services advocate loosely coupled systems, although current loosely coupled applications are limited to stateless services. The reason for this limitation is the lack of a method supporting matchmaking of state dependent services exemplarily specified in BPEL. In particular, the sender's requirement that the receiver must support all possible messages sent at a certain state are not captured by models currently used for service discovery. Annotated deterministic finite state automata provide this expressiveness. In this paper the transformation of a local process specification given in BPEL to annotated deterministic finite state automata is presented.
We present a Petri net semantics for the Business Process Execution Language for Web Services (BPEL). Our semantics covers the standard behaviour of BPEL as well as the exceptional behaviour (e.g. faults, events, compensation). The semantics is implemented as a parser that translates BPEL specifications into the input language of the Petri net model checking tool LoLA. We demonstrate that the semantics is well suited for computer aided verification purposes.
Service-oriented Computing (SoC) in general, and e-service orchestrations in particular have the potential to increase reuse and to ease maintainability. Typically, interoperating e-services require orches- tration efforts, which should be accomplished outside the application logic itself. In this paper we present a novel MDA-based approach for generating orchestrations of e-services, enabling the automatic genera- tion of e-service orchestrations based on UML models. Secondly, such orchestrations may include GUIs. Thirdly, we discuss our execution en- vironment supporting heterogeneous e-service orchestrations, including Web services, COM, CORBA, and .NET objects. Such heterogeneous software system landscapes are very common today, where many (legacy) applications still exist and are not wrapped as e-services, nor BPEL pro- cess descriptions are available.
Web Services are seen as one of the most promising solutions for the integration of autonomous, heterogonous e-business systems.
Today’s e-commerce systems often involve a combination of multiple Web Services, which are implemented via a mix of technologies
such as Business Process Markup Language (BPML), Business Process Execution Language for Web Services (BPEL4WS), and Web Service
Choreography Interface (WSCI).
Recently, the application of Model Driven Architecture (MDA) to Web Services has received considerable attention. However,
most of existing literature deals with the static aspects of Web Service modelling. This paper focuses on the behavioral aspect
of the composition of Web Services using a Meta Object Facility (MOF) compliant metamodel for BPEL4WS. The paper presents
a transformation of the Unified Modelling Language (UML) Activity diagram to the BPEL4WS.
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.
We define an abstract operational semantics for the Business Process Execution Language for Web Services (BPEL) based on the ab- stract state machine (ASM) formalism. This way, we model the dynamic properties of the key language constructs through the construction of a BPEL abstract machine in terms of a distributed real-time ASM. Specif- ically, we focus here on the process execution model and the underlying execution lifecycle of BPEL activities. The goal of our work is to provide a well defined semantic foundation for establishing the key language at- tributes. The resulting abstract machine model provides a comprehensive and robust formalization at three different levels of abstraction.
People are an important part of many business processes. Current workflow-based implementations of business processes constrain users to the desktop environment; require them to periodically check for pending tasks; and do not support direct or synchronous people-to-people interaction. On the other hand, the wide spectrum of people collaboration tools ranging from telephones to instant messaging and to email have no provision for structured collaboration and are separate from business processes. We have designed and implemented a system, dubbed PerCollab that integrates workflow and collaboration technologies. It allows people to participate in business processes from anywhere using a traditional collaboration mechanism. It proactively engages users in business processes by pushing interaction to a convenient device of the users. PerCollab uses an extended BPEL to formally define business processes with human partners and exploits dynamic user context to solve the personal mobility problem. Our prototype implementation integrates a variety of collaboration tools: instant messaging, email and e-meeting.
For the MDA vision to become a reality, there must be a viable means to perform model-to-model transformation. In this paper, we compare and contrast two approaches to model transformation: one is a graph transformation-based approach, and the other is a relational approach, based on the QVT-Merge submission for OMG's MOF 2.0 Query/View/Transformation Request for Proposal. We apply them both to a common example, which involves transforming UML statemachines to a CSP specification, and we look at some of the concrete and concep-tual differences between the approaches.
We present a transparent yet rigorous conceptual framework for defining the semantics of dynamic UML diagrams. We illustrate the method for UML state machines, making the “semantic variation points” of UML explicit, as well as various ambiguities and omissions in the official UML documents. This includes the event deferring and completion mechanism, the meaning of atomic and durative actions, concurrent internal activities and conflict situations which may arise through the concurrent behavior of active objects.
The web services paradigm promises to enable rich, exible, and dynamic interoperation of highly distributed and heterogeneous web-hosted services. Substantial progress has already been made towards this goal (e. g., emerging standards such as SOAP, WSDL, BPEL) and industrial technology (e. g., IBM's WebSphere Toolkit, Sun's Open Net Environment and JiniTM Network technology, Mi-crosoft's. Net and Novell's One Net initiatives, HP's e-speak). Sev-eral research efforts are already underway that build on or take ad-vantage of the paradigm, including the DAML-S/OWL-S program [8, 25, 19], the Semantic eWallets project [18], ActiveXML [3], and automata-based models for web services [6, 21, 4]. But there is still a long way to go, especially given the ostensible long-term goal of enabling the automated discovery, composition, enactment, and monitoring of collections of web services working to achieve a speci ed objective. A fundamental question right now concerns the design and analysis of composite web services. Speci cally, are existing tools for design and analysis of software systems suf-cient for web services, or are new techniques needed to handle the novel aspects of the web services paradigm? This raises a variety of questions, several of which are relevant for the database research community. These include: What is the right way to model web services and their compositions? What is the right way to query them in order to support automated composition and analysis algo-rithms? And how can the data management aspects of composite web services be incorporated into current web services standards? This tutorial will provide the groundwork needed to address these questions, by describing emerging frameworks for studying com-posite services, and identifying emerging tools and techniques for both automated design and analysis of composite web services. The tutorial will begin with an overview of the underlying goals and assumptions of the web services paradigm, from the perspec-tives of both emerging standards and the semantic web services community (Section 2). It then reviews key standards in the area, as these provide some of the basic building blocks to be used by the web services paradigm, and will in uence the form that this paradigm eventually takes (Section 3).
With the emergence of technologies and standards supporting the development of web services, more and more services are becoming
available on the Internet. But almost all of them are single and simple functional units. Composing existing services into
new functionality becomes very essential for enterprises. We call a service composition “Serviceflow”. This paper presents
the DartFlow framework aimed to build, execute and manage serviceflow. Due to the similarity between serviceflow and workflow,
we use workflow technology in DartFlow to compose services dynamically and flexibly. A detailed comparison between serviceflow
and workflow is introduced in this paper. Semantic technology is also adopted to resolve some basic issues about services,
such as service description, service registration and automatic service discovery in DartFlow.
Summary form only given. The Business Process Execution Language for Web services (BPEL) has emerged as the de-facto standard for cross-organizational business processes and business interaction protocols for connecting Web services. At the beginning of BPEL, people mainly focused on automated business process execution. Although intended as a language for connecting Web services, BPEL has been applied by ambitious people to realize a wide variety of process-aware intra-organizational application, which gives the heavier burden on BPEL than ever. Faced with emerging wider scenarios (complex human activity, various non-Web service APIs, etc), original BPEL has difficulties for fulfilling the new requirement. Human activities have complex and dynamic impact on business process execution. BPEL was designed for automated service-to-service interactions, and did not define mechanisms interacting with people in its current version. Considering most modern business processes commonly involving some extent of human-intensive workflow, inability of specification is actually serious, and in some cases fatal. To complement the lack of BPEL on human-driven workflow, and coordinate work performed by human-driven workflows and automated processes, this paper presents a novel four-step procedure. In the first step, we distinguish human activity from automated process among business process, and treat them as external process and internal process, respectively. While the former supports a more event-driven, flexible and dynamic human-driven workflow with unstructured data, the latter, as lower part of the former, supports sequential, predefined and static approach with structured data. In the second step, we utilize state machine to model the human-driven workflow. The state machine provides a flexible and efficient way to model the more loosely defined nature of human workflow. In the third step, we transform the state machine-style workflow to the BPEL-style process. In the fourt- - h step, we integrate external BPEL-style human-driven process with internal sequential automated process into a complete BPEL process. The latter is invoked by the former as a single Web service via standard 'invoke' activity in BPEL, or as a sub-process via extensive 'call' activity in BPEL-SPE. This procedure has been implemented in DartFlow - a service composition platform for the sharing of the TCM (traditional Chinese medicine) knowledge and services
With the extensive applications of Web services on the Internet, to locate target services in an accurate and efficient way becomes increasingly difficult. At present, semantic Web service is regarded as the most promising approach to address the challenge. In this paper, an ontology service description language and a query language, OSDL and OSQL are proposed respectively, and then a service matchmaking algorithm based on interface semantics is proposed. The problem of service matchmaking can be attributed to the similarity between the semantic pair, and the similarity is the quantization of their relationship, which is discovered through reasoning on ontology. Unlike the existing semantics-based service matchmaking algorithms, which focus on the relationships among the successors and ancestors of ontology classes, the proposed one also pays attention to the comparability among classes and their property classes. The experiment data indicate that it is worthwhile to take the point into consideration to receive a higher recall and precision.
Workflow has grown to be a primary method in managing processes. Improving the ability to support heterogeneous applications for workflow management system (WFMS) will promote the more popular application of workflow technology in wide areas. Moreover, as e-service is becoming as a focus in business process management, workflow technology is facing the challenge to support e-services in a proper way. We import the enterprise application integration (EAI) technology into workflow enactment service to support heterogeneous applications in a uniform way; and also we introduce some service-related components into workflow reference model to support e-services in processes. A WFMS prototype based on our extended workflow model is also presented. Semantic knowledge is used in this prototype to make service registration and discovery.
This paper presents a set of tools and techniques for analyzing interactions of composite web services which are specified in BPEL and communicate through asynchronous XML messages. We model the interactions of composite web services as conversations, the global sequence of messages exchanged by the web services. As opposed to earlier work, our tool-set handles rich data manipulation via XPath expressions. This allows us to verify designs at a more detailed level and check properties about message content. We present a framework where BPEL specifications of web services are translated to an intermediate representation, followed by the translation of the intermediate representation to a verification language. As an intermediate representation we use guarded automata augmented with unbounded queues for incoming messages, where the guards are expressed as XPath expressions. As the target verification language we use Promela, input language of the model checker SPIN. Since SPIN model checker is a finite-state verification tool we can only achieve partial verification by fixing the sizes of the input queues in the translation. We propose the concept of synchronizability to address this problem. We show that if a composite web service is synchronizable, then its conversation set remains same when asynchronous communication is replaced with synchronous communication. We give a set of su#cient conditions that guarantee synchronizability and that can be checked statically. Based on our synchronizability results, we show that a large class of composite web services with unbounded input queues can be completely verified using a finite state model checker such as SPIN.
On Formalizing UML State Machines Using ASM, Information & Software Technology
- References Bcr
- Alessandra Borgera
- Cavarrab
References [BCR04] Egon Borgera, Alessandra Cavarrab and Elvinia Riccobene. On Formalizing UML State Machines Using ASM, Information & Software Technology, Volume 46, (5): 287-292.
Role Modellers Ltd Transforming BPEL to Petri Nets, Business Process Management
- Keith Harrison
Keith Harrison-Broninski, Modeling Human-Driven Processes, Role Modellers Ltd, October 2004. http://www.rolemodellers.com [HSS05] Sebastian Hinz, Karsten Schmidt, and Christian Stahl. Transforming BPEL to Petri Nets, Business Process Management, 3rd International Conference, BPM 2005, Nancy, France, September 5-8, 2005, Proceedings. [HK04] Rainer Hauser and Jana Koehler. Compiling Process Graphs into Executable Code, Generative Programming and Component Engineering: Third International Conference, GPCE 2004 :317-336, Vancouver, Canada, October 24-28, 2004. [HS04] Richard Hull, Jianwen Su. Tools for Design of Composite Web Services. Proceedings of the ACM
Transforming BPEL to Petri Nets, Business Process Management
- Sebastian Hinz
- Karsten Schmidt
- Christian Stahl
Integrating User Tasks into BPEL Processes
- Magoo
Which Style of Workflow When? Dave Green's WebLog
- Dave Green
Of People, Processes and Programs
- Barry Briggs
BPEL to The Rescue: A Real-World Account on SOA Web Services
- Peter Zadrozny
- Arthur Wang
- Kevin Geminiuc
- Robert Wales
WS-BPEL Extension for Sub-processes _ BPEL-SPE
- Matthias Kloppmann
- Dieter Koenig
- Frank Leymann
- Gerhard Pfau
- Alan Rickayzen
- Claus Von Riegen
- Patrick Schmidt
- Ivana Trickovic
Modeling Human-Driven Processes
- Keith Harrison-Broninski