Greg Lavender

Intel's premier annual developer conference

Model driven development (MDD) of software product lines (SPLs) merges two increasing important paradigms that synthesize programs by transformation. MDD creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational model of a product line of scalar vector graphics and JavaScript applications. We explain how we simplified our implementation by lifting selected… Show more

Model driven development (MDD) of software product lines (SPLs) merges two increasing important paradigms that synthesize programs by transformation. MDD creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational model of a product line of scalar vector graphics and JavaScript applications. We explain how we simplified our implementation by lifting selected features and their compositions from our original product line (whose implementations were complex) to features and their compositions of another product line (whose specifications were simple). We used operators to map higher-level features and their compositions to their lower-level counterparts. Doing so exposed commuting relationships among
feature compositions in Show less

In this paper we describe the design of Lagniappe, a programming environment that simplifies the design of portable, high throughput applications on multi-* architectures.

Information, e.g., password or other access credential information is synchronized, amongst directory spaces or repositories, that employ dissimilar protective transformations, e.g., hashes, encryption, etc. In some embodiments, directory spaces are embodied as directory servers, services or similar components of computer operating systems. The mechanism includes detecting changes to information encoded in a first information store and invalidating a corresponding entry of a second information… Show more

Information, e.g., password or other access credential information is synchronized, amongst directory spaces or repositories, that employ dissimilar protective transformations, e.g., hashes, encryption, etc. In some embodiments, directory spaces are embodied as directory servers, services or similar components of computer operating systems. The mechanism includes detecting changes to information encoded in a first information store and invalidating a corresponding entry of a second information store. The invalidating triggers information synchronization upon a subsequent attempt to authenticate against this entry in the second store. The detection may be administered without reversing a protective transform of the entries. Show less

Information, e.g., password or other access credential information, may be synchronized amongst replicated directory spaces or repositories. In some embodiments, directory spaces are embodied as directory servers, services or similar components of computer operating systems, including LDAP, UDDI, Active Directory or other standardized or proprietary directory environments. In one embodiment in accordance with the present invention, a method includes invalidating an entry of at least one replica… Show more

Information, e.g., password or other access credential information, may be synchronized amongst replicated directory spaces or repositories. In some embodiments, directory spaces are embodied as directory servers, services or similar components of computer operating systems, including LDAP, UDDI, Active Directory or other standardized or proprietary directory environments. In one embodiment in accordance with the present invention, a method includes invalidating an entry of at least one replica store. The invalidation of the entry of the replica store triggers information synchronization of a corresponding invalidated entry of a master store to a corresponding entry of an authoritative store on a next attempt to authenticate against the invalidated entry of the replica store.; The method may include propagating information of the synchronized master store entry to at least one other replica store. Show less

The paper surveys the history, development and usage of directory services based on the Lightweight Directory Access Protocol (LDAP). We present a summary of the naming model, the schema model, the principal service models, and the main protocol interactions in terms of a C language application programming
interface.

The Adaptive Configuration pattern described in this paper decouples the compositional structure of modules, which perform transformations on a data stream, from the algorithms used to implement these modules. Both may be changed dynamically and independently, to allow an implementation to adapt its functionality and resource requirements to the run-time environment. This pattern distinguishes itself from purely configurable pipeline patterns by addressing the tension
between modularity and… Show more

The Adaptive Configuration pattern described in this paper decouples the compositional structure of modules, which perform transformations on a data stream, from the algorithms used to implement these modules. Both may be changed dynamically and independently, to allow an implementation to adapt its functionality and resource requirements to the run-time environment. This pattern distinguishes itself from purely configurable pipeline patterns by addressing the tension
between modularity and performance. Show less

Recent improvements in microprocessor performance have made possible the migration of continuous media processing from specialized hardware, such as decompression and digital signal processing boards, to software. The extensibility and configurability of software libraries allows multimedia applications to access a wider range of multimedia objects, stored in a variety of compressed formats, and to employ an extensible set of tools for processing these objects. Furthermore,
configurable… Show more

Recent improvements in microprocessor performance have made possible the migration of continuous media processing from specialized hardware, such as decompression and digital signal processing boards, to software. The extensibility and configurability of software libraries allows multimedia applications to access a wider range of multimedia objects, stored in a variety of compressed formats, and to employ an extensible set of tools for processing these objects. Furthermore,
configurable software libraries enable applications to take advantage of new audio and video compression standards as they emerge, rather than becoming obsolete. Show less

This paper describes the design of and implementation of Presentation Processing Engines (PPEs) that provide flexible control over QoS to manage heterogeneity in networks, end-systems and compression formats. Development of PPEs is facilitated by a framework that provides the modular architecture, data types, and transformations common to most codecs, filters, transcoders etc. to facilitate the implementation of emerging compression standards and their integration into media processing… Show more

This paper describes the design of and implementation of Presentation Processing Engines (PPEs) that provide flexible control over QoS to manage heterogeneity in networks, end-systems and compression formats. Development of PPEs is facilitated by a framework that provides the modular architecture, data types, and transformations common to most codecs, filters, transcoders etc. to facilitate the implementation of emerging compression standards and their integration into media processing applications. By allowing fine-grained composition of compression and image processing modules, the framework facilitates the development of extensible presentation processing engines that can be dynamically configured to adapt to changes in resource availability and user preferences. Show less

This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to a shared resource by methods invoked in different threads of control. This pattern is commonly used in distributed systems requiring multi-threaded servers.

A set of object-oriented abstractions is described that permits direct programming with ASN.1 specified types. The design and implementation also supports the flexible use of different encoding rules. The implementation is in C++ and makes use of class templates for representing polymorphic types, class inheritance for type specialization, and typedefs for de?ning ASN.1 types as instances of class templates. Encoding/decoding performance data is provided as evidence that this work is suitable… Show more

A set of object-oriented abstractions is described that permits direct programming with ASN.1 specified types. The design and implementation also supports the flexible use of different encoding rules. The implementation is in C++ and makes use of class templates for representing polymorphic types, class inheritance for type specialization, and typedefs for de?ning ASN.1 types as instances of class templates. Encoding/decoding performance data is provided as evidence that this work is suitable for serious application development. Show less

A new approach to structuring layered protocols using polymorphic service access points and type inheritance between protocol machines is presented. Polymorphic service access points facilitate the flexible instantiation of protocol machines containing the minimal functionality required by an application. The type inheritance structure is induced by a vertical partitioning of the upper layers of the ISO Reference Model resulting in a non-monolithic protocol stack that supports concurrent… Show more

A new approach to structuring layered protocols using polymorphic service access points and type inheritance between protocol machines is presented. Polymorphic service access points facilitate the flexible instantiation of protocol machines containing the minimal functionality required by an application. The type inheritance structure is induced by a vertical partitioning of the upper layers of the ISO Reference Model resulting in a non-monolithic protocol stack that supports concurrent object-oriented applications such as Actor systems. The results presented represent a modest contribution to the research and practice of advanced protocol development. The type structures in?troduced demonstrate to software engineers, particularly those developing layered systems software, that object-oriented programming techniques facilitate and enhance the implementation of layered
architectures. In addition, the results presented provide justification for object-oriented language designers that polymorphic and extensible type structures are useful for efficiently implementing layered communication protocol architectures. Show less

ACT++ 2.0 is the most recent version of a class library for concurrent programming in C++. The underlying model of concurrent computation is the Actor model. Programs in ACT++ consist of a collection of active objects called actors. Actors execute concurrently and cooperate by sending request and reply messages. An agent, termed the behavior of an actor, is responsible for processing a single request message and for specifying a replacement behavior which processes the next
available request… Show more

ACT++ 2.0 is the most recent version of a class library for concurrent programming in C++. The underlying model of concurrent computation is the Actor model. Programs in ACT++ consist of a collection of active objects called actors. Actors execute concurrently and cooperate by sending request and reply messages. An agent, termed the behavior of an actor, is responsible for processing a single request message and for specifying a replacement behavior which processes the next
available request message. One of the salient features of ACT++ is its ability to handle the Inheritance Anomaly - the interference between the inheritance mechanism of object-oriented
languages and the specification of synchronization constraints in the methods of a class - using the notion of behavior sets. Another feature of ACT++ is its realization of I/O as an actor operation. A special type of actor, called an interface actor, provides a high level interface for a file. Interface actors are sent request messages whenever I/O is necessary and can also transparently perform asynchronous I/O. ACT++ has been implemented on the Sequent Symmetry multiprocessor using the
PRESTO threads package. Show less

A survey of concurrent object-oriented languages is presented. The survey is organized around three models: the Animation Model that describes a variety of relationships between threads and objects, an Interaction Model that classi#es the possible semantics of invocations and returns between a client object and a server object, and a Synchronization Model that shows di#erentways in which concurrentinvocations can be managed bya server.Anumber of representative languages are brie#y presented… Show more

A survey of concurrent object-oriented languages is presented. The survey is organized around three models: the Animation Model that describes a variety of relationships between threads and objects, an Interaction Model that classi#es the possible semantics of invocations and returns between a client object and a server object, and a Synchronization Model that shows di#erentways in which concurrentinvocations can be managed bya server.Anumber of representative languages are brie#y presented. The problem of synchronization in concurrent object-oriented languages is considered in detail including a discussion of the inheritance anomaly. A synchronization mechanism, called a behavior set , is shown to avoid this anomaly in certain cases. The implementation of behavior sets in ACT++, an actor-based concurrent programming framework implemented in C++, is described. Show less

Appropriate use of object-oriented programming mechanisms in the implementation of communication architectures results in a type structure that reflects the architectural model and increases the run-time performance of the protocol machines at each layer. This result is important since it contradicts the assertion by some that layered protocol architectures, such as the ISO Reference Model, necessarily suffer in performance because of layering, thus forcing implementors to violate the layering… Show more

Appropriate use of object-oriented programming mechanisms in the implementation of communication architectures results in a type structure that reflects the architectural model and increases the run-time performance of the protocol machines at each layer. This result is important since it contradicts the assertion by some that layered protocol architectures, such as the ISO Reference Model, necessarily suffer in performance because of layering, thus forcing implementors to violate the layering principle in search of efficiency. The result substantiates the experience of others, notably Clark, that sound network programming methodology leads to efficient implementations that are also understandable. In this paper, elements of an object-oriented implementation of the upper layer OSI protocols are presented. The purpose of the paper is two-fold: first, to communicate to software engineers, particularly those developing systems software, that object-oriented programing techniques facilitate and enhance the implementation of layered architectures; second, to convey to language designers that object-oriented language features are useful in building communication protocols. The focus is on the requirements for the upper layer OSI protocols and how inheritance, subtyping, and polymorphic functions effect their implementation. Show less

Polymorphic type abstractions are proposed for constructing concurrent objects and layered peer-to-peer communication protocols, both of which exhibit inherently asynchronous behavior. The type abstractions are shown to be both expressive and efficient in the context of a statically typed object-oriented
language. Where appropriate, the utility of the type abstractions is illustrated by demonstrating their usefulness in concurrent programming using the Actor model. The results of this work… Show more

Polymorphic type abstractions are proposed for constructing concurrent objects and layered peer-to-peer communication protocols, both of which exhibit inherently asynchronous behavior. The type abstractions are shown to be both expressive and efficient in the context of a statically typed object-oriented
language. Where appropriate, the utility of the type abstractions is illustrated by demonstrating their usefulness in concurrent programming using the Actor model. The results of this work have direct applicability to problems in concurrent programming, distributed systems, and communication
protocol architectures.
Show less

A "future" is a typed synchronization mechanism used to represent a value that will come into existence at some point in time after the creation of the future. In this paper, a polymorphic future type is introduced that di?ffers from previous mechanisms in that it provides a ?first-class, extensible facility for expressing synchronized access to the typed result value of a concurrent computation. The proposed mechanism requires write-once/read-many synchronization, which is implemented in terms… Show more

A "future" is a typed synchronization mechanism used to represent a value that will come into existence at some point in time after the creation of the future. In this paper, a polymorphic future type is introduced that di?ffers from previous mechanisms in that it provides a ?first-class, extensible facility for expressing synchronized access to the typed result value of a concurrent computation. The proposed mechanism requires write-once/read-many synchronization, which is implemented in terms of common thread synchronization primitives, thereby ensuring a high-degree of e?fficiency. The type definition and type specialization features of C++ are used to illustrate how one would implement a polymorphic future type in a strongly typed object-oriented language supporting polymorphic type de?nitions. Show less

The Carnot project for developing a flexible framework for integrating heterogeneous information resources and applications, both within and among organizations, is reviewed. The effective use of such systems requires a way to flexibly and efficiently orchestrate related tasks on far-flung computing systems. A central component of the Carnot project, the extensible services switch (ESS), which provides interpretive access to applications and to communications and information resources at… Show more

The Carnot project for developing a flexible framework for integrating heterogeneous information resources and applications, both within and among organizations, is reviewed. The effective use of such systems requires a way to flexibly and efficiently orchestrate related tasks on far-flung computing systems. A central component of the Carnot project, the extensible services switch (ESS), which provides interpretive access to applications and to communications and information resources at distributed sites, is discussed. The ESS is described as essentially a programmable glue that enhances interoperability by binding software components to one another. Show less

Using CCS behavior equations to specify and reason about the observable behavior of concurrent objects, the nature of the conflict in inheriting synchronization constraints is explicated. Using behavior equations as a formal representation of concurrent object behavior results in the definition of behavior sets and a behavior function. A behavior set represents a subset of the methods defined as part of an object’s interface. The behavior function is a mapping from the domain of object states… Show more

Using CCS behavior equations to specify and reason about the observable behavior of concurrent objects, the nature of the conflict in inheriting synchronization constraints is explicated. Using behavior equations as a formal representation of concurrent object behavior results in the definition of behavior sets and a behavior function. A behavior set represents a subset of the methods defined as part of an object’s interface. The behavior function is a mapping from the domain of object states to the domain of behavior sets. A behavior set is used to represent the synchronization constraints of actor-like concurrent objects and may be extended via inheritance. By expressing relevant object states, behavior sets, and the behavior function as first-class, inheritable,and mutable entities in a concurrent object-oriented language, the conditions are defined that must be met in order to inherit synchronization constraints free of known anomalies. Show less