We believe that the regime governing the patterns of sharing between objects, and of exchange of messages between them, should not be “hard-wired” into a programming language, but should be specifiable by the builders of a system to fit its particular requirements. This thesis has been the primary motivation behind our general concept of law-governed system, which serves as the foundation for this paper.

This paper is based on a new approach for dealing with large scale software systems. This approach is based on the concept of a Law-Governed System, which is a triple

The central idea behind this paper is that the discipline governing the exchange of messages between objects should be specifiable by the programmer in the form of an explicit law of the system. We show how, starting from a very primitive foundation, which presumes neither encapsulation nor inheritance, one can establish various forms of both, as well as other useful disciplines, simply by means of appropriate laws.

This paper presents a model that provides a single comprehensive mechanism to control the use, operation and evolution of database systems. This model unifies several concepts generally considered to be quite distinct. In particular, it minimizes the formal distinction between the users of the database, the programs embedded in it and even the administrators and the programmers maintaining it. Furthermore, under this model, the concepts of subschema and of program module are replaced with a single concept of frame, which serves as the locus of power and of activity in the system. Moreover, the proposed control mechanism is closed, in the sense that the process of establishing controls is itself controllable by the same mechanism. This can be used to formalize and control managerial policies about the use and evolution of database systems.

Users of a relational database must explicitly navigate between relations in order to establish a connection among a set of attributes spanning several relation schemes. While a universal scheme interface to a relational database provides users with automatic navigation, it usually imposes on the database a unique role assumption. This assumption requires every attribute name to represent a unique role in the database, so that connections among sets of attributes are unambiguous.

In universal scheme interfaces to relational databases, an attribute name must represent a unique role in the database, so that the connection among a set of attributes is unambiguous. A drawback to this requirement is that several attributes can represent the same underlying class of of entities, but the relationship among those attributes is not captured in the database scheme. As our method for relating attributes uses natural joins, some semantically meaningful.

We discuss the philosophy, history and theory of window functions. Window functions (sometimes called connections) are a means to treat a relational database as a semantic whole, rather than as an arbitrary collection of relations. Simply stated, a window function maps a database state and a relation scheme to a relation over the scheme. Window functions are the basis for all existing universal scheme interfaces. We present an assumption inherent in universal scheme interfaces, the unique role assumption.Window functions have evolved along two paths, giving rise to computational definitions and weak instance definitions. We examine several examples of each type of window function, with special attention to the association-object window function of PIQUE. We then look at properties we feel a reasonable window function should satisfy, notably the containment condition and faithfulness. We also define implicit objects, which are relation schemes that a window function treats in a special manner, and which are useful for describing the behavior of window functions.

One of the main goals of database systems, relational systems in particular, is to provide a degree of physical data independence for users and programs. Users should not need to know the exact physical storage structures to use the database, and should be protected from changes in those structures. We attempt to go a step further, to logical data independence. We want an interface to a relational database where a user need not be concerned with how the data has been partitioned into various relations. The natural relation schemes to be used, from a semantic point of view, may be decomposed in the database for normalization or redundancy reasons. Our approach essentially loads all the semantics onto the attributes. In our query language tuple variables are not bound to specific relations. Rather, the system uses the set of attributes, say X, that appear in a query with a tuple variable, say t, to combine the database relations to form a single relation with scheme X over which t ranges. We describe our method for constructing such a relation given the associated set of attributes X. When tuple variables are bound implicitly, the logical connectives 'and', 'or', and 'not' take on 'semantic overtones' since they can affect the binding. We discuss the motivation behind the chosen semantics for these connectives. Our goal is a powerful, yet concise, query language with natural semantics.