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.

This poster presentation illustrates the use of SOM (the IBM System Object Model) for interfacing, different object-oriented programming (OOP) languages. Our approach allows classes defined in one OOP language to be used by different (possibly non-OOP) languages—both for subclassing, and for object creation. This extends the utility of OOP class libraries and makes it possible to define “multilanguage” objects, whose supporting methods and instance variables are provided by different languages.

article Free Access Share on Developing language neutral class libraries with the System Object Model (SOM) Authors: Mike Conner View Profile , Nurcan Coskun View Profile , Scott Danforth View Profile , Larry Loucks View Profile , Andy Martin View Profile , Larry Raper View Profile , Roger Sessions View Profile Authors Info & Claims ACM SIGPLAN OOPS MessengerVolume 4Issue 2April 1993 pp 191–193https://doi.org/10.1145/157710.157751Online:01 December 1992Publication History 0citation180DownloadsMetricsTotal Citations0Total Downloads180Last 12 Months2Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

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.

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.

FAD is a strongly typed, computationally complete database programming language designed for creating and manipulating shared complex objects within Bubba, a parallel database system developed at MCC. This paper describes the compiler that transforms a FAD program into a load module targeted for execution on Bubba. In addition to low level code generation, the major functions of the compiler are static type checking and inferencing, optimization with respect to Bubba resources, and parallelization. This leads to efficient, type secure execution on Bubba.

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.

Object-oriented programming is becoming a popular approach to the construction of complex software systems. Benefits of object orientation include support for modular design, code sharing, and extensibility. In order to make the most of these advantages, a type theory for objects and their interactions should be developed to aid checking and controlled derivation of programs and to support early binding of code bodies for efficiency. As a step in this direction, this paper surveys a number of existing type theories and examines the manner and extent to which these theories are able to represent the ideas found in object-oriented programming. Of primary interest are the models provided by type theories for abstract data types and inheritance, and the major portion of this paper is devoted to these topics. Code fragments illustrative of the various approaches are provided and discussed. The introduction provides an overview of object-oriented programming and types in programming languages; the summary provides a comparative evaluation of the reviewed typing systems, along with suggestions for future work.

This dissertation presents DOT, a process-oriented design and simulation model for a highly parallel multiprocessor, and describes a complete associated programming system. The design methodology includes the use of layered design. abstract data types, and a process-oriented view of concurrency. Our results demonstrate that these software engineering structuring principles can be successfully applied to the design of highly parallel multiprocessors. DOT is represented using an executable high-level language that provides support for discrete-event simulation. This allows verification and accurate simulation of the complete programming system, which is composed of three logical levels. The top, or user level of the programming system is that of FFP (Formal Functional Programming) languages. The middle, or system support level is that of LPL, a low-level concurrent programming language used to define and implement FFP operators on the DOT architecture. The DOT design represents the lowest level of the programming system, a highly parallel tree-structured multiprocessor that directly supports the LPL and FFP languages. During execution, user programs consisting of FFP language symbols are entered into a linear array of processing cells (the leaves of the binary tree of processors represented in the DOT design), and segments of this array that contain innermost FFP applications execute LPL programs in order to perform the required reductions. The LPL programs for a useful set of FFP primitives are given. In addition to DOT and the overall programming system, this dissertation presents an analytic model which maybe used to derive upper and lower bounds for program execution time. Predictions of the analytic model are compared with simulation results, and various design alternatives and possible extensions are examined.