Abstract not found

In this paper we overview the design and implementation of a language extension to C++ for abstracting types and for decoupling subtyping and inheritance. This extension gives the user more of the flexibility of dynamic typing while retaining the efficiency and security of static typing. We discuss the syntax and semantics of this language extension, show examples of its use, and present and analyze the cost of three different implementation techniques: a preprocessor to a C++ compiler, an implementation in the front end of a C++ compiler, and a low-level back-end based implementation.

In Java, an interface specifies public abstract methods and associated public constants. Conformance of a class to an interface is by name. We propose to allow structural conformance to interfaces: Any class or interface that declares or implements each method in a target interface conforms structurally to the interface, and any expression of the source class or interface type can be used where a value of the target interface type is expected. We argue that structural conformance results in a major gain in flexibility in situations that require retroactive abstraction over types.

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.

Object-oriented techniques increase program modularity, decrease coupling, and improve data abstraction by supporting encapsulation through narrow, rigidly defined and strongly enforced interfaces to objects. Applying object-oriented techniques to address problems of building scalable and maintainable distributed systems seems an obvious approach since reducing coupling and increasing modularity are of obvious benefit. Unfortunately, object-oriented interfaces and mechanisms are usually only accessible and enforced through programming language mechanisms and support. This severely limits the degree to which disjoint, unrelated components can interact in a multilingual, loosely coupled distributed system. An accepted solution to the language dependence problem is the use of high-level interface description languages (IDLs) to provide a description mechanism for an object's interface that is independent of any programming language. Implementations of these interfaces can be provided by a...

Object-oriented techniques stress modularity through narrow and rigidly defined interfaces as a way of achieving low coupling between individual software components and high cohesion in the implementation of each component. Unfortunately, in a distributed environment object-oriented interfaces are usually only enforced and usable through language mechanisms or rigid programming conventions. Both of these limitations make it difficult for components in a large-scale distributed environment to interact. This paper discusses a technique that overcomes these limitations and allows for strong interface descriptions that are available at runtime with very small overheads. Our system allows for the dynamic querying of objects for their conformance to a client's requirements specified as an interface description. We also support the automatic generation of local proxy objects to access remote objects once their conformance is confirmed. The conformance rules we have chosen are more flexible th...

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . viii 1. INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 2. BACKGROUND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.1 Object Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.1.1 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.1.2 Subtype Polymorphism . . . . . . . . . . . . . . . . . . . . . . 6 2.2 Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.2.1 Influence of Languages on Patterns . . . . . . . . . . . . . . . 8 2.2.2 Influence of Patterns on Languages . . . . . . . . . . . . . . . 9 2.3 Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3. PATTERNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.1 Explicit Interface Descriptions . . . . . . . . . . . . . . . . . . . . . . 13 3.1.1 Examples . . . . . . . . . . . . . . . . . . ....