No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Scenario-Driven Approach for Business Process Modeling
Abstract
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.
... We present here a discussion of the selected works, per Table 1, following their publication order. We focused on highlighting how the approaches deal (Kazhamiakin et al., 2004) C P02 B-SCP: A requirements analysis framework for validating strategic alignment of organizational IT based on strategy, context, and process (Bleistein et al., 2006) J P03 A combined approach for supporting the business process model lifecycle (Koliadis et al., 2006) C P04 Requirements-driven design and configuration management of business processes (Lapouchnian et al., 2007) C P05 Business process management with the user requirements notation (Pourshahid et al., 2009) J P06 Scenario-driven approach for business process modeling (Ruokonen et al., 2009) C P07 Wiki-based requirements management for business process reengineering (Abeti et al., 2009) C P08 Rule based business process optimization (Aghdasi and Malihi, 2010) C P09 Towards a pattern-based framework for goal-driven business process modeling (Behnam et with modeling of strategic goals and their mapping to business processes' NFRs. All acronyms and initialisms used in this section are defined in Section 2, except for those not yet presented in the text. ...
... [P06] "Scenario-driven approach for business process modeling" (Ruokonen et al., 2009): this approach is formed by four steps: first, the essential business requirements, representing strategic goals, are modeled as scenarios using UML sequence diagrams; then, the modeled scenarios are synthesized by a UML state machine, which represents the process model; next, the process model is translated into a process skeleton using a UML activity diagram; and, finally, the process skeleton is implemented in WS-BPEL. Although NFRs is a concern which can be addressed by this approach, no clear direction is presented on their treatment through the approach steps. ...
Business processes' Non-Functional Requirements (NFR) can foster the strategic alignment in organizations. Our goal was to evaluate to what extent there are approaches that seek to support the modeling of business processes' NFR based on strategic goal-related information. To achieve this goal, we conducted a literature study based on systematic review concepts. As a result, we identified 19 works addressing strategic goals and business processes with NFRs. The most commonly used techniques are: i* and Key Performance Indicators (KPI) for modeling strategic goals and Business Process Model and Notation (BPMN) for modeling business processes. According to our analysis, no approach fully addresses business processes' NFR based on strategic goals which was our primary question in conducting this study.
... An end-user driven approach for WS-BPEL-based business process development has been proposed in [18]. The approach is targeted for providing a method for easy sketching of service orchestrations. ...
RESTful services are becoming a popular technology for providing and consuming
cloud services. The idea of cloud computing is based on on-demand services and
their agile usage. This implies that also personal service compositions and workflows
should be supported. Some approaches for RESTful service compositions have been
proposed. In practice, such compositions typically present mashup applications, which
are composed in an ad-hoc manner. In addition, such approaches and tools are mainly
targeted for programmers rather than end-users. In this paper, a user-driven approach
for reusable RESTful service compositions is presented. Such compositions can be
executed once or they can be configured to be executed repeatedly, for example, to get
newest updates from a service once a week.
... To illustrate the approach and its usefulness, we present a simple Loan approval example and an industry case study carried out for a logistics service provider. The approach presented in this paper has been further developed based on our earlier work (Ruokonen et al., 2009). In addition, this paper includes developed algorithms, description of the developed tool, and an industry case study. ...
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.
... Also, a UML 2.0 profile for WS-BPEL have been proposed [1]. A previous work by Ruokonen et al.,in [15], presents a UML-based approach for creating BPEL-WS flavored activity models, which enable generation of executable BPEL-WS descriptions. By combining existing works, we aim at proposing modeling constructs, given as UML activity diagram, for BPEL-REST processes. ...
The process of web service composition involves different partner web services that are published over the internet. The Representational-State Transfer (REST) web services adopt different architectural style compared to Remote Procedure Call (RPC) web services. In this paper, we address these differences in the context of web service compositions and motivate the need for new designing techniques that lead to RESTful interfaces. We provide a UML based modeling approach for the composition of RESTful web services that models the composition for its static and behavioral features. These models provide RESTful compositions by construction, serve as a part of specification document, have mapping to several web implementation languages and can also be used to validate a RESTful composition. We illustrate the applicability of the approach with a sample Hotel and Flight booking RESTful composite web service.
In Service Oriented Systems (SOS), implementation of business processes is accomplished through services in distributed, loosely coupled manner based on business process requirements of the users. Consequently, importance of businessprocess requirements analysis for development of SOS is strongly highlighted in both academia and industry. Usually, traditional requirements engineering is competent enough to specify and analysis business requirements for development of software systems efficiently. However, Service Oriented Requirement Engineering (SORE) emerging for SOS development is differed from traditional requirement engineering due to complex nature of services. Yet, a serious gap is still exist between early and detailed specification of business process requirements in SORE and further mapping towards design of SOS from set of business processes. To address this issue, in this paper, a requirements analysis framework is proposed for development of SOS systems. The contribution of the proposed work is formal representation of business process requirements for SOS based on business scenario and Cause-Effect-Dependency (CED) graph in dimensions of six aspects of services -- What, Why, How, Who, When and Where (5W1H). Both early and detailed level requirements analysis in the context of SORE is facilitated by the proposed approach. Beside, traceability of proposed approach towards design of business processes for development of SOS is also exhibited in this paper. Moreover, the practical utility of the proposed approach is demonstrated using a suitable case study.
RESTful services are becoming a popular technology for providing and consuming cloud services. The idea of cloud computing is based on ondemand services and their agile usage. This implies that also personal service compositions and workflows should be supported. Some approaches for RESTful service compositions have been proposed. In practice, such compositions typically present mashup applications, which are composed in an ad-hoc manner. In addition, such approaches and tools are mainly targeted for programmers rather than end-users. In this paper, a user-driven approach for reusable RESTful service compositions is presented. Such compositions can be executed once or they can be configured to be executed repeatedly, for example, to get newest updates from a service once a week.
Minimally Adequate Synthesizer (MAS) is an algorithm that synthesizes UML statechart diagrams from sequence diagrams. It follows Angluin's framework of minimally adequate teacher to infer the desired statechart diagram with the help of membership and equivalence queries. The purpose of this paper is to discuss problems related to an practical implementation of MAS. In order to be able to handle most membership queries without consulting the user, MAS maintains a structure of strings already known to belong to the unknown language. User's erroneous answers and mind changes require an implementation of the structure that is capable of handling backtracking. We sketch a trie based implementation to allow this. Moreover, we discuss the interaction between the user and the algorithm as a medium of improving the algorithm and further decreasing the number of membership queries needed. Furthermore, we show how MAS can be used to synthesize sequence diagrams into an edited or manually cons...
The paper offers basic elements of a new graphical model transformation language MOLA. The language combines the traditional structured programming with pattern-based transformation rules, the key element being a natural loop construct. The prime goal of MOLA is to provide a natural and highly readable representation of model transformation algorithms.
The paper describes a new graphical model transformation language MOLA. The basic idea of MOLA is to merge traditional structured program- ming as a control structure with pattern-based transformation rules. The key language element is a graphical loop concept. The main goal of MOLA is to de- scribe model transformations in a natural and easy readable way.
A key aspect of successfully using UML is understanding the semantics of the notations. UML 2 will increase the already substantial collection of notations supported by UML 1.×. At the same time, this will augment the difficulty users experience in understanding semantics. In this paper we propose that while the diverse notations may render concepts differently, the concepts can often be considered semantically equivalent. This gives rise to an architecture where two single abstract syntaxes (structure and behaviour) underpin UML 2's seven concrete syntax. Because there a fewer semantically distinct concepts, this makes UML both easier to understand and substantially easier to implement.
There has been significant recent interest, within the aspect-oriented software development (AOSD) community, in representing crosscutting concerns at various stages of the software lifecycle. However, most of these efforts have concentrated on the design and implementation phases. We focus in This work on representing aspects during use case modeling. In particular, we focus on scenario-based requirements and show how to compose aspectual and non-aspectual scenarios so that they can be simulated as a whole. Non-aspectual scenarios are modeled as UML sequence diagrams. Aspectual scenarios are modeled as interaction pattern specifications (IPSs). In order to simulate them, the scenarios are transformed into a set of executable state machines using an existing state machine synthesis algorithm. Previous work composed aspectual and non-aspectual scenarios at the sequence diagram level. In This work, the composition is done at the state machine level.
Scenario-based specifications such as Message Sequence Charts (MSCs) are useful as part of a requirements specification. A scenario is a partial story, describing how system components, the environment, and users work concurrently and interact in order to provide system level functionality. Scenarios need to be combined to provide a more complete description of system behavior. Consequently, scenario synthesis is central to the effective use of scenario descriptions. How should a set of scenarios be interpreted? How do they relate to one another? What is the underlying semantics? What assumptions are made when synthesizing behavior models from multiple scenarios? In this paper, we present an approach to scenario synthesis based on a clear sound semantics, which can support and integrate many of the existing approaches to scenario synthesis. The contributions of the paper are threefold. We first define an MSC language with sound abstract semantics in terms of labeled transition systems and parallel composition. The language integrates existing approaches based on scenario composition by using high-level MSCs (hMSCs) and those based on state identification by introducing explicit component state labeling. This combination allows stakeholders to break up scenario specifications into manageable parts and reuse scenarios using hMCSs; it also allows them to introduce additional domain-specific information and general assumptions explicitly into the scenario specification using state labels. Second, we provide a sound synthesis algorithm which translates scenarios into a behavioral specification in the form of Finite Sequential Processes. This specification can be analyzed with the Labeled Transition System Analyzer using model checking and animation. Finally, we demonstrate how many of the assumptions embedded in existing synthesis approaches can be made explicit and modeled in our approach. Thus, we provide the basis for a common approach to scenario-based specification, synthesis, and analysis.
Currently many different modeling languages are used for workflow definitions in BPM systems. Authors of this paper analyze the two most popular graphical languages, with highest possibility of wide practical usage - UML Activity diagrams (AD) and Business Process Modeling Notation (BPMN). The necessary in practice workflow aspects are briefly discussed, and on this basis a natural AD profile is proposed, which covers all of them. A functionally equivalent BPMN subset is also selected. The semantics of both languages in the context of process execution (namely, mapping to BPEL) is also analyzed in the paper. By analyzing AD and BPMN metamodels, authors conclude that an exact transformation from AD to BPMN is not trivial even for the selected subset, though these languages are considered to be similar. Authors show how this transformation could be defined in the MOLA transformation language.
This book presents a powerful new language and methodology for programming complex reactive systems in a scenario-based manner. The language is live sequence charts (LSCs), a multimodal extension of sequence charts and UML's sequence diagrams, used in the past mainly for requirements. The methodology is play-in/play-out, an unusually convenient means for specifying inter-object scenario-based behavior
directly from a GUI or an object model diagram, with the surprising ability to execute that behavior, or those requirements, directly. The language and methodology are supported by a fully implemented tool – the Play-Engine – which is attached to the book in CD form.
The design of reactive systems is one of the most challenging problems in computer science. This books starts with a critical insight to explain the problem: there is a fundamental gap between the scenario-based way in which people think about such systems and the state-based way in which these systems are implemented. The book then offers a radical proposal to bridge this gap by means of playing scenarios. Systems can be specified by playing in scenarios and implemented by means of a Play-Engine that plays out scenarios. This idea is carried out and developed, lucidly, formally and playfully, to its fullest. The result is a compelling proposal, accompanied by a prototype software engine, for reactive systems design, which is bound to cause a splash in the software-engineering community. Moshe Vardi, Rice University, Houston, Texas, USA
Scenarios are a primary exchange tool in explaining system behavior to others, but their limited expressive power never made them able to fully describe systems, thus limiting their use. The language of Live Sequence Charts (LSCs) presented in this beautifully written book achieves this goal, and the attached Play-Engine software makes these LSCs really come alive. This is undoubtedly a key breakthrough that will start long-awaited and exciting new directions in systems specification, synthesis, and analysis. Gérard Berry, Esterel Technologies and INRIA, Sophia-Antipolis, France
The approach of David Harel and Rami Marelly is a fascinating way of combining prototyping techniques with techniques for identifying behavior and user interfaces. Manfred Broy, Technical University of Munich, Germany
this paper avoids undesired results, due to overgeneralization. To achieve thisgoal, the algorithm asks the designer for guidance during the synthesis process,when needed.
The problem of identifying an unknown regular set from examples of its members and nonmembers is addressed. It is assumed that the regular set is presented by a minimally adequate Teacher, which can answer membership queries about the set and can also test a conjecture and indicate whether it is equal to the unknown set and provide a counterexample if not. (A counterexample is a string in the symmetric difference of the correct set and the conjectured set.) A learning algorithm L∗ is described that correctly learns any regular set from any minimally adequate Teacher in time polynomial in the number of states of the minimum dfa for the set and the maximum length of any counterexample provided by the Teacher. It is shown that in a stochastic setting the ability of the Teacher to test conjectures may be replaced by a random sampling oracle, EX( ). A polynomial-time learning algorithm is shown for a particular problem of context-free language identification.
While message sequence charts (MSCs) are widely used in industry to document the interworking of processes or objects, they are expressively weak, being based on the modest semantic notion of a partial ordering of events as defined, e.g., in the ITU standard. A highly expressive and rigorously defined MSC language is a must for serious, semantically meaningful tool support for use-cases and scenarios. It is also a prerequisite to addressing what we regard as one of the central problems in behavioral specification of systems: relating scenario-based inter-object specification to state-machine intra-object specification. This paper proposes an extension of MSCs, which we call live sequence charts (or LSCs), since our main extension deals with specifying “liveness”, i.e., things that must occur. In fact, LSCs allow the distinction between possible and necessary behavior both globally, on the level of an entire chart and locally, when specifying events, conditions and progress over time within a chart. This makes it possible to specify forbidden scenarios, for example, and enables naturally specified structuring constructs such as subcharts, branching and iteration.
A powerful methodology for scenario-based specification of reactive systems is described, in which the behavior is played in directly from the systems GUI or some abstract version thereof, and can then be played out. The approach is supported and illustrated by a tool, which we call the play-engine. As the behavior is played in, the play-engine automatically generates a formal version in an extended version of the language of live sequence charts (LSCs). As they are played out, it causes the application to react according to the universal (must) parts of the specification; the existential (may) parts can be monitored to check their successful completion. Play-in is a user-friendly high-level way of specifying behavior and play-out is a rather surprising way of working with a fully operational system directly from its inter-object requirements. The ideas appear to be relevant to many stages of system development, including requirements engineering, specification, testing, analysis and implementation.
The problem of identifying an unknown regular set from examples of its members and nonmembers is addressed. It is assumed that the regular set is presented by a minimally adequate Teacher, which can answer membership queries about the set and can also test a conjecture and indicate whether it is equal to the unknown set and provide a counterexample if not. (A counterexample is a string in the symmetric difference of the correct set and the conjectured set.) A learning algorithm L∗ is described that correctly learns any regular set from any minimally adequate Teacher in time polynomial in the number of states of the minimum dfa for the set and the maximum length of any counterexample provided by the Teacher. It is shown that in a stochastic setting the ability of the Teacher to test conjectures may be replaced by a random sampling oracle, EX( ). A polynomial-time learning algorithm is shown for a particular problem of context-free language identification.
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.
Abstract Workflow,and ,business ,process ,modeling ,approaches ,have ,become ,essential ,for designing,service ,collaborations ,when ,developing ,SOA-based systems. ,To derive actual executable business process descriptions from the high-level workflow models, model,transformation ,techniques ,can ,be used. ,Various ,service ,composition ,and business,process ,languages ,are available ,for describing ,the executable ,processes. They have ,been ,developed ,having ,slightly different aims ,and ,requirements ,in mind. They do, however, share common key constructs, called workflow patterns that recur in descriptions given in these languages. Wepropose,a model-driven,approach,for transforming workflow models given as UML
A mobile business process is a special case of a business process where most of the human interaction is done using mobile devices. In this paper, we propose UML-based support for developing such mobile business processes. Here, the business process is first modeled using UML. Then the process model is translated into a BPEL description, which can be run in mobile and/or network-based workflow engines. We propose rules to guide modeling of mobile business processes, to import existing WSDL decriptions into UML models, and to generate executable BPEL descriptions with appropriate WSDL definitions. In addition, we introduce our implementation of the approach. The practical applicability is demonstrated by designing a group messaging process. It provides a customizable mobile device based communication service offering a business case for mobile operators.
The idea of synthesizing statecharts out of a collection of scenarios has received a lot of attention in recent years. However due to the poor expressive power of first generation scenario languages, including UML 1.x sequence diagrams, the proposed solutions often use ad hoc tricks and suffer from many shortcomings. The recent adoption in UML 2.0 of a richer scenario language, including interesting composition operators, now makes it possible to revisit the problem of statechart synthesis with a radically new approach. Inspired by the way UML 2.0 sequence diagrams can be algebraically composed, we first define an algebraic framework for composing statecharts. Then we show how to leverage the algebraic structure of UML 2.0 sequence diagrams to get a direct algorithm for synthesizing a composition of statecharts out of them. The synthesized statecharts exhibit interesting properties that make them particularly useful as a basis for the detailed design process. Beyond offering a systematic and semantically well founded method, another interest of our approach lies in its flexibility: the modification or replacement of a given scenario has a limited impact on the synthesis process, thus fostering a better traceability between the requirements and the detailed design.
This paper presents an algorithm for automatically generating UML
statecharts from a collection of UML sequence diagrams. Computer support
for this transition between requirements and design is important for a
successful application of UML's highly iterative, distributed software
development process. There are three main issues which must be addressed
when generating statecharts from sequence diagrams. Firstly, conflicts
arising from the merging of independently developed sequence diagrams
must be detected and resolved. Secondly, different sequence diagrams
often contain identical or similar behaviors. For a true interleaving of
the sequence diagrams, these behaviors must be recognized and merged.
Finally, generated statecharts usually are only an approximation of the
system and thus must be hand-modified and refined by designers. As such,
the generated artifact should be highly structured and readable. In
terms of statecharts, this corresponds to the introduction of hierarchy.
Our algorithm successfully tackles all three of these aspects and will
be illustrated in this paper with a well-known ATM example
: While message sequence charts (MSCs) are widely used in industry to document the interworking of processes or objects, they are expressively quite weak, being based on the modest semantic notion of a partial ordering of events as defined, e.g., in the ITU standard. A highly expressive and rigorously defined MSC language is a must for serious, semantically meaningful tool support for use-cases and scenarios. It is also a prerequisite to addressing what we regard as one of the central problems in behavioral specification of systems: relating scenario-based inter-object specification to state-machine intra-object specification. This paper proposes an extension of MSCs, which we call live sequence charts (or LSCs), since our main extension deals with specifying "liveness ", i.e., things that must occur. In fact, LSCs allow the distinction between possible and necessary behavior both globally, on the level of an entire chart and locally, when specifying events, conditions and progress ov...
Scenario-Driven Approach to Support Business Process Modeling for SOA-enabled Environments
- L Pajunen
- A Ruokonen
- T Systa
L. Pajunen, A. Ruokonen, and T. Systa. Scenario-Driven Approach to Support Business Process Modeling for SOA-enabled Environments. In Technical report: NW-MoDE '08, Reykjavik, Iceland, 2008. Engineering Research Inst.ute, Univ. of Iceland.
Synthesizing State-Based Ob-ject Systems from LSC Specifications Preliminary version ap-peared as technical report MCS99-20, Weizmann Inst
- D Harel
- H Kugler
D. Harel and H. Kugler. Synthesizing State-Based Ob-ject Systems from LSC Specifications. IJFCS, 13(1):5–51, Febuary 2002. (Also in Proc. of 5th Int. Conf. on CIAA 2000, Springer-Verlag, pp. 1–33, Preliminary version ap-peared as technical report MCS99-20, Weizmann Inst. of Science, 1999. ).
Relating Inter-Agent and Intra-Agent Specifications (The Case of Live Sequence Charts)
- Y Bontemps