Michael Thonhauser

Model-typed Component Interfaces

Component based software engineering (CBSE) allows to design and develop reusable software components that can be assembled to construct software systems via well defined interfaces. However, designing such reusable components for data intensive business logic often requires heavy data transfer between components over interfaces. Static interface definitions using basic data types or structures of such lead to large interfaces susceptible to modifications. The goal of this paper is to present model-typed interfaces based on generic interface parameters, which allows to transfer complex structured data between components. Providing such generic, model-defined types with data models specifying the parameter structure supports compatibility checks of model-typed interfaces at assembly time. The methodology is described platform independently and the coherency with our system development process is discussed. Moreover, a technology mapping to IDL and the CORBA Component Model (CCM) is illustrated.

Model-Based Data Processing with Transient Model Extensions

Software is often constructed using a layered approach to encapsulate the functionality in different layers. Individual requirements of each layer demand layer specific data structures. These data structures typically provide redundant information with respect to the data source. Providing a model driven software development approach for creating these data structures leads to overlapping data models, each containing data structures defined by the data source. Because putting all various requirements of the software layers in a single data model can lead to difficulties, each software layer should only extend the basic data source model with its specifically needed model elements. This paper presents a mechanism for transient extension of a data model. Using this mechanism, a basic data model can be used by every layer, being extended by additional attributes and classes for satisfying layer specific requirements

A Model-Based Architecture Supporting Virtual Organizations in Pervasive Systems

Modern distributed computer systems, with mobile and embedded devices as first class citizens, are formed from heterogeneous platforms. Owing to their distributed nature, dynamic reconfiguration and adaptation are reflecting different ownerships and administration domains of devices and applications. A portable, plug-in extensible runtime architecture is presented that explicitly honors ownership and realm of control of hardware devices, resources and application components. Based on such an architecture, their owners, while pursuing their very own business models, can cooperatively form Virtual Organizations (VO) to run applications defined by model-based software components (MBSC), consisting of a set of high-level models that are directly interpreted by this architectures runtime nodes.

Interpreting Model-Based Components for Information Systems

To foster the reuse of software artifacts various approaches like Component Based Software Engineering or Model-Driven Software Development have been proposed. These approaches support a developer in generating and implementing platform specific software artifacts, which can be executed on the chosen runtime architecture. To facilitate portability of these artifacts to other runtime architectures it is important to model various aspects of the artifact (i.e. user interface, behavior, data) in a platform independent way. While this abstraction helps to reduce complexity of the problem, choosing the right granularity of methods provided by this artifact is another important issue for enhancing software quality.Considering these aspects a model-based development approach is presented, which is based on the interpretation of several model views -- like state machine and class diagrams being provided by a model-based software component. Additionally the integration of components build with this approach in the design of an information system is discussed. The proposed architecture is evaluated by animplementation in the software application domain of logistics.

ECQL: A Query and Action Language for Model-Based Applications

Modern distributed computer systems with mobile and embedded devices as first class citizens are formed from heterogeneous platforms. To support this heterogeneity along with adaptation of the system an approach for interpretation of domain specific models at runtime has been proposed with the concept of Model-Based Software Components (MBSC), separating the domain specific functionality from the current technical platform. This is achieved by the usage of different sets of high-level models. These sets are interpreted by a portable, plugin-extensible runtime environment, utilizing several instances of model-based containers (MCC) for models and their corresponding data. In this paper the design of a domain specific language is presented, enabling the specification of accessing and manipulating data entities provided by various MCCs used in the runtime architecture of a MBSC. For demonstration purposes the application of the various language elements is presented using a case study of an exemplary distributed pervasive system running in the business domain of logistics.

Platform Design for Software Product Lines of Data-intensive Systems

Software product line engineering promises rapid, feature oriented development of similar products in a particular domain by reusing core artifacts. Commonalities and variabilities of individual products are obtained by domain analysis and described in feature models. According to the feature model, reusable core assets or artifacts need to be designed and implemented to be assembled in particular products. In this paper we present a platform supporting product line development of data-intensive systems, based on the concepts of component based and model-driven development. Data-intensive systems are often built in several layers (e.g. database, business logic, user interface), so we have applied the methodology of product line engineering to each layer to find artifacts, describe their characteristics and dependencies. Mappings are defined between features and artifacts in order to assemble different products from these reusable artifacts. Model-based strategies to tackle cross-cutting of variabilities-arising especially from data model variabilities-are presented.

Reflective, Model-Based Data Access with the Type-Safe Entity Container

Data centric applications can benefit heavily from model-based data access abstraction. This fosters understanding, maintainability, as well as independence from persistency mechanisms. Utilizing metadata from the domain data model allows to write generic, reusable software modules. However, for a business logic application part, direct, type-safe manipulation of persistent object attributes is more typical. Thus, both are important programmatic use cases and coexist in data centric applications. In this paper, we describe the concept of a dynamic and model-based object cache, the entity container (EC), and discuss the needs, design and implementation of a type-safe access layer upon the EC, called TSEC. Therefore, providing both access mechanisms to an EC in parallel, dynamic data and metadata access as well as static type-safe access, allows to develop flexible and reusable software modules at different abstraction levels, even independent of particular domain models

Applying Multi-model Based Components for Virtual Organizations

Raising the level of abstraction is an important research topic in the context of software for mobile and embedded devices. Model Driven Software Development techniques have been recognized for their ability to provide this abstraction by separating domain specific aspects from their technical implementation. Traditionally, such approaches rely on static code generation, which does not fit well in an evolving, collaborating system managed by multiple participating organizations. In order to support such dynamically (re-)configuring Virtual Organizations with high, domain specific abstraction levels, the presented approach is based on loosely coupled, run-time executed Model Based Software Components (MBSC). An MBSC is defined and implemented by potentially multiple distinct models covering all necessary domain-specific aspects (e.g.\ behavior, data) of the component. MBSCs are deployed to a distributed runtime architecture, where they reside in model-based component containers. System evolution during operation is supported by these plug in-extensible containers, which support additional kinds of MBSC models. A scenario for a building access system that consists of MBSCs owned by independent, yet cooperating organizations (facility management, security, departments), is analyzed in this paper. Finally, several system evolution use cases are discussed.

Data Model Driven Enterprise Service Bus Interceptors

Integration of distributed software systems is an important issue in enterprise computing. Assembling of loosely coupled services via XML based protocols is a frequently used technique today. To overcome the struggle between safety of a strong typed interface and flexibility of generic parameters, we present a novel approach that uses model-typed interface parameters together with the idea of model compatibility verification. It respects separated ownerships of service provider and consumer interfaces, and adds a mediating connector based on platform-independent, model-based functional interface reconciliation. Given a pair of compatible interfaces an interface connector that integrates related services can be realized automatically. The concept of rule-based compatibility verification can also increase the efficiency of service repository lookups significantly.