| |
Formal Syntax and Semantics of Java (1999), pp. 543-543.
Abstract
This chapter presents an attribute grammar for the Java programming language (v. 1.1). This grammar is derived from the LALR grammar presented in the Java Language Specification (JLS) [1]. The purpose of this grammar is to formally specify not only the syntactic structure of Java programs, but also their static semantics. Specifically, in this chapter we try to formally capture all aspects of the language that would result in compile-time errors. These errors include, but are not limited to: – -Type ...
|
| |
SIGACT News, Vol. 32, No. 1. (2001), pp. 60-65.
|
| |
LISP and Symbolic Computation, Vol. 4, No. 3. (1 July 1991), pp. 187-205.
Abstract
SELF is an object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because SELF does not distinguish state from behavior, it narrows the gaps between ordinary ...
|
| |
In LFP '84: Proceedings of the 1984 ACM Symposium on LISP and functional programming (1984), pp. 293-298.
Abstract
The power of first class continuations is demonstrated by implementing a variety of coroutine mechanisms using only continuations and functional abstraction. The importance of general abstraction mechanisms such as continuations is discussed. ...
|
| |
Commun. ACM, Vol. 6, No. 7. (1963), pp. 396-408.
Abstract
Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references. ...
|
| |
SIGPLAN Not., Vol. 39, No. 10. (October 2004), pp. 50-68.
Abstract
Tracing and reference counting are uniformly viewed as being fundamentally different approaches to garbage collection that possess very distinct performance properties. We have implemented high-performance collectors of both types, and in the process observed that the more we optimized them, the more similarly they behaved - that they seem to share some deep structure. ...
|
| |
Memory Management (1992), pp. 1-42.
Abstract
We survey basic garbage collection algorithms, and variations such as incremental and generational collection. The basic algorithms include reference counting, mark-sweep, mark-compact, copying, and treadmill collection. Incremental techniques can keep garbage collection pause times short, by interleaving small amounts of collection work with program execution. Generational schemes improve efficiency and locality by garbage collecting a smaller area more often, while exploiting typical lifetime characteristics to avoid undue overhead from long-lived objects. ...
|
| |
ACM Comput. Surv., Vol. 21, No. 3. (September 1989), pp. 359-411.
Abstract
The foundations of functional programming languages are examined from both historical and technical perspectives. Their evolution is traced through several critical periods: early work on lambda calculus and combinatory calculus, Lisp, Iswim, FP, ML, and modern functional languages such as Miranda 1 and Haskell. The fundamental premises on which the functional programming methodology stands are critically analyzed with respect to philosophical, theoretical, and pragmatic concerns. Particular attention is paid to the main features that characterize modern functional languages: higher-order functions, ...
|
| |
ACM Trans. Program. Lang. Syst., Vol. 24, No. 2. (2002), pp. 153-191.
Abstract
Reclassification changes the class membership of an object at run-time while retaining its identity. We suggest language features for object reclassification, which extend an imperative, typed, class-based, object-oriented language.We present our proposal through the language Fickle ⋄⋄ . The imperative features, combined with the requirement for a static and safe type system, provided the main challenges. We develop a type and effect system for Fickle ⋄⋄ and prove its soundness with respect to the operational semantics. In ...
|
| |
ECOOP’ 93 — Object-Oriented Programming (1993), pp. 268-296.
Abstract
Predicate classes are a new linguistic construct designed to complement normal classes in object-oriented languages. Like a normal class, a predicate class has a set of superclasses, methods, and instance variables. However, unlike a normal class, an object is automatically an instance of a predicate class whenever it satisfies a predicate expression associated with the predicate class. The predicate expression can test the value or state of the object, thus supporting a form of implicit property-based classification that augments the explicit ...
|
| |
Component Deployment (2002), pp. 391-411.
Abstract
Gilgul is an extension of the Java programming language that allows for dynamic object replacement without consistency problems. This is possible in a semantically clean way because its model strictly separates the notions of reference and comparison that are usually subsumed in the concept of object identity. This paper sketches problems that occur in attempts at replacements of active objects and presents some solutions, including both variants that preserve consistency and those that trade consistency for timeliness. The latter are enabled ...
|
| |
Computer Languages, Systems & Structures, Vol. 31, No. 3-4. (October 2005), pp. 107-126.
|
| |
In OOPSLA '05: Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (2005), pp. 177-189.
Abstract
Unanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance relationships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be implemented, and thus reducing the need for convoluted design anomalies. In this paper we demonstrate ...
|
| |
|
| |
In GPCE '07: Proceedings of the 6th international conference on Generative programming and component engineering (2007), pp. 123-134.
Abstract
Multiple dispatch - the selection of a function to be invoked based on the dynamic type of two or more arguments - is a solution to several classical problems in object-oriented programming. Open multi-methods generalize multiple dispatch towards open-class extensions, which improve separation of concerns and provisions for retroactive design. We present the rationale, design, implementation, and performance of a language feature, called open multi-methods, for C++. Our open multi-methods support both repeated and virtual inheritance. Our call resolution rules generalize ...
|
| |
(1999)
Abstract
Multiple Inheritance is the ability of a class to have more than one base class (super class). In a language where multiple inheritance is supported a program can be structured as a set of inheritance lattices instead of (just) as a set of inheritance trees. This is widely believed to be an important structuring tool. It is also widely believed that multiple inheritance complicates a programming language significantly, is hard to implement, and is expensive to ...
|
| |
ACM Trans. Program. Lang. Syst., Vol. 28, No. 2. (March 2006), pp. 331-388.
Abstract
Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance, multiple inheritance, or mixins, all pose numerous problems for reuse. To overcome these problems we propose traits , pure units of reuse consisting only of methods. We develop a formal model of traits that establishes how ...
|
| |
SIGPLAN Not., Vol. 22, No. 2. (1987), pp. 85-94.
Abstract
Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references. ...
|
| |
(2002)
Abstract
Inheritance is the fundamental reuse mechanism in object-oriented programming languages; its most prominent variants are single inheritance, multiple inheritance, and mixin inheritance. In the first part of this paper, we identify and illustrate the conceptual and practical reusability problems that arise with these forms of inheritance. We then present a simple compositional model for structuring object-oriented programs, which we call traits. Traits are essentially groups of methods that serve as building blocks for classes and are primitive units of code reuse. ...
|
| |
In OOPSLA '87: Addendum to the proceedings on Object-oriented programming systems, languages and applications (Addendum) (1987), pp. 17-34.
Abstract
Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references. ...
|
| |
Engineering of Computer-Based Systems, 2004. Proceedings. 11th IEEE International Conference and Workshop on the In Engineering of Computer-Based Systems, 2004. Proceedings. 11th IEEE International Conference and Workshop on the (2004), pp. 329-336.
Abstract
Metadata management is one of the key concepts of distributed interoperable systems. This paper compares two approaches to building a metadata repository for component-based distributed environment. We compare a hand-written repository and MOF-based one with respect to easiness of building and accessing them. The results are based on implementations of the both repositories for a real component model. ...
|
| |
ACM Comput. Surv., Vol. 28, No. 3. (September 1996), pp. 438-479.
Abstract
One of the most intriguing—and at the same time most problematic—notions in object-oriented programing is inheritance . Inheritance is commonly regarded as the feature that distinguishes object-oriented programming from other modern programming paradigms, but researchers rarely agree on its meaning and usage. Yet inheritance of often hailed as a solution to many problems hampering software development, and many of the alleged benefits of object-oriented programming, such as improved conceptual modeling and reusability, are largely credited to it. This article ...
|
| |
Computer In Computer, Vol. 14, No. 11. (1981), pp. 76-93.
Abstract
Progress in this realm of performance measurement has lagged behind advances in the general field of programming languages: careful study of its capabilities and limitations is long overdue. ...
|
| |
In In FTfJP, Vol. 5 (2005), pp. 5-29.
Abstract
In this paper, I examine some of reasons that “readonly ” style qualifiers have been proposed for Java, and also the principles behind the rules for these new qualifiers. I find that there is a mismatch between some of the motivating problems and the proposed solutions. Thus I urge Java designers to proceed with caution when adopting a solution to these sets of problems. 1 Proposals for “readonly ” in Java The purpose in having qualifiers such as “readonly ” on ...
|
Search
Search
