Reflective systems allow their own structures to be altered from within. Here we are concerned with a style of reflection, called linguistic reflection, which is the ability of a running program to generate new program fragments and to integrate these into its own execution. In particular, we describe how this kind of reflection may be provided in the compiler-based, strongly typed object-oriented programming language Java. The advantages of the programming technique include attaining high levels of genericity and accommodating system evolution. These advantages are illustrated by an example taken from persistent programming, which shows how linguistic reflection allows functionality (program code) to be generated on demand (Just-In-Time) from a generic specification and integrated into the evolving running program. The technique is evaluated against alternative implementation approaches with respect to efficiency, safety and ease of use. © 1998 John Wiley & Sons, Ltd.

In this paper we characterise exactly the complexity of a set based database language called SRL, which presents a unified framework for queries and updates.By imposing simple synt act ic restrictions on it, we are able to express exactly the classes, P and L OGSPA CE.We also discuss the role of ordering in database query languages and show that the hom operator of Machiavelli language in [OBB89]does not capture all the order-independent properties.Complexity

Maintaining the integrity of databases is one of the promises of database management systems. This includes assuring that integrity constraints are invariants of database transactions. This is very difficult to accomplish efficiently in the presence of complex constraints and large amounts of data. One way to minimize the amount of processing required to maintain database integrity over transaction processing is to prove at compile-time that transactions cannot, if run atomically, disobey integrity constraints. We report on a system that performs such verification for a robust set of constraint and transaction classes. The system accepts database schemas written in a more or less traditional style and accepts programs in a high-level programming language. Automatic verification fast enough to be effective on current workstation hardware is performed.

Some information in databases and knowledge bases often needs to be protected from disclosure to certain users. Traditional solutions involving multi-level mechanisms are threatened by the user's ability to infer higher level information from the semantics of the application. We concentrate on the revelation of secrets through a user running transactions in the presence of database integrity constraints. We develop a method of specifying secrets formally that not only exposes a useful structure and equivalence among secrets but also allows a theorem prover to detect certain security lapses during transaction compilation time.

Data models have been proposed as a means of defining the objects and operations in an office information system. Office documents, because of their highly variable structure and multimedia content, are a difficult class of objects to model. The modeling task is further complicated by document architecture standards used for interchange between systems. We present an approach to data modeling based on constrained type definitions that allows architecture standards to be defined and ensures that individual document types conform to those standards. The ADABTPL model, which is used to define the schema of document types and standards, is described.

An analysis of database transactions in the presence of database integrity constraints can lead to several modes of feedback to transaction designers. The different kinds of feedback include tests and updates that could be added to the transaction to make it obey the integrity constraints, as well as predicates representing post-conditions guaranteed by a transaction's execution. We discuss the various modes, meanings, and uses of feedback. We also discuss methods of generating feedback from integrity constraints, transaction details and theorems constituting both generic knowledge of database systems and specific knowledge about a particular database. Our methods are based on a running system that generates tailored theories about database systems from their schemas and uses these theories to prove that transactions obey integrity constraints.

The basic data types from which records can be constructed in most database management systems are limited to a few simple types such as integers, reals, and character strings. There are many applications, exemplified by office automation, computer-aided design and geographic information systems, that could benefit from management of databases containing the complex objects typically used in programming these systems. We call databases that contain user defined abstract data types object-extended databases. In this paper we examine three aspects of providing support for object-extended databases: their specification, their manipulation by transactions, and access to them via queries. We show that a database specification scheme grounded formally in three abstract data types, finite sets, tuples and lists, accommodates the integration of databases and arbitrary abstract data types from the points of view of database designers, transaction programmers, and query writers and implemented.1

Gutenberg is a port-based operating system being designed to study protection issues in distributed systems. All shared resources are viewed as protected objects and hence can be assessed only via specific operations defined on them. Processes communicate and access objects through the use of ports. Each port is associated with an abstract data type operation and can be created by a process only if the process has the capability to execute the operation on the type. Thus, a port represents the privilege of the port's client process to request a service. Capabilities to create ports for requesting operations are contained in a capability directory, which is navigated by processes to gain these capabilities. Privilege transfer is a means of providing servers access to the resources they need to perform their services. In Gutenberg, privilege transfer is accomplished by allowing access to subdirectories of the capability directory and by passing capabilities, including port access capabilities, to processes via ports. It should be possible to revoke transferred privileges when breaches of trust are detected or suspected, when a period of time has passed beyond which the distributor of a privilege does not want the privilege shared, or when an error has been detected.

An interprocess communication facility provided by the kernel of the Gutenberg experimental operating system is presented. In Gutenberg all interprocess communication is via channels (ports) that are typed by the service which can be requested on them. Ports are created by reference to their service without using the identifier of the process providing the service, a technique the authors refer to as functional addressing. By using functional addressing, interprocess transfer of port use privileges and a new concept of cooperation class, arbitrary process interconnection topologies can be achieved without any explicit use of process identifiers by processes. Examples of object sharing with abstract data type managers and data-driven protocols of database query execution are presented to illustrate the methods of constructing systems of cooperation processes using the Gutenberg system.

No abstract available.

A database system, comprising a schema, integrity constraints, transactions, and queries, constitutes a single abstract data type. This type, which we call an abstract database type, has as its object the database itself. Thus, the value set of such a type is the set of all legal database states, legal in the sense of obeying all the structural specifications of the schema and the semantic prescriptions of the integrity constraints. The database transactions are the operations of the abstract database type and must be functions on the value set of the type. A transaction specification is safe if it defines a function which is closed on the database state set, i. e., any execution of the transaction on a legal database yields a legal database.We propose an approach to the definition of abstract database types which is both usable by typical database designers and which facilitates the mechanical verification of transaction safety. The Boyer and Moore theorem proving technique is used to prove transaction safety theorems using abstract data type axioms and recursive functions generated from the database schema and transaction programs.

Two experiments testing the ability of subjects to write queries in two different query languages were run. The two languages, SQL and TABLET, differ primarily in their procedurality; both languages use the relational data model, and their Halstead levels are similar. Constructs in the languages which do not affect their procedurality are identical. The two languages were learned by the experimental subjects almost exclusively from manuals presenting the same examples and problems ordered identically for both languages. The results of the experiments show that subjects using the more procedural language wrote difficult queries better than subjects using the less procedural language. The results of the experiments are also used to compare corresponding constructs in the two languages and to recommend improvements for these constructs.

A facility is described for the implementation of database management systems having high degrees of horizontal data independence, i.e. independence from chosen logical properties of a database as opposed to vertical independence from storage structures. The facility consists of a high level language for the specification of virtual database managers, a compiler from this language to a pseudomachine language, and an interpreter for the pseudomachine language. It is shown how this facility can be used to produce efficient database management systems with any degree of both horizontal and vertical data independence. Two key features of this tool are the compilation of tailored database managers from individual schemas and multiple levels of optional binding.

This paper presents a facility for the implementation of data base management systems having high degrees of horizontal data independence, i.e. independence from chosen logical properties of a data base as opposed to vertical independence from storage structures. The facility consists of a high level language for the specification of virtual data base managers, a compiler from this language to a pseudo-machine language, and an interpreter for the pseudo-machine language.