Scott Danforth

Prototyping Bubba, a highly parallel database system

Bubba is a highly parallel computer system for data-intensive applications. The basis of the Bubba design is a scalable shared-nothing architecture which can scale up to thousands of nodes. Data are declustered across the nodes (i.e. horizontally partitioned via hashing or range partitioning) and operations are executed at those nodes containing relevant data. In this way, parallelism can be exploited within individual transactions as well as among multiple concurrent transactions to improve throughput and response times for data-intensive applications. The current Bubba prototype runs on a commercial 40-node multicomputer and includes a parallelizing compiler, distributed transaction management, object management, and a customized version of Unix. The current prototype is described and the major design decisions that went into its construction are discussed. The lessons learned from this prototype and its predecessors are presented. >

Release-to-release binary compatibility in SOM

SOM (IBMs System Object Model) removes a major impediment to reuse in Object-Oriented Programming by facilitating the programming of release-to-release binary compatible class libraries. This is accomplished by supporting a large number of compatibility preserving transformations. Taken together these transformations compose a discipline for programming evolving class libraries.

Reflections on metaclass programming in SOM

This paper reports on the evolution of metaclass programming in SOM (the IBM System Object Model). Initially, SOMs use of explicit metaclasses introduced metaclass incompatibilities. This was cured by having SOM dynamically derive an appropriate metaclass by interpreting the “metaclass declaration” as a constraint. In effect, inheritance is given a new dimension, because the constraint is also inherited. The derived metaclass is the least solution to all these constraints. Subsequently, this cure led to the possibility of metaclasses conflicting over the need to assign meaning to a method. The cure for this problem is a framework that facilitates the programming of metaclasses that cooperate on the assignment of meaning to methods.

Composition of before/after metaclasses in SOM

In SOM, the IBM System Object Model, a class is a run-time object that defines the behavior of its instances by creating an instance method table. Because classes are objects, their behavior is defined by other classes (called metaclasses). For example, a “Before/After Metaclass” can be used to define the implementation of classes that, by suitable construction of their instance method tables, arrange for each invocation of a method to be preceded by execution of a “before method” and followed by execution of an “after method”. This paper introduces and solves the problem of composing different Before/After Metaclasses in the context of SOM. An enabling element in the solution is SOMs concept of derived metaclasses , i.e., at run-time a SOM system derives the appropriate metaclass of a class based on the classes of its parents and an optional metaclass constraint.

A FAD for data intensive applications

FAD is a strongly typed database programming language designed for uniformly manipulating transient and persistent data on Bubba, a parallel database system developed at MCC. The paper provides an overall description of FAD, and discusses the design rationale behind a number of its distinguishing features. Comparisons with other database programming languages are provided. >

Integrating object and relational technologies

A precondition for integrating object-oriented and relational technologies is an integration of their respective models. A general approach to unifying the models is outlined. The essential features of the resulting model are that abstract data types (ADTs) provide the sole mechanism for encapsulating data and operations, an inheritance ordering on ADTs reflects common abstract interfaces and supports static typechecking, and there is a distinction between value and object ADT instances. Primitive data types provided by the model include atomic data and data structures. Instances of primitive data types are always values. An ADT is implemented using a primitive data type to store its state. What is normally in object-oriented terminology called a class, is called an ADT in the model discussed. Object-oriented databases (OODBs) often make use of class extents, which provide a useful indexing technique for objects. In the model discussed, extents appear as instances of ADTs whose state includes a set of objects plus a set of sub-extents.<<ETX>>

Parallelizing a database programming language

We extend distributed database query optimization techniques to support a database programming language, a language much richer than relational query languages. With the richness comes difficulties, e.g., how to recognize joins and how to handle aliases. In this paper we describe our techniques: dataflow analysis, abstract evaluation, partial evaluation, and rewriting. Also, we overview the algorithm that uses these techniques.

Query Optimization for Database Programming Languages

Many knowledge-based applications require efficient access and manipulation of database objects. Although high level declarative language formalisms have been suggested for programming these applications, the general purpose nature of such languages makes optimization for database access a much harder problem than with traditional query languages. In this paper, we present a solution to this problem that allows direct and effective use of existing query optimization techniques originally developed for relational databases.

Functional SQL (FSQL), an SQL upward-compatible database programming language

Abstract Functional sql (fsql) is an sql upward-compatible database programming language implemented as a syntactic extension of fad , a strongly typed functional programming language that supports a persistent database, complex objects with sharing, and general-purpose programming (e.g., iteration). Because it is based on fad , fsql can offer these capabilities with an sql -like syntax while providing standard sql as a subset. This paper introduces fsql , and describes the fsql -to- fad correspondence.

A Data and Operation Model for Advanced Database Systems

This paper introduces a model that combines and extends capabilities of relational and object oriented systems. Within a simple, statically-typed framework, the model supports abstract data types (ADTs), a multiple inheritance ordering on ADTs based on behavioral similarity, multi-targeted generic operations, polymorphic methods, type-independent persistence, and set-oriented rules over shared objects, values, classes, and relations. The model maintains a clear separation between interface and implementation, and resolves currently open problems for typed OODBs.