Zsolt Kovács

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.

Local components and reuse of legacy code in the CORBA component model

The CORBA component model (CCM) seemed to be a new powerful multi-language and multi-platform component development framework. First applications based on CCM have shown that there are some drawbacks in practical use. We present a new approach for the CCM component implementation which improves communication performance of components living in the same address space. At the same time we simplify the component development process and the reuse of legacy code within components. These extensions to CCM are possible without changing its specification.

A test-driven component development framework based on the CORBA component model

Short product cycles and rapidly changing requirements are increasingly forcing developers to use agile development strategies like extreme programming and test-driven development. At the same time, hierarchical software design strategies such as component based software engineering are becoming necessary to overcome increasing software complexity. In this paper, we present a test-driven component development framework that encapsulates test code in a mirror component for automated testing during development, and as an executable semantic to simplify assessment and to increase trustworthiness of software systems.

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.

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