java layers language support for stepwise refinement rich cardone, ibm research & ut at austin...

Java Layers

Language Support for Stepwise Refinement

Rich Cardone, IBM Research & UT at Austin

Calvin Lin, University of Texas at Austin

12/7/00 Java Layers/RC,CL 2

Problem

Software development and maintenance is expensive

Difficult

Takes a long time

Assemble applications from off-the-shelf components

Mix and match features to create applications

Plug and unplug components to change applications


Reuse is Key

Separation of concerns

One application feature per component

Flexible composition

4Java Layers/RC,CL12/7/00

Presentation Overview

Part I – Motivation Mixins Stepwise Refinement Drawbacks of Mixins

Part II – Java Layers Java Layers Overview Two Language Features


An OO Problem

Car Box House

Problem: Lockable code replicated 3 times

LockableCar

LockableBox

LockableHouse

lock(), unlock()


An OO Solution Use same lockable code for all 3 classes

Encapsulate lockable code in a class Subtype Car, Box, House with new class

Mixin Classclass Lockable<T> extends T {

lock(){…}

unlock(){…}

}[Bracha90]


Mixed-In Classes

Car Box House

Lockable<Car> Lockable<Box> Lockable<House>

Lockable code reused 3 times

<T>

Lockable<T>


Mixins

Types with parameterized supertypes

Depend on type parameters More precisely: Parametric Polymorphism

An OO mechanism for code reuse

Apply same code to unrelated classes

Work with single inheritance


Mixins & Software Components Question

Can we use mixins to build applications out of reusable components?

If so, then mixins must support: Separation of concerns Flexible composition

Let’s look at an example application


Example: Music Server Variation can occur on many axes:

Client interface{getSong, putSong, eraseCopyright, hideBritney, …}

Server execution strategy{single threaded, thread-spawning, thread pool, …}

Transport type Fault tolerance Server discovery …


Music Application Instances

Base

GetSong

PutSong

Simple

Base

GetSong

PutSong

NoBritney

HideBritney

Base

EraseCopyright

GetSong

Thief

ThreadSpawn

GetSong GetSong

GetSong

leaf-types

…


Application Assembly is Easy

class Simple extends PutSong<GetSong<Base>> {…}

class NoBritney extends HideBritney<PutSong<GetSong<Base>>> {…}

class Thief extends ThreadSpawn<GetSong<EraseCopyright<

Base>>> {…}


Base Class class Base {

}

static public class Server {

void dispatchLoop(){for(;;) dispatch(readRequest());}

void dispatch(Req req){errorUnknownReq(req);}

…

}

static public class Client {…}


GetSong Mixin

class GetSong<T extends Base> extends T {

static public class Client extends T.Client {

void getSong(…){…} }

static public class Server extends T.Server {

void dispatch(Req req){

if (req.name.equals(“getSong”)) processGetSong(req);

else super.dispatch(req);

}

…

}

}

constraint

nested mixins


Other Mixinsclass EraseCopyright<T extends Base> extends T {

static public class Client extends T.Client {

void eraseCopyright(…){…}

} …

}

class ThreadSpawn<T extends Base> extends T {

static public class Server extends T.Server {

void dispatchLoop(){…}

} …

}


Stepwise Program Refinement

Client Server

Base

EraseCopyright

GetSong

class Thief extends ThreadSpawn<GetSong<EraseCopyright<Base>>> {…}

ThreadSpawn

Layer

s

[Batory92]


Drawbacks of Mixins

Superclass initialization Runtime efficiency Leaf-type references Composition validation

Semantic validity Syntactic correctness


Recap Software components imply reuse Mixins reuse OO code Mixins build applications incrementally

Stepwise program refinement Nested types encapsulate features Feature mixing and matching

Mixins have usability & efficiency drawbacks


Part II – Java Layers

Java Layers Overview

Two JL Language Features

Status

Conclusion


Goal of Java Layers

Increase software reuse to reduce

development and maintenance costs

Use layered, stepwise program refinement

Encapsulate features in mixins classes

Compose features through type instantiation


JL’s Foundation

Java + Constrained Parametric Polymorphism

(CPP) There are several proposals for adding CPP to Java

[Agesen97, Bokowski98, Bracha98, Cartwright98, Myers97, Solorzano98]

JL is a heterogeneous implementation of CPP Conventional syntax and semantics

Parametric classes and interfaces

Mixins


The JL Language

JL is a parametric Java plus 4 features: Deep conformance Static virtual typing Semantic checking Constructor propagation

All language extensions are designed to support stepwise refinement


JL Compiler Support

Class hierarchy optimization

Remove design-time layering from runtime code

Inline calls to superclass methods w/same

signature

Collapse class hierarchy into a single class


The Need for Deep Conformance

JL adds support for deep type checking Supertypes are checked for required nested types

class Parent { class Inner {…} }

class Child extends Parent {…}

Question:

Does Child contain a nested class named Inner?

Answer: Maybe

Java supports shallow type checking

Interfaces and classes


Deep Conformance

Deep Conformance supports stepwise refinement

Enforces structural conformance at all nesting depths

Subtypes can safely refer to nested types in their supertypes

Feature composition is enhanced by added type precision


Deep Conformance Example

class HideBritney<T extends Base deeply> extends deeply T {

static public class Client extends T.Client {…}

static public class Server extends T.Server {…} }

HideBritney contains all the public nested types of T

Compiler generates missing nested types if necessary

Type parameter T binds to classes that: Extend Base Contain a nested Client class that extends Base.Client Contain a nested Server class that extends Base.Server


Deep Conformance Syntax

Deeply modifier for implements and extends

clauses

Different meaning in constraint and inheritance

clauses

Operates on public nested types by default

Propagate modifier for non-public nested

types

Enables selective deep type checking

Use in parameterized and non-parameterized

types


A Use of Virtual Types

class Node {Node next;}

class DoubleNode extends Node {DoubleNode prev;}

class Node {virtual Node; Node next;}

class DoubleNode extends Node {typedef Node as DoubleNode;

DoubleNode prev;}

[Thorup97]

In DoubleNode:

next is type Node

prev is type

DoubleNode

In DoubleNode:

next is type

DoubleNode

prev is type

DoubleNode


Virtual Types The automatic adaptation of types through

inheritance. Virtual types change through subtyping

A child class can change the type of its parent

Benefits of Virtual Typing Greater type precision

Better type checking

Less manual typecasting

Genericity (Beta)


JL’s This Virtual Type This pseudo-type is like the “type of this.” Static binding

Used in parametric types only Bound at instantiation time

Enhances JL’s expressiveness Allows the instantiated leaf-type to be

expressed within the mixins being composed to define that leaf-type.


This Example

Base

GetSong

Client-Factory

PutSong

class ClientFactory<T extends Base deeply> extends T deeply {

static public class Client extends T.Client

{ static Client clientFactory() {return new Client();} } … }

class ClientFactory<T extends Base deeply> extends T deeply {

static public class Client extends T.Client

{ static This clientFactory() {return new This();} } … }

leaf-type


Work Completed

Implemented JL prototype

Compared JL to OO

Frameworks

Reengineered Schmidt’s ACE

ICSE 2001 paper


Future Work

Develop new JL compiler

Implement language described here

Build a family of related applications

Compare JL and OO approaches


Related Work GenVoca – Batory92-00, Smaragdakis98-99

Parametric Polymorphism – Agesen97,

Bokowski98, Bracha90, Bracha98, Cartwright98, Myers97, Solorzano98

Virtual Types – Bruce97-98, Madsen89, Thorup97,

Thorup99, Torgerson98 Semantic Checking – Batory95, Perry89-93

Programming Paradigms – Danforth98, Gamma94,

Harrison93, Johnson91, Kiczales97, Schmidt98, Tarr99


Conclusion

JL extends Java to improve reusability

Promotes stepwise program refinement

Assembles applications from reusable parts

Builds on parametric polymorphism

Adds a small number of language features

Is this approach practical for application

programming?


THE END

Think Layers

java layers language support for stepwise refinement rich cardone, ibm research & ut at austin...

Documents

java layersrc

class threadspawn

mixins class erasecopyright

class nobritney

class thief

cl13 base class class

static public class

times lockable slide