Type-Safe Prototype-Based Component Evolution

  title={Type-Safe Prototype-Based Component Evolution},
  author={Matthias Zenger},
Component-based programming is currently carried out using mainstream object-oriented languages. These languages have to be used in a highly disciplined way to guarantee flexible component composition and extensibility. This paper investigates abstractions for component-oriented programming on the programming language level. We propose a simple prototype-based model for first-class components on top of a class-based object-oriented language. The model is formalized as an extension of… 
A Form-based Metamodel for Software Composition
This article presents a generic meta-level framework for modeling both objectand component-oriented programming abstractions, and defines a compositional model that provides the means both to bridge between different object models and to incorporate existing software artifacts into a unified composition system.
Object reuse and behavior adaptation in Java-like languages
This work proposes new linguistic constructs for composing objects in a Java-like language that supports flexible object reuse and adaptation of the object behavior at run time and guarantees that method calls on well-typed object compositions are safe.
Flexible Type-Safe Linking of Components for Java-Like Languages
A framework of components based on Java-like languages, where components are binary mixin modules, which achieves great flexibility in reusing components for two reasons: (1) type constraints generated for a single component exactly capture all possible contexts where it can be safely used; and (2) composition of components is not limited to conventional linking, but is achieved by means of a set of powerful operators typical ofMixin modules.
Scl: A Simple, Uniform and Operational Language for Component-Oriented Programming in Smalltalk
SCL is presented, a simple language dedicated to component-oriented programming that provides new features such as a uniform component composition model based on connectors that represent interactions between independently developed components.
Guaranteeing Resource Bounds for Component Software
This work extends the previous one to include a parallel composition and improves on the operational semantics by using a small-step reduction relation, and can prove the soundness property of the static type system using the technique of Wright and Felleisen.
Bichon: A New Component-Oriented Programming Language
  • Liping Xu, Yufei Ren
  • Computer Science
    2010 Second World Congress on Software Engineering
  • 2010
The core syntax and type definition of Bichon calculus is presented, which shows separation of static and dynamic behaviors of components, better component definition and composition are achieved.
A programming language for software components
This dissertation presents a programming language called Mentok that provides two novel programming language features enabling improved specification of stateful component roles and type layers that allow specification of abstract control flow constraints through the interfaces of a component-based application.
Poplar: Extending the Java Programming Language for Evolvable Component Integration
A Java extension is proposed, Poplar, which enriches interfaces with a semantic label system, which describes functional properties of variables, as well as an effect system, and a formal specification of Poplar is provided, which is based on Middleweight Java (MJ).
Foundations of a simple and unified component-oriented language


A Basic Model of Typed Components
A simple model which captures some basic ingredients of black-box object-oriented component programming styles is proposed, expressed by a core imperative typed calculus, and whose basic constructs enable the composition, scripting, instantiation and definition of atomic components.
Compound types for Java
To investigate the integrability into a strongly typed language, this work adds compound types to Java and reports on a mechanical soundness proof of the resulting type system.
Integrating Independently-Developed Components in Object-Oriented Languages
This work discusses several reuse mechanisms that can adapt a component in place without requiring access to the component's source code and without needing to re-typecheck it.
Type-Safe Delegation for Run-Time Component Adaptation
This paper presents a type-safe integration of delegation into a class-based object model and shows how it overcomes the problems faced by forwarding-based component interaction, how it supports independent extensibility of components and unanticipated, dynamic component adaptation.
Mixing COP and OOP
We describe and justify thirteen technical properties that a component system must possess to work with object-oriented programming languages (such as Java, C++, or C#). Our components are designed
Classes and mixins
A model of class-to-class functions that refers to as mixins is developed, which is an intuitive model of an essential Java subset; an extension that explains and models mixins; and type soundness theorems for these languages.
Type-safe linking and modular assembly language
This work presents a formal model of typed object files and a set of inference rules that are sufficient to guarantee that type safety is preserved by the linking process.
A Primitive Calculus for Module Systems
A simple and powerful calculus of modules supporting mutual recursion and higher order features, and an untyped version of the calculus and a type system which is proved sound w.r.t. the reduction semantics are presented.
True Modules for Java-like Languages
JAVAMOD is a module language which is extremely flexible and allows to express, for instance, generic types as in Pizza and GJ, mixin classes (that is, subclasses parametric in the direct superclass) and mutually recursive class definitions split in independent modules.
A Core Calculus of Classes and Mixins
An imperative calculus that provides a formal model for both single and mixin inheritance, and introduces classes and mixins as the basic object-oriented constructs in a λ-calculus with records and references, with an intuitive operational semantics.