Browsing by Author "Lavender, R. Gregory"

Now showing 1 - 8 of 8
  • Thumbnail Image
    ACT++ 2.0: A Class Library for Concurrent Programming in C++ Using Actors
    Kafura, Dennis G.; Mukherji, Manibrata; Lavender, R. Gregory (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    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. ACT++ has been implemented on the Sequent Symmetry multiprocessor using the PRESTO threads package.
  • Thumbnail Image
    The Application of Concurrent Object-Oriented Techniques to Reactive Systems
    Kafura, Dennis G.; Lavender, R. Gregory (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    A language and system model combining concurrency, abstract communication and an object orientation offers several advantages in the design and implementation of large-scale reactive systems. An object-orientation captures the abstraction and variety of entities inhabiting the environment while the autonomy of actual entities is clearly reflected by expressions of concurrency in the program of the reactive system. Abstract communication is necessary to achieve data sharing among heterogeneous systems. However, attempts to design and implement a paradigm unifying these three features have encountered unexpected difficulties. These difficulties include the interference between concurrency control (synchronization) and inheritance, inadequate application-oriented communication abstractions, the absence of a useful model of exception handling for concurrent object-oriented applications, and the lack of a powerful and useful theory of computation based on asynchrony.
  • Thumbnail Image
    The explication of process-product relationships in DoD-STD-2167 and DoD-STD-2168 via an Augmented Data Flow Diagram model
    Lavender, R. Gregory (Virginia Tech, 1988-03-05)
    The research reported in this thesis is an extension and application of the results first introduced by the Procedural Approach to the Evaluation of Software Development Methodologies. The evaluation procedure offers a unique perspective based on the philosophy that a software development methodology should espouse a set of objectives that are achieved by employing certain U principles throughout the software development process, such that the products generated possess certain attributes deemed desirable. Further, definite linkages exist between objectives and principles, and principles and attributes. The work described herein adopts the perspective offered by the evaluation procedure and applies a critical analysis to the process-product relationships in DoD-STD-2l67 and DoD-STD-2l68. In support of the analysis, Augmented Data Flow Diagrams are introduced as an effective tool for concisely capturing the information in both standards. The results of the analysis offer a deeper insight into the requirements for defense system software development, such that one is able to better understand the development process, and more intelligently assess the quality of the software and documentation produced.
  • Thumbnail Image
    Implementing Communication Protocols Using Object-Oriented Techniques
    Lavender, R. Gregory; Kafura, Dennis G.; Tomlinson, Chris J. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1992)
    In this paper, elements of an object-oriented implementation of the upper layer OSI protocols are presented. Our goal in the paper is two-fold. First, to communicate to software engineers, particularly those developing systems software, that object-oriented programming techniques facilitate and enhance the implementation of layered architectures. Second, to convey to language designers our experience using object-oriented language features in building communications protocols. We focus on the requirements for the upper layer OSI protocols and illustrate how inheritance, subtyping, and polymorphic function effect their implementation.
  • Thumbnail Image
    Issues Related to the Explication of Process-Product Relationships in DoD-Std-21677 and DoD-Std-2168
    Lavender, R. Gregory (Department of Computer Science, Virginia Polytechnic Institute & State University, 1988)
    This paper is a discussion of issues related to the thesis entitled, "The Explication of Process-Product Relationships in DoD-STD-2167 and DoD-STD-2168 via an Augmented Data Flow Diagram Model." In particular, the major results of the above thesis are viewed in light of the draft standards DoD-STD-2167 and DoD-STD-2168 (both dated 1 April 1987), and the issue of development objectives is explored. The ideas presented in this paper represent the author's opinion and are speculative in nature due to the fact that, at present, the revised DoD standards are in draft form, and the issue of development objectives has not yet been thoroughly investigated.
  • Thumbnail Image
    Polymorphic types for constructing concurrent objects and layered communication protocols
    Lavender, R. Gregory (Virginia Tech, 1993-05-05)
    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. An extensible, polymorphic type abstraction for structuring concurrent method execution in a strongly typed object-oriented language is introduced. The type abstraction is called a polymorphic lambda type. A lambda type is an abstraction for a procedure that is based in part on λ-abstraction in the λ-calculus. The lambda type is a key component of a concurrent object model that allows methods defined in a class to be instantiated as lambda objects. Lambda objects are used to represent some aspect of behavior and they represent a first-class execution environment. The first-class nature of lambda objects facilitates the construction of more powerful computational abstractions, primarily those requiring 'asynchronous interaction and concurrent execution. Through a series of refinements, lambda objects are shown to be as expressive as traditional procedures with little extra cost for call setup and invocation. Concurrent objects require synchronization control. A type abstraction called a behavior set is introduced for specifying synchronization constraints in a strongly typed concurrent object-oriented language with Actor-style concurrency semantics. The behavior set abstraction offers a solution to structuring synchronization control that coexists with an inheritance mechanism, thereby avoiding the inheritance anomaly.
  • Thumbnail Image
    Specifying and Inheriting Concurrent Behavior in an Actor-BasedObject-Oriented Language
    Lavender, R. Gregory; Kafura, Dennis G. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1990)
    Using CCS behavior equations to specify and reason about the observable behavior of concurrent objects, we demonstrate that a language mechanism called a behavior set can be used to capture the behavior of actor-like objects. Using behavior equations as a formal representation of concurrent object behavior results in the explication of a mapping from the domain of objects to a domain of behavior sets. We call this mapping the behavior function. By expressing relevant object states, behavior sets and the behavior function as first-class, inheritable, and mutable entities in a concurrent object-oriented language, we have defined the conditions which must be met in order to inherit concurrent behavior free of known anomalies.
  • Thumbnail Image
    The Synergy Between Object-Oriented Programming and Open System Interconnection
    Lavender, R. Gregory; Kafura, Dennis G. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1991)
    The software engineering practice of building distributed object-oriented applications can be improved dramatically by exploiting the powerful synergism between object-oriented programming (OOP) and Open System Interconnection (OSI). The synergy arises because there are corresponding and complementary elements in both OOP and OSI; these elements are detailed and the synergism resulting from their integration is explained. The architecture of a prototype implementation, the goal of Project Synergy, is described. The environment created by Project Synergy supports application development using classes which are defined in an implementation-independent manner, implemented in possibly different programming languages, and executed in a distributed system on possibly heterogeneous processor architectures.