Transaction management in object-oriented data base systems

Object-oriented data bases are fast gaining in popularity, especially with the advent of advanced applications like computer aided design (CAD) and multimedia data bases (MMDB). The modeling techniques required by these applications cannot be met by conventional data base systems. The semantic richness of the object-oriented model facilitates the modeling of advanced data base applications. These applications are characterized by long-duration cooperating transactions. Unlike the conventional data bases, serializability can no linger be the correctness criterion for concurrent transaction execution. A new transaction model for object-oriented data bases is needed. This dissertation describes our research in the area of transaction management for object-oriented data bases. A new transaction model for object-oriented data bases is defined. This model takes into consideration the unique requirements of the advanced applications. Data base consistency is now defined in terms of correctability. Object-oriented Correct Schedules (OOCS) and Object-oriented Correctable Schedules (OOCLS) are defined. This dissertation also describes a new concurrency control protocol that satisfies the correctness criterion for concurrent execution of transactions in an object-oriented data base environment, i.e. it allows only Object-oriented Correctable Schedules. Users of a data base interact with it through means of queries. Queries are then translated into transactions. The data base functionality necessary to support queries is also discussed in this research work

Object-Oriented Software Representation of Polymer Materials Information in Engineering Design

The software application POISE, Polymer Objects in a Smalltalk™ Environment, integrates knowledge representation, user interfaces, and data management; a system of tools for the materials domain expert involved in design. Engineering design solutions initially build from generalisations. POISE represents multiple levels of generalisations from classifications of polymer information. The class-instance paradigm classifies software objects. An object’s behaviour is an exclusive function of its class. Polymer’s behaviours are a function of multiple orthogonal factors, like chemistry and processing, therefore multiple orthogonal classes must represent polymers. Taxonomy only represents one of these factors. The Enhancer mechanism resolves this conflict between classification and representation. Polymer classification is not well established, with new materials evolving. The software compensates by evolving the classification schema. Guided with a specialised interface tool, the domain expert updates the schema by adding new polymer families and re-classifying existing classes. Through analysing the generalisations in the classification, the domain expert can develop an appropriate classification. This analysis relies on the engineering properties differentiating the principal material qualities. Standard properties do not distinguish specific structural differences in polymer materials, necessitating new properties. Material properties distinguish materials in the domain whereas the classes describe the properties of polymer objects. Domain experts add new properties to the polymer classes to distinguish polymer objects. Properties are independent objects that partially describe the class template; Partial Template Objects. Persistence of personal design information and management of shared data requires dichotomous database management. Shared data requires multi-user access, and consequently transaction management. Transaction management in object-oriented systems often holds resources for a long duration. Transaction declaration hinders transparent access to storage, and corrupts the representation. For single-user design information, transactions are implicit with access. Database proxies provide transparent per-object transaction management to persistent design information. The WorkBase is an object-storage utility that utilises Enhancers as proxies

Flexible cooperation in non-standard application environments

The integration of preexisting systems into a single, heterogeneous, distributed non-standard application system in domains like office automation or computer-integrated manufacturing are regarded as cooperating systems. They are characterized through teamwork, distribution and the handling of complex data structures (e.g. multimedia data). Object-oriented database systems, providing for complex object management, represent one approach in support of such applications. They concentrate, however, on data modeling aspects and use more or less conventional transaction concepts, based on a global execution control. Hence, they only partially fulfill application requirements as they do not adequately cope with the autonomy that is often inherent to the system's components. As a consequence, we suggest S-transactions as an appropriate means for describing the cooperation of system components in terms of transactions and beyond. In this paper we outline the modeling of conventional transactions (flat or nested as well as distributed and design transactions) in terms of STDL, the S-transaction definition language. Beyond that we point out how to specify SAGAs and similar concepts. Finally we discuss the specification of non-linear but maybe acyclic or even cyclic cooperation structuresPrepared for: Naval Ocean Systems Center and funded by the Naval Postgraduate School.http://archive.org/details/flexiblecooperat00holtO&MN, Direct FundingNAApproved for public release; distribution is unlimited

Two Case Studies of Subsystem Design for General-Purpose CSCW Software Architectures

This paper discusses subsystem design guidelines for the software architecture of general-purpose computer supported cooperative work systems, i.e., systems that are designed to be applicable in various application areas requiring explicit collaboration support. In our opinion, guidelines for subsystem level design are rarely given most guidelines currently given apply to the programming language level. We extract guidelines from a case study of the redesign and extension of an advanced commercial workflow management system and place them into the context of existing software engineering research. The guidelines are then validated against the design decisions made in the construction of a widely used web-based groupware system. Our approach is based on the well-known distinction between essential (logical) and physical architectures. We show how essential architecture design can be based on a direct mapping of abstract functional concepts as found in general-purpose systems to modules in the essential architecture. The essential architecture is next mapped to a physical architecture by applying software clustering and replication to achieve the required distribution and performance characteristics

Designing Software Architectures As a Composition of Specializations of Knowledge Domains

This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience

Compensation methods to support generic graph editing: A case study in automated verification of schema requirements for an advanced transaction model

Compensation plays an important role in advanced transaction models, cooperative work, and workflow systems. However, compensation operations are often simply written as a^−1 in transaction model literature. This notation ignores any operation parameters, results, and side effects. A schema designer intending to use an advanced transaction model is expected (required) to write correct method code. However, in the days of cut-and-paste, this is much easier said than done. In this paper, we demonstrate the feasibility of using an off-the-shelf theorem prover (also called a proof assistant) to perform automated verification of compensation requirements for an OODB schema. We report on the results of a case study in verification for a particular advanced transaction model that supports cooperative applications. The case study is based on an OODB schema that provides generic graph editing functionality for the creation, insertion, and manipulation of nodes and links

An Object-Oriented Language-Database Integration Model: The Composition-Filters Approach

This paper introduces a new model, based on so-called object-composition filters, that uniformly integrates database-like features into an object-oriented language. The focus is on providing persistent dynamic data structures, data sharing, transactions, multiple views and associative access, integrated with the object-oriented paradigm. The main contribution is that the database-like features are part of this new object-oriented model, and therefore, are uniformly integrated with object-oriented features such as data abstraction, encapsulation, message passing and inheritance. This approach eliminates the problems associated with existing systems such as lack of reusability and extensibility for database operations, the violation of encapsulation, the need to define specific types such as sets, and the incapability to support multiple views. The model is illustrated through the object-oriented language Sina

Compensation methods to support cooperative applications: A case study in automated verification of schema requirements for an advanced transaction model

Compensation plays an important role in advanced transaction models, cooperative work and workflow systems. A schema designer is typically required to supply for each transaction another transaction to semantically undo the effects of . Little attention has been paid to the verification of the desirable properties of such operations, however. This paper demonstrates the use of a higher-order logic theorem prover for verifying that compensating transactions return a database to its original state. It is shown how an OODB schema is translated to the language of the theorem prover so that proofs can be performed on the compensating transactions

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow