Tim Schattkowsky

Verification of Business Process Quality Constraints Based on Visual Process Patterns

Business processes usually have to consider certain constraints like domain specific and quality requirements. The automated formal verification of these constraints is desirable, but requires the user to provide an unambiguous formal specification. In particular since the notations for business process modeling are usually visual flow-oriented languages, the notational gap to the languages usually employed for the formal specification of constraints, e.g., temporal logic, is significant and hard to bridge. Thus, our approach relies on UML Activities as a single language for the specification of both business processes and the corresponding constraints. For the expression of such constraints, we have provided a process pattern definition language based on specialized Activities. In this paper, we describe how model checking can be employed for formal verification of business processes against such patterns. For this, we present an automated transformation of the business process and the corresponding patterns into a transition system and temporal logic, respectively.

Model-based design of embedded systems

The design of embedded systems is often based on the development of a detailed formal system specification. Considerable effort is spent to ensure the correctness of this specification. However, the actual implementation of the specification and later maintenance is usually done using traditional programming and more often diverges from the specification. To overcome this, it is desirable to derive the implementation directly from the specification. We present an approach for model-based development of embedded systems applying a well-defined UML 2.0 subset with precise execution semantics. Our approach is fully object-oriented, accounts for important aspects like real-time behavior including timeouts, and interrupts. Through the seamless integration of UML sequence diagrams with state diagrams, executable systems can be completely described. The direct execution of such models on a UML virtual machine (UVM) avoids a separate implementation step and increases portability

UML 2.0 - Overview and Perspectives in SoC Design

The design productivity gap requires more efficient design methods. Software systems have faced the same challenge and seem to have mastered it with the introduction of more abstract design methods. The UML has become the standard for software systems modeling and thus the foundation of new design methods. Although the UML is defined as a general purpose modeling language, its application to hardware and hardware/software codesign is very limited. In order to successfully apply the UML in these fields, it is essential to understand its capabilities and to map it to a new domain.

A Model-Based Approach for Executable Specifications on Reconfigurable Hardware

UML 2.0 provides a rich set of diagrams for systems documentation and specification. Much effort has been undertaken to employ different aspects of UML for multiple domains, mainly in the area of software systems. Considering the area of electronic design automation, however, we currently see only very few approaches which investigate UML for hardware design and hardware/software co-design. We present an approach for executable UML closing the gap from system specification to its model-based execution on reconfigurable hardware. For this purpose, we present our abstract execution platform (AEP), which is based on a virtual machine running an executable UML subset for embedded software and reconfigurable hardware. This subset combines UML 2.0 classes, state-machines and sequence diagrams for a complete system specification. We describe how these binary encoded UML specifications can be directly executed and give the implementation of such a virtual machine on a Virtex II FPGA. Finally, we present evaluation results comparing the AEP implementation with C code on a C167 microcontroller.

Transformation of UML state machines for direct execution

Executable UML models are nowadays gaining interest in embedded systems design. This domain is strongly devoted to the modeling of reactive behavior using StateChart variants. In this context, the direct execution of UML state machines is an interesting alternative to native code generation approaches since it significantly increases portability. However, fully featured UML 2.0 State Machines may contain a broad set of features with complex execution semantics that differ significantly from other StateChart variants. This makes their direct execution complex and inefficient. In this paper, we demonstrate how such state machines can be represented using a small subset of the UML state machine features that enables efficient execution. We describe the necessary model transformations in terms of graph transformations and discuss the underlying semantics and implications for execution.

Activity diagram patterns for modeling quality constraints in business processes

Quality management is an important aspect of business processes. Organizations must implement quality requirements, e.g., according to standards like ISO 9001. Existing approaches on business process modeling provide no explicit means to enforce such requirements. UML Activity Diagrams are a well recognized way of representing those business processes. In this paper, we present an approach for enforcing quality requirements in such business processes through the application of process quality patterns to Activity Diagrams. These patterns are defined using a pattern description language, being a light-weight extension of UML Activity Diagrams. Accordingly, such patterns can be used in forward-engineering of business processes that incorporate quality constraints right from the beginning.

On the Pitfalls of UML 2 Activity Modeling

With the introduction of new Petri net-like semantics for Activities in UML 2.0, these have become a complete language for modeling behavior. Thus, UML Activities are nowadays investigated for application in many areas from embedded systems to business process modeling. However, some issues have been discovered that currently seem to limit the practical applicability of Activities. In this paper, we present an overview of the identified semantic and syntactic problems, and point at possible solutions and directions for future research.

UML-B Specification for Proven Embedded Systems Design

1 An Introduction to Formal Methods.- 2 Formally Unified System Specification Environment with UML, B and SystemC.- 3 Embedded System Design Using the PUSSEE Method.- 4 System Level Modelling and Refinement with EventB.- 5 The UML-B Profile for Formal Systems Modelling in UML.- 6 U2B.- 7 BHDL.- 8 Towards a Conceptual Framework for UML to Hardware Description Language Mappings.- 9 Interface-Based Synthesis Refinement in B.- 10 Refinement of Finite State Machines with Complementary Model Checking.- 11 Adaptive Cruise Control Case Study Design Experiment.- 12 Adaptive Cruise Controller Case Study.- 13 Formal Modelling of Electronic Circuits Using Event-B.- 14 The Echo Cancellation Unit Case Study.- 15 Results of the Mobile Design System Experiment.- 16 UML-B Specification and Hardware Implementation of a Hamming Coder/Decoder.- 17 The PUSSEE Method in Practice.- A1 Evaluation Criteria for Embedded System Design Methods.

Rapid Development of Modular Dynamic Web Sites Using UML

Development of dynamic Web sites is often performed by teams consisting of graphic designers and software developers. Communication between these different team members has to be supported with a simple modeling approach that considers their different academical backgrounds. Dynamic Web sites can contain multiple modules that may reappear on different pages. Reuse of both business logic and visual design modules would be desirable. Furthermore, a considerable amount of time is usually consumed by the implementation of data flows that are already defined in the model. Rapid development is enabled by providing roundtrip engineering capabilities with support for automatic code generation. We propose a simple subset of the UML adapted to the problem domain by means of stereotypes as well as a strategy for generating code templates from such models. These templates are tailored to the tasks of each team member. This enables parallel work and automated reintegration of results.

A Pattern-driven Development Process for Quality Standard-conforming Business Process Models

Quality management is a hot issue in most organisations and must be considered in the business processes of the organisation. Existing approaches on business process modelling provide neither explicit strategy to model quality requirements on business processes nor do they provide explicit support for the construction of business processes satisfying such quality requirements. In this paper, we present a pattern-driven development process for modelling business processes with respect to given quality constraints. We introduce a visual pattern specification language based on UML Activity Diagrams that enables the expression of quality constraints as patterns. These patterns can be used in a forward-engineering development process which supports the business process designer in constructing business processes by applying patterns. Thereby, quality constraints can be integrated into the design of business processes seamlessly