The programming language jigsaw: mixins, modularity and multiple inheritance
The programming language jigsaw: mixins, modularity and multiple inheritance
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Units: cool modules for HOT languages
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Making the future safe for the past: adding genericity to the Java programming language
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Compatible genericity with run-time types for the Java programming language
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Proceedings of the ACM SIGPLAN 1999 conference on Programming language design and implementation
Featherweight Java: a minimal core calculus for Java and GJ
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Parametric polymorphism in Java: an approach to translation based on reflective features
OOPSLA '00 Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Parametric polymorphism in Java: an efficient implementation for parametric methods
Proceedings of the 2001 ACM symposium on Applied computing
Jiazzi: new-age components for old-fasioned Java
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Recursive structures for standard ML
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
The Definition of Standard ML
Import is Not Inheritance - Why We Need Both: Modules and Classes
ECOOP '92 Proceedings of the European Conference on Object-Oriented Programming
True Modules for Java-like Languages
ECOOP '01 Proceedings of the 15th European Conference on Object-Oriented Programming
Efficient Implementation of Run-time Generic Types for Java
Proceedings of the IFIP TC2/WG2.1 Working Conference on Generic Programming
A first-class approach to genericity
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
Safe instantiation in generic Java
Proceedings of the 3rd international symposium on Principles and practice of programming in Java
Understanding and evolving the ml module system
Understanding and evolving the ml module system
Scalable component abstractions
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Efficient first-class generics on stock Java virtual machines
Proceedings of the 2006 ACM symposium on Applied computing
From structures and functors to modules and units
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Deriving components from genericity
Proceedings of the 2007 ACM symposium on Applied computing
JavaGI: The Interaction of Type Classes with Interfaces and Inheritance
ACM Transactions on Programming Languages and Systems (TOPLAS)
| Hi-index | 0.00 |
Developing a general component system for a statically typed, object-oriented language is a challenging design problem for two reasons. First, mutually recursive references across components are common in object-oriented programs-an issue that has proven troublesome in the context of component systems for functional and procedural languages. Second, inheritance across component boundaries can cause accidental method overrides. Our recent research shows that a component framework can be constructed for a nominally typed object-oriented language supporting first-class generic types simply by adding appropriate annotations, syntactic sugar, and component-level type-checking. The fundamental semantic building blocks for constructing, type-checking and manipulating components are provided by the underlying first-class generic type system. To demonstrate the simplicity and utility of this approach we have designed and implemented an extension of Java called Component NEXTGEN (CGEN). CGEN, which is based on the Sun Java 5.0 javac compiler, is backwards compatible with existing Java binary code and runs on current Java Virtual Machines. The primary contribution of this paper is a technical analysis of the subtle design issues involved in building a component framework for a nominally typed object-oriented language supporting first-class generics. In contrast to component systems for structurally typed languages, mutual recursion among components is accommodated in the type system and semantics without incorporating any special machinery. Our analysis includes a presentation of Core CGEN (CCG), a small, core language modeling the CGEN framework. It is based on Featherweight GJ and incorporates some ideas from MIXGEN. CCG adds the essential features to support components, but nothing more. Our discussion includes the type rules and semantics for CCG, as well as a proof of type safety.