Gernot Schmoelzer

The Entity Container - An Object-Oriented and Model-Driven Persistency Cache

Data persistency is a fundamental, but complex aspect of a modern software development process. Therefore, in order to reduce development costs and improve a systems quality, support for data persistency must be provided to common software paradigms, such as object-oriented programming or component based development. In this paper we present a new approach of an object persistency cache - the Entity Container (EC), based on a data model. The EC allows data and metadata management according to a data model independent of any specific persistency mechanism. We present the complete architecture, functionality and implementation of the system and compare our new approach with existing frameworks in order to point out features and major improvements of the EC.

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 hybrid component-based system development process

Component-based development (CBD) distinguishes the process of component development from that of component-based system development. While reuse is the foundation of CBD, conventional development methods are not suitable for that kind of software development. In this paper we present a hybrid development process for component-based software systems that capitalizes on benefits from model-driven and test-driven process models, and give an experience report from a pilot project in which this novel development methodology has been applied.

Model-driven development of recursive CORBA component assemblies

Software applications can be described as compositions of software components at an abstract level. In This work we present a component modeling process which allows to design, model and implement recursive component compositions. We model nested components in a platform independent manner and provide a transformation to the CORBA component model (CCM), one example of a platform specific model (PSM). Furthermore, an implementation technique of recursive component assembling compliant to the CCM standard is described, where the components structure is automatically generated by code generation tools.

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.

Towards a contract aware CORBA component container

Component based software engineering (CBSE) suggests the idea of applications as assemblies of prefabricated components. Practical experiences with the CORBA component model (CCM), which is a multi-language and multi-platform component architecture, have shown that pure syntax declarations are inadequate for describing trustworthy software components, in particular for reuse. In this paper we present a contract extension to the CCM metamodel, a contract aware CCM container that improves the trustworthiness of CORBA components and experimental results that explore the runtime impacts of contract verification.

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

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.