E is an extension of C++ designed for writing software systems to support persistent applications. Originally designed as a language for implementing database systems, E has evolved into a general persistent programming language E was the first C++ extension to support transparent persistence, the first C++ implementation to support generic classes, and remains the only C++ extension to provide general-purpose lterators, In addition to its contributions to the C + + programming domain, work on E has made several contributions to the field of persmtent languages in general, including several distinct implementations of persistence. Thm paper describes the main features of E and shows through examples how E addresses many of the problems that arise in building persistent systems.

Automatic storage management, or garbage collection, is a feature usually associated with languages oriented toward ‘‘symbolic processing,’’ such as Lisp or Prolog; it is seldom associated with ‘‘systems’’ languages, such as C and C++. This report surveys techniques for performing garbage collection for languages such as C and C++, and presents an implementation of a concurrent copying collector for C++. The report includes performance measurements on both a uniprocessor and a multiprocessor.

We describe the support to object management of the distributed object-oriented operating system SOS. We discuss the integration of object migration and storage into C++ programs, a language not designed for that purpose. The necessary support is split between the compiler and a run-time object management system. Migration and storage preserve the type and structure of the objects, which may be user-defined and arbitrarily complex. Our mechanisms are simple, generic, and require little programmer intervention. The key elements are dynamic classes, a generalized pointer type which allows to efficiently refer to an object, pre-requisite objects, and a mechanism for object re-initialization. Keywords: persistence, migration, dynamic linking, dynamic type-checking, C++, object-oriented operating system, SOS 1 INTRODUCTION We present some aspects of the object management support in the SOS operating system [Sha86a]. SOS is a research program to build a distributed operating system, where ...

In this dissertation, we show how a relatively simple and extremely fast interprocedural optimization algorithm can be used to optimize many of the expensive features of statically typed, object-oriented languages --- in particular, C++ and Java. We present a new program analysis algorithm, Rapid Type Analysis, and show that it is fast both in theory and in practice, and significantly out-performs other "fast" algorithms for virtual function call resolution. We present optimization algorithms for the resolution of virtual function calls, conversion of virtual inheritance to direct inheritance, elimination of dynamic casts and dynamic type checks, and removal of object synchronization. These algorithms are all presented within a common framework that allows them to be driven by the information collected by Rapid Type Analysis, or by some other type analysis algorithm. Collectively, the optimizations in this dissertation free the programmer from having to sacrifice modularity and extensibility for performance. Instead, the programmer can freely make use of the most powerful features of object-oriented programming, since the optimizer will remove unnecessary extensibility from the program.

Extensions to C ++ are proposed that would enable the directed synthesis of code as an alternative to dispatch-based code generation. The strategies are similar to those used in the SELF compiler, which uses customization techniques to impressive effect. The language extensions required to support customization also enhance support for other uses of inheritance in C++ , and are useful in conjunction with proposed additions of parametric types. 1 Introduction One of the smallest, but most important features introduced in C++ 2.0 is improved support for abstract base classes (ABCs) via the use of "pure virtual" member functions. For example, 1 class Matrix -- public: virtual ~Matrix() -- virtual int rows() const = 0; virtual int cols() const = 0; virtual float elem(int i, int j) const = 0; int size() -- return rows() * cols(); ; This declares a Matrix class in terms of its protocol or interface (i.e., the signatures of member functions), but not in terms of member function implement...

Abstract not found

“Concepts ” are an essential language feature needed to support generic programming in the large. Concepts allow for succinct expression of bounds on type parameters of generic algorithms, enable systematic organization of problem domain abstractions, and make generic algorithms easier to use. In this paper we formalize the design of a type system and semantics for concepts that is suitable for non-type-inferencing languages. Our design shares much in common with the type classes of Haskell, though our primary influence is from best practices in the C ++ community, where concepts are used to document type requirements for templates in generic libraries. The technical development in this paper defines an extension to System F and a type-directed translation from the extension back to System F. The translation is proved sound; the proof is written in the human readable but machine checkable Isar language and has been automatically verified by the Isabelle proof assistant. This document was generated directly from the Isar theory files using Isabelle’s support for literate proofs.

Abstract 1 Introduct ion In object-oriented database systems, it is assumed silently that fundamental object types and inter-object relationships can be classified statically, prescribing basic structural and behavioral properties for all the objects in the database. Such a classification-based ap-proach falls short of supporting those data-intensive applications requiring more advanced dynamic func-tions. A particular kind of such advanced functions is “dynamic clustering ”- the ability to group/cluster existing objects to form typeless, ad-hoc collections (called “clusters”) which are directly denotable and employable. Such clusters can be formed by taking copies or by including the Oids of the input objects, and can be explicitly defined or indefinitely defined, exhibiting thus different impacts and characteristics, ranging from loosely-coupled to tightly-coupled ones. In this paper we describe an on-going project of de-vising a conceptual clustering model. A real life DB application is used as a basis for testing and evaluating the model. An implementation prototype has been im-plemented, based on a comprehensive object database programming system.

First and foremost I thank my parents for all their love and for teaching me to enjoy learning. I especially thank my wife Katie for her support and understanding through this long and sometimes stressful process. I also thank Katie for insisting on good error messages for G! My advisor, Andrew Lumsdaine, deserves many thanks for his support and guidance and for keeping the faith as I undertook this long journey away from scientific computing and into the field of programming languages. I thank my thesis committee: R. Kent Dybvig, Daniel P. Friedman, Steven D. Johnson, and Amr Sabry for their advice and encouragement. A special thanks goes to Ronald Garcia, Christopher Mueller, and Douglas Gregor for carefully editing and catching the many many times when I accidentally skipped over the important stuff. Thanks to Jaakko and Jeremiah for hours of stimulating discussions and arguments concerning separate compilation and concept-based overloading. Thanks to David Abrahams for countless hours spent debating the merits of one design over another while jogging through the hinterlands of Norway. Thanks to Alexander Stepanov and David Musser for getting all this started, and thank you for the encouragement over the years. Thanks to Matthew Austern, his book Generic Programming in the STL was both an inspiration

C++ uses inheritance as a substitute for subtype polymorphism. We give examples where this makes the type system too inflexible. We then describe a conservative language extension that allows us to define an abstract type hierarchy independent of any implementation hierarchies, to retroactively abstract over an implementation, and to decouple subtyping from inheritance. This extension gives the user more of the flexibility of dynamic typing while retaining the efficiency and security of static typing. With default implementations and views we provide flexible mechanisms for implementing an abstract type by different concrete class types. We first show how our language extension can be implemented in a preprocessor to a C++ compiler, and then detail and analyze the efficiency of an implementation we directly incorporated in the GNU C++ compiler.