Sebastian Thöne

Style-based modeling and refinement of service-oriented architectures

Service-oriented architectures (SOA) provide a flexible and dynamic platform for implementing business solutions. In this paper, we address the modeling of such architectures by refining business-oriented architectures, which abstract from technology aspects, into service-oriented ones, focusing on the ability of dynamic reconfiguration (binding to new services at run-time) typical for SOA.The refinement is based on conceptual models of the platforms involved as architectural styles, formalized by graph transformation systems. Based on a refinement relation between abstract and platform-specific styles we investigate how to realize business-specific scenarios on the SOA platform by automatically deriving refined, SOA-specific reconfiguration scenarios.

Process-Oriented, Flexible Composition of Web Services with UML

The composition of elementary web services to larger-scale services has become an important means to enhance e-business collaborations. If such composite web services can also integrate legacy components that are not yet provided as web services, the number of possible compositions is increased. Following a process-oriented approach, the compositions can be described as control- and data-flow between available web services and components. This paper discusses the Business Process Execution Language for Web Services (BPEL4WS), an existing service composition language, and proposes UML-WSC as an alternative, visual language. For the advanced description of service interfaces, UML-WSC extends the type system of the established Web Service Definition Language (WSDL).

Style-based refinement of dynamic software architectures

In this paper, we address the correct refinement of abstract architectural models into more platform-specific representations. We consider the challenging case of dynamic architectures which can perform run-time reconfigurations. For this purpose, the underlying platform has to provide the necessary reconfiguration mechanisms. To conceptually model such platforms including provided reconfiguration mechanisms, we use architectural styles formalized by graph transformation rules. Based on formal refinement relations between abstract and platform-specific styles, we can then investigate how to realize business-specific scenarios on a certain platform by automatically deriving refined, platform-specific reconfiguration scenarios.

Process Modeling using UML

The Unified Modeling Language (UML)1 is a visual, object-oriented, and multipurpose modeling language. Primarily designed for modeling software systems, it can also be used for business process modeling. Since the early 1970s, a large variety of languages for data and software modeling like entity-relationship diagrams [2], message sequence charts [5, 10], state charts [9], and so on, have been developed, each of them focusing on a different aspect of software structure or behavior. In the early 1990s, object-oriented design approaches gained increasing attention, for instance, in the work of James Rumbaugh (Object Modeling Technique or OMT [21]), Grady Booch [1], and Ivar Jacobson [12]. The UML emerged from the intention of Rumbaugh, Booch, and Jacobson to find a common framework for their approaches and notations. Furthermore, the language was also influenced by other object-oriented approaches like that of Coad and Yourdon [3]. The first version, UML 1.0 [20], was released in 1997 and accepted as a standard by the Object Management Group (OMG)2 the same year. The OMG, which took over the responsibility for the evolution of the UML from then on, is a consortium from both industry and academia and is also responsible for other wellknown initiatives like CORBA, MDA, and XMI. OMG specifications have to undergo a sophisticated adoption process before being agreed upon as a standard by the OMG members. Since many important tool builders and influential software companies are involved in the OMG, UML has quickly been accepted by the software industry, especially since version UML 1.3 appeared in 1999. When writing this book, the current UML version was UML 2.0 [18], a major revision of the language. UML is a conglomeration of various diagram types. Therefore, the challenge is to provide a uniform framework for all these heterogeneous diagram types and accounting for relationships between them. In UML, this is solved by a common meta-model that formally defines the abstract syntax of all diagram types. The

Behavioral Refinement of Graph Transformation-Based Models

Model-driven software engineering requires the refinement of abstract models into more concrete, platform-specific ones. To create and verify such refinements, behavioral models capturing recon- figuration or communication scenarios are presented as instances of a dynamic meta-model, i.e., a typed graph transformation system specifying the concepts and basic operations scenarios may be composed of. Possible refinement relations between models can now be described based on the corresponding meta-models.In contrast to previous approaches, refinement relations on graph transformation systems are not defined as fixed syntactic mappings between abstract transformation rules and, e.g., concrete rule expressions, but allow for a more loose, semantically defined relation between the transformation systems, resulting in a more flexible notion of refinement.

Behavior-preserving refinement relations between dynamic software architectures

In this paper, we address the refinement of abstract architectural models into more platform-specific representations. For each level of abstraction, we employ an architectural style covering structural restrictions on component configurations as well as supported communication and reconfiguration operations. Architectural styles are formalized as graph transformation systems with graph transformation rules defining the available operations. Architectural models are given as graphs to which one can directly apply the transformation rules in order to simulate operations and their effects. In addition to previous work, we include process descriptions into our architectural models in order to control the communication and reconfiguration behavior of the components. The execution semantics of these processes is also covered by graph transformation systems. We propose a notion of refinement which requires the preservation of both structure and behavior at the lower level of abstraction. Based on formal refinement relationships between abstract and platform-specific styles, we can use model checking techniques to verify that abstract scenarios can also be realized in the platform-specific architecture.

Process-oriented, consistent integration of software components

The integration of software components becomes a more and more important issue in software engineering. Process-oriented approaches should provide automated information processes. Therefore, the software components have to be integrated in a consistent way, i.e., their export interfaces have to be respected by the importing components. Furthermore, the type system of component interfaces has to support a tunable degree of freedom. This allows the insertion of components with interfaces of restricted but sufficient degree of compatibility. In this paper, we develop a concept for consistent and flexible integration of components. We present a process modeling language that combines UML and XML in order to support consistent, flexible, and executable processes. Finally, we provide a formalization of the proposed component type system.