Ralph Hoch

Semantic Service Specification for VaV of Service Composition and Business Processes

Semantic specification of services based on formal logic can be used for automated verification of service composition. In order to make such verifications consistent with validations of service compositions in the context of business processes, more and more knowledge needs to be included in the related specifications. We show using a simple example that after adding such additional knowledge directly to the semantic specifications of services, they may become over-specified. We found that this additional knowledge can be a special kind of business rules. Therefore, we propose to specify them separately, but also based on formal logic. More precisely, the use of the Fluent Calculus and the related FLUX tool enabled automated and guaranteed verification of composed services against the specifications of the single services. Adding the formalized business rules into such verifications made them consistent with validations of service compositions in the context of business processes. Overall, both verification and validation (V&V) are essential for service composition and business processes. As a consequence, this novel approach to V&V should support a comprehensive approach to service design.

Semi-automatic generation of recommendation processes and their GUIs

Creating and optimizing content- and dialogue-based recommendation processes and their GUIs (graphical user interfaces) manually is expensive and slow. Changes in the environment may also be found too late or even be overlooked by humans. We show how to generate such processes and their GUIs semi-automatically by using knowledge derived from unstructured data such as customer feedback on products on the Web. Our approach covers the whole lifecycle from knowledge discovery through text mining techniques to the use of this knowledge for semi-automatic generation of recommendation processes and their user interfaces as well as their comparison in real-world use within the e-commerce domain through A/B-variant tests. These tests indicate that our approach can lead to better results as well as less manual effort.

A Connection of Task-centric with Artefact-centric Models through Semantic Task Specification and its Use for Formal Verification

Taskand artefact-centric business process models (BPMs) are mostly used in isolation. This entails, e.g., problems with formal and automated verification of BPMs through model checking. We address this gap through semantic task specification, which is transferred from more widely known semantic service specification. In summary, we present a new and systematic approach for connecting a task-centric BPM (in BPMN) with a model of an artefactcentric object life cycle through semantic task specification. As a consequence, we achieve a seamless approach for formal and automated verification of BPMs using model check-

Aligning Architectures of Business and Software: Software Driven by Business Process Models and Its User Interface

There is still a gap between businesses and their supporting software. Even when an enterprise architecture is defined for a given business, its software is often not aligned to it. If it is reflected in the software at all, then its representation there is mostly in program code rather than models, which makes it difficult to adapt the software. While BPMN provides the possibility to specify business processes in models, executing them with currently available engines does not satisfy the level of usability of traditionally developed software, due to missing context information on business artefacts and context switches for each isolated task execution. We propose a software architecture including a BPMN 2.0 engine and a model of business artefacts for aligning the architectures of the business and its supporting software. It shows how business processes (defined in BPMN) can be enriched at their enactment with additional artefact information. It is consistently presented to the user (in a graphical user interface) based on configuration information attached to business processes or tasks in the software application. It relates the process model with business artefacts in the software much as in an enterprise architecture.

Consistently Formalizing a Business Process and its Properties for Verification: A Case Study

Formal verification of business process models can be done through model checking (also known as property checking), where a model checker tool may automatically find violations of properties in a process model. This approach obviously has formal representations as a prerequisite. However, a key challenge for applying this approach in practice is to consistently formalize the process and its properties, which clearly cannot be done automatically. We studied this challenge in a case study of formally verifying an informally given business process against a guideline written like a legal text. Major lessons learned from this case study are that formalizing is key to success and that in its course a semi-formal representation of properties is useful. In the course of such a step-wise and incremental formalization, problems with the given process model have been found already, apart from those found with a model checker tool that used the formal property specification. In total, our approach revealed five problems not found by the official review. In summary, this paper investigates in a case study consistently formalizing a business process and its properties for verification through model checking.

An inductive learning perspective on automated generation of feature models from given product specifications

For explicit representation of commonality and variability of a product line, a feature model is mostly used. An open question is how a feature model can be inductively learned in an automated way from a limited number of given product specifications in terms of features. We propose to address this problem through machine learning, more precisely inductive generalization from examples. However, no counter-examples are assumed to exist. Basically, a feature model needs to be complete with respect to all the given example specifications. First results indicate the feasibility of this approach, even for generating hierarchies, but many open challenges remain.

Verification of Feature Coordination using the Fluent Calculus.

Previously, an approach based on the Situation Calculus was published for specifying feature coordination of a software system, but without a physical model or any additional autonomous agent in the environment. Hence, no verification of the feature coordination was possible in spite of its formal specification. Verification of safety-critical feature coordination is important, however, and requires additional models. This paper shows that a specification of a software coordinator can be formally verified using the Fluent Calculus (a derivative of the Situation Calculus), when combined with additional models. The overall qualitative model is a reimplementation of a recently published one based on synchronized finite-state machines, which was used for model checking. In fact, we show how the model in Fluent Calculus can be systematically derived from the finite-state machines. The results of verification using the Fluent Calculus correspond to those using model checking. We also contrast our approach using the Fluent Calculus with model checking. In summary, we present verification of (safety-critical) feature coordination using the Fluent Calculus.

Semantic task specification in business process context

Much like semantic service specification, semantic specification of tasks in business processes is needed, e.g., for their formal verification. In addition to the specification of the pure effects of some procedural code, however, business context plays a major role for semantic task specification. Open questions are how to include the business context of a task in its semantic specification, and what the semantic specification of a task composition is. This paper clarifies the relation of service composition with corresponding task composition in different business context using semantic specification. It shows that a specific semantic service task specification may become a supertype of the corresponding semantic service specification. Hence, it provides a theoretical basis for the reusability of (Web) services in different business contexts. This paper also presents a systematic derivation of the semantic specification of sequential task composition. Based on all that, it shows recursive application for higher-level business processes.

Verification of Business Processes Against Business Rules Using Object Life Cycles

While formal verification of business process models (BPMs) can be done through model checking (also known as property checking), formalizing corresponding properties having the process model available may negatively influence the formulation of properties to be checked. In addition, properties should be checkable for several processes. So, we address the problem of formalizing properties without knowing the process model. The solution proposed in this paper employs additional models of object life cycles. The new key idea is to formulate properties referring to these additional models, which together can represent certain business rules. These models have to be connected with the BPM to be checked in the formalism used for model checking. This combination facilitates more rigorous model checking with a better decoupling of the specification of the original BPM from the properties to be checked. In summary, this paper presents how a combination of conventional business process models (given, e.g., in BPMN), models of business object life cycles, and formalized business rules can be used for verification through model checking.

Reuse vs. Reusability of Software Supporting Business Processes

Reusing software is desirable, and so is reusing business processes. For reusing both in the course of developing software supporting business processes, an integration of related reuse approaches is necessary. Of course, such reuse is not for free and requires reusability of related artefacts, i.e., business process models and software parts supporting them. For successful reuse, of course, trade-offs with making artefacts reusable or acquiring them have to be beneficial. In this paper, we present an integration of business process and software reuse and reusability R&R. Based on it, we compare trade-offs between making reusable and reusing in the context of developing software supporting business processes. As a consequence, it should become easier to make rational judgments on whether and how to engage in R&R of such software.