Uwe Zdun

Modeling process-driven and service-oriented architectures using patterns and pattern primitives

Service-oriented architectures are increasingly used in the context of business processes. However, the proven practices for process-oriented integration of services are not well documented yet. In addition, modeling approaches for the integration of processes and services are neither mature nor do they exactly reflect the proven practices. In this article, we propose a pattern language for process-oriented integration of services to describe the proven practices. Our main contribution is a modeling concept based on pattern primitives for these patterns. A pattern primitive is a fundamental, precisely specified modeling element that represents a pattern. We present a catalog of pattern primitives that are precisely modeled using OCL constraints and map these primitives to the patterns in the pattern language of process-oriented integration of services. We also present a model validation tool that we have developed to support modeling the process-oriented integration of services, and an industrial case study in which we have applied our results.

Business Compliance Governance in Service-Oriented Architectures

Governing business compliance with regulations, laws, best practices, contracts, and the like is not an easy task, and so far there are only limited software products available that help a company to express compliance rules and to analyze its compliance state. We argue that today’s SOA-based way of implementing and conducting business (e.g., using Web services and business process engines) lends itself very well to the development of a comprehensive compliance government solution that effectively aids companies in being compliant. In this paper, we contextualize the compliance problem in SOA-based businesses, we highlight which are the most salient research challenges that need to be addressed, and we describe our approach to compliance governance, spanning design, execution, and evaluation concerns.

A survey of patterns for Service-Oriented Architectures

Service-Oriented Architectures (SOA) are a promising means to integrate heterogeneous systems, but virtually no technology-neutral approach to holistically understand SOAs exists. We tackle this problem by introducing a survey of technology-independent patterns that are relevant for SOAs, and are working towards a formalised pattern-based reference architecture model to describe SOA concepts.

Modeling architectural patterns using architectural primitives

Architectural patterns are a key point in architectural documentation. Regrettably, there is poor support for modeling architectural patterns, because the pattern elements are not directly matched by elements in modeling languages, and, at the same time, patterns support an inherent variability that is hard to model using a single modeling solution. This paper proposes tackling this problem by finding and representing architectural primitives, as the participants in the solutions that patterns convey. In particular, we examine a number of architectural patterns to discover those primitive abstractions that are common among the patterns, and at the same time demonstrate a degree of variability in each pattern. These abstractions belong in the components and connectors architectural view, though more abstractions can be found in other views. We have selected UML 2 as the language for representing these primitive abstractions as extensions of the standard UML elements. The added value of this approach is twofold: it proposes a generic and extensible approach for modeling architectural patterns by means of architectural primitives; it demonstrates an initial set of primitives that participate in several well-known architectural patterns.

On the transformation of control flow between block-oriented and graph-oriented process modelling languages

Much recent research work discusses the transformation between different process modelling languages. This work, however, is mainly focussed on specific process modelling languages, and thus the general reusability of the applied transformation concepts is rather limited. In this paper, we aim to abstract from concrete transformations by distinguishing two major paradigms for representing control flow in process modelling languages: block-oriented languages (such as BPEL and BPML) and graph-oriented languages (such as BPMN, EPCs, and YAWL). The contribution of this paper are generic strategies for transforming from block-oriented process languages to graph-oriented languages, and vice versa.

Systematic literature review of the objectives, techniques, kinds, and architectures of models at runtime

In the context of software development, models provide an abstract representation of a software system or a part of it. In the software development process, they are primarily used for documentation and communication purposes in analysis, design, and implementation activities. Model-Driven Engineering (MDE) further increases the importance of models, as in MDE models are not only used for documentation and communication, but as central artefacts of the software development process. Various recent research approaches take the idea of using models as central artefacts one step further by using models at runtime to cope with dynamic aspects of ever-changing software and its environment. In this article, we analyze the usage of models at runtime in the existing research literature using the Systematic Literature Review (SLR) research method. The main goals of our SLR are building a common classification and surveying the existing approaches in terms of objectives, techniques, architectures, and kinds of models used in these approaches. The contribution of this article is to provide an overview and classification of current research approaches using models at runtime and to identify research areas not covered by models at runtime so far.

Designing runtime variation points in product line architectures: three cases

Software product lines provide a common architecture, reusable code, and other common assets for a set of related software products. Variation is a central requirement in this context, as the product line components have to be instantiated, composed, and configured in the context of the products. In many approaches either static composition techniques or dynamic composition techniques based on loose relationships, such as association, aggregation, and replacement of entities, are proposed to design the variation points. If the domain of the product requires runtime variation, however, these approaches do not provide any central management facility for the runtime variation points. As a solution to this problem, we propose a pattern language that provides a domain-specific variation language and runtime variation point management facilities as part of the product line. We present three case studies from the areas of interactive digital television and document archiving in which we have applied this pattern language.

Model-driven and pattern-based integration of process-driven SOA models

Service-oriented architectures (SOA) are increasingly us ed in the context of business processes. However, the modeling approaches for process-driven SOAs do not yet suffi ciently integrate the various kinds of models relevant for a process-driven SOA ‐ ranging from process models to sof tware architectural models to software design models. We propose to integrate process-driven SOA models via a mode l-driven software development approach that is based on proven practices documented as software patterns. We int roduce pattern primitives as an intermediate abstraction to formally model the participants in the solutions that pat terns convey. To enable model-driven development, we develop domain-specific modeling languages for each kind ofprocess-driven SOA model ‐ based on formal metamodels that are extended with the pattern primitives. The va rious process-driven SOA models are integrated in a model-driven tool chain via the meta-models. Our tool chainvalidates the process-driven SOA models with regard to the constraints given by the meta-models and primitives.

Piecemeal legacy migrating with an architectural pattern language: a case study

Numerous large applications that have evolved over many years are well-functioning and reliable, but have severe problems regarding flexibility and reuse. Due to the many fixes that were applied in a systems lifetime, it is often hard to customize, change or exchange system parts. Therefore, it is problematic to migrate such systems to a more flexible architecture or to new technologies. The document archive/retrieval system, discussed in this article, is an example of a large C system that had such problems. As a solution, we will sketch an architectural pattern language that involves patterns well-suited for a piecemeal migration process. The patterns aim at building and composing highly flexible black-box component architectures with an object-oriented glueing layer. We present a re-engineering case study for the document archive/retrieval system based on these patterns. The patterns are used to wrap the existing C implementations and integrate them with an object system. Moreover, the patterns introduce flexibility hooks into the hot spots of the architecture and let components define their required environment. This enables an easier future evolution of the system. The case study demonstrates a pattern language as an approach for piecemeal legacy migration apart from implementation details.

Reengineering to the Web: a reference architecture

Reengineering existing (large-scale) applications to the Web is a complex and highly challenging task. This is due to a variety of demanding requirements for interactive Web applications. High performance is usually required, old interfaces still have to be supported, high availability requirements are usual, information has to be provided to multiple channels and in different formats, pages should contain individual layouts across different channels, styles should be imposed over presentation, etc. To achieve these goals a variety of different technologies and concepts have to be well understood, including HTTP protocol handling, persistent stores/databases, various XML standards, authentication, session management, dynamic content creation, presentational abstractions, and flexible legacy system wrapping. In a concrete project, all these components have to be integrated properly and appropriate technologies have to be chosen. On basis of practical and theoretical experience in the problem domain, in this paper, we try to identify the recurring components in reengineering projects to the Web, lay out critical issues and choices, and conceptually integrate the components into a reference architecture.