Browsing by Author "Lee, Keung Hae"
Now showing 1 - 5 of 5
Results Per Page
Sort Options
- ACT++: Building a Concurrent C++ with ActorsKafura, Dennis G.; Lee, Keung Hae (Department of Computer Science, Virginia Polytechnic Institute & State University, 1989)ACT++ (Actors in C++) is a concurrent object-oriented language being designed for distributed real-time applications. The language is a hybrid of the actor kernel language and the object-oriented language C++. The concurrency abstraction of ACT++ is derived from the actor model as defined by Agha. This paper discusses our experience in building a concurrent extension of C++ with the concurrency abstraction of the actor model. The current design of ACT++ and its implementation are described. Some problems found in the Agha's actor model are discussed in the context of distributed real-time applications. The use of ACT++ disclosed the difficulty of combining the actor model of concurrency with class inheritance in an object-oriented language.
- Designing a statically typed actor-based concurrent object-oriented programming languageLee, Keung Hae (Virginia Tech, 1990)The research reported in this dissertation investigates extending the power and flexibility of an object-oriented language with inheritance, Static typing, and concurrency. A language supporting inheritance, static typing, and concurrency offers a significant leverage in software development. However, when these features are provided together, the benefits of the features are significantly reduced due to the interaction among them. The challenge for the designer of an object-oriented language lies in the difficulty of reconciling the conflicts among these features. This thesis discusses two issues: combining static typing with inheritance and combining concurrency with inheritance. A new model of type and inheritance, called HANA, is presented. The HANA model integrates multiple inheritance, multiple representation, method exclusion, and method name overloading with static typing. The contribution of HANA is that it extends other existing models of type and inheritance with enhanced expressive power, increased reusability, and improved program efficiency. Combining concurrency with inheritance is investigated in the framework of the actor computation model. A language design based on the actor model of concurrent computation faces a serious problem arising from the interference between concurrency and inheritance. A similar problem also occurs in other concurrent object-oriented languages. The problem of concurrency-inheritance conflict is described and a solution based on a concept called behavior abstraction is presented.
- A Fast and Efficient Method Dispatching Statically Typed MultipleInheritance Object-Oriented LanguagesLee, Keung Hae; Kafura, Dennis G. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1989)Inheritance is an invaluable mechanism for object-oriented programming. The benefits of inheritance have been well recognized over the last few years. However, these benefits typically come at the expense of run time overhead in time and space. While an efficient late binding mechanism based on indexing has been popularly used in supporting single inheritance, a mechanism for multiple inheritance which can provide a comparable efficiency has been sought. In this paper, we describe a late binding mechanism for statically typed object-oriented programming with multiple inheritance. Our technique, based on the partitioning of a multiple inheritance hierarchy, is a significant improvement in both space and time over existing techniques. The fast and efficient late binding mechanism called hierarchy partitioning is presented. An analysis of the predicted performance of the technique and a detailed comparison with other related work are also provided.
- HANA: A Model of Type and Inheritance for Object-Oriented Programming LanguagesLee, Keung Hae; Kafura, Dennis G. (Department of Computer Science, Virginia Polytechnic Institute & State University, 1990)Most current object-oriented languages consider inheritance as subtyping. However, a type system which views inheritance as subtyping allows neither multiple representations of a type nor method exclusion without violating typing constraints. These problems and the difference between inheritance and subtyping have been well recognized recently. Another approach to subtyping found in the literature is to separate inheritance from subtyping. In this approach, subtyping is solely determined by inheritance conformance. While subtyping based on interface conformance can support multiple representations, it cannot distinguish intended conformance from accidental conformance. This paper describes a new model of type and inheritance, called HANA, in which subtyping and inheritance are not separated, although differentiated. The notion of subtyping in HANA is based on both inheritance and interface conformance. HANA integrates multiple inheritance multiple representations, method exclusion, and method name overloading with static typing. HANA extends other existing methods of inheritance and subtyping with enhanced expressive power, increased reusability, and program efficiency. We show that the differentiation made by HANA between inheritance and subtyping allows name collision to be resolved without compromising the integrity of the type system. The capability of excluding an inherited method without violating static typing offers a sound solution for resolving name collision in multiple inheritance when used together with other mechanisms. We show that the mechanisms of method exclusion, addition, and renaming are othogonal with respect to the power of resolving name collision in multiple inheritance.
- Inheritance in Actor Based Concurrent Object-Oriented LanguagesKafura, Dennis G.; Lee, Keung Hae (Department of Computer Science, Virginia Polytechnic Institute & State University, 1988)Inheritance is a valuable mechanism which enhances reusability and maintainability of software. A language design based on the actor model of concurrent computation faces a serious problem arising from the interference between concurrency and inheritance. A similar problem also occurs in other concurrent object-oriented languages. In this paper, we describe problems found in existing concurrent object-oriented languages. We present a solution which is based on a concept called behavior abstraction.