A sequence of interleaved user transactions in a database system may not be 8zis, i.e., equivalent to some sequential execution of the individual transactions. Using a simle transaction model we show that recognizing the transaction histories which are serializable is an NP- complete problem. We therefore introduce several efficiently recognizable j9gsses of the class of serializable histories most of thee S.b- classes correspond to serializability principles existing in the literature and used in practice. We also propose two new principles which subsume all previously known ones. We give necessary and sufficient conditions for a class of histories to be the output of an efficient history scheduler these conditions imply that there can be no efficient scheduler that outputs all of serializable histories,.and also that all subclasses of serializable histories studied above have an efficient scheduler. Finally, we show how our results can be extended to far more general transaction models,'to transactions with partly interpreted functions, and to distributed database syst%.

A lambda-calculus schema is an expression of the lambda calculus augmented by uninterpreted constant and operator symbols. It is an abstraction of programming languages such as LISP which permit functions to be passed to and returned from other functions. When given an interpretation for its constant and operator symbols, certain schemata, called lambda abstractions, naturally define partial functions over the domain of interpretation. Two implementation strategies are considered: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbage-collected store) and the deletion strategy, modeled after the usual stack implementation of ALGOL 60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Not all lambda abstractions evaluate correctly under the deletion strategy. Nevertheless, both strategies are equally powerful in the sense that any lambda abstraction can be mechanically translated into another that evaluates correctly under the deletion strategy and defines the same partial function over the domain of interpretation as the original. Proof is by translation into continuation-passing style.

A method schema is a simple programming formalism for object-oriented databases with features such as classes, methods, inheritance, name overloading, and late binding. An important problem is to check whether a given method schema can lead to an inconsistency in some interpretation. This consistency question is shown to be undecidable in general. Decidability is obtained for monadic and/or recursion-free method schemas. In particular, consistency of monadic method schemas is shown to be decidable in O(nc 3 ) time, where n is the size of the method definitions and c is the size of the class hierarchy; also, it is logspace-complete in PTIME, even for monadic, recursion-free schemas. Method signature covariance is shown to simplify the computational complexity of key decidable cases. For example: one coded method in the context of base methods with covariant signatures can be tested for consistency in O(n+c) time for the monadic case (without covariance this problem is in O(nc 2 ) t...

This paper traces the important steps in the history --up to around 1990-- of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satisfies its specification (or that two programs were equivalent). Over time it became clear that post facto verification is only practical for small programs and attention turned to verification methods which support the development of programs; for larger programs it is necessary to exploit a notation of compositionality. Coping with concurrent algorithms is much more challenging -- this and other extensions are considered briefly. The main thesis of this paper is that the idea of reasoning about programs has been around since they were first written; the search has been to find tractable methods.

This paper traces the important steps in the history --up to around 1990-- of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satifies its specification (or that two programs were equivalent). Over time it has become clear that post facto verification is only practical for small programs and attention turned to verification methods which support the development of programs; for larger programs it is necesary to exploit a notion of composability.

Two well-studied functional formalisms in the theory of programming languages are (1) applicative program schemas and (2) typed lambda calculi. We relate these programming formalisms to object-oriented databases (OODBs) and in particular to the description of methods. The language of method schemas (MS) is a programming formalism based on applicative program schemas with additional key object-oriented features such as classes, methods, inheritance, name overloading, and late binding. From [4], we present its syntax and semantics and survey the state-of-the-art of consistency checking or signature inference for this language, a problem which can be used in studying database schema evolution. We then relate MS with more conventional database query languages by showing that its expressive power over finite ordered databases is PTIME. Despite its simplicity and applicability, MS does not directly model the tuple, set, and list complex structures that are quite common in databases. Also, it does not treat functions as objects, i.e., methods are different from objects. It is possible to achieve these two capabilities using the typed lambda calculus with equality (TLC=) as a database query language, even without any objectoriented features. From [25], we illustrate how this pure functional language subsumes most conventional database query languages including the relational calculus/algebra, Datalog (with or without negation), and the complex object calculus/algebra (with or without powerset). In conclusion, we argue that the appropriate programming formalism for OODBs must be a functional language that combines the object-oriented MS with the expressive TLC= and facilitates operations on sets of objects.

Several approaches to reverse and re-engineering are based upon program slicing. Unfortunately, for large systems, such as those which typically form the subject of reverse engineering activities, the space and time requirements of slicing can be a barrier to successful application. Faced with this problem, several authors have found it helpful to merge Control Flow Graph (CFG) nodes, thereby improving the space and time requirements of standard slicing algorithms. The node-merging process essentially creates a `coarser' version of the original CFG. This paper introduces a theory for defining Control Flow Graph node coarsening calculi. The theory formalizes properties of interest, when coarsening is used as a precursor to program slicing. The theory is illustrated with a case study of a coarsening calculus, which is proved to have the desired properties of sharpness and consistency. 1

A program schema de nes a class of programs, all of which have identical statement structures, but whose expressions may dier. We prove that given any two structured schemas which are conservative, linear and free, it is decidable whether they are equivalent.

Abstract. Artifact-centric services are stateful service descriptions centered around “business artifacts”, which contain both a data schema holding all the data of interest for the service, and a lifecycle schema, which specifies the process that the service enacts. In this paper, the data schemas are full-fledged relational databases, and the lifecycle schemas are specified as sets of conditionaction rules, where conditions are evaluated against the current snapshot of the artifact, and where actions are suitable updates to database. The main characteristic of this work is that conditions and actions are based on conjunctive queries. In particular, we exploit recent results in data exchange to specify through tuplegenerating-dependencies (tgds) the effects of actions. Using such basis we develop sound and complete verification procedures, which, in spite of the fact that the number of states of an artifact-centric service can be infinite, reduce to the finite case through a suitable use of homomorphism induced by the conjunctive queries. 1

this paper various devices operating directly on structures, without encoding. The motivation and benefits for doing this are manyfold. On a fundamental level, encodings of structures seem to be a technical device rather than an intrinsic feature. This point has already been made by several mathematicians such as Tarski [Tar86], and Harvey Friedman [Fri71] (see Section 5). It has come up more recently in the context of databases, where devices computing on structures model more acurately database computation carried out against an abstract interface hiding the internal representation of data. Thus, the primary benefit of studying devices and languages computing on structures is that they clarify issues which are obscured in classical devices such as Turing machines. For example, they yield new notions of complexity, quite different from classical computational complexity. They reflect more acurately the actual complexity of computation, which, like database computation, cannot take advantage of encodings of structures. An example is provided by the query even on a set