1. Java Layers Language Support for Stepwise Refinement Rich Cardone, IBM Research & UT at Austin Calvin Lin, University of Texas at Austin

2. 12/7/00Java Layers/RC,CL2 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

3. 12/7/00Java Layers/RC,CL3 Reuse is Key Separation of concerns One application feature per component Flexible composition

4. 12/7/00Java Layers/RC,CL4 Presentation Overview Part I – Motivation Mixins Stepwise Refinement Drawbacks of Mixins Part II – Java Layers Java Layers Overview Two Language Features

5. 12/7/00Java Layers/RC,CL5 An OO Problem CarBoxHouse Problem: Lockable code replicated 3 times Lockable Car Lockable Box Lockable House lock(), unlock()

6. 12/7/00Java Layers/RC,CL6 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 Class class Lockable extends T { lock(){…} unlock(){…} } [Bracha90]

7. 12/7/00Java Layers/RC,CL7 Mixed-In Classes CarBoxHouse Lockable Lockable code reused 3 times Lockable

8. 12/7/00Java Layers/RC,CL8 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

9. 12/7/00Java Layers/RC,CL9 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

10. 12/7/00Java Layers/RC,CL10 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 …

11. 12/7/00Java Layers/RC,CL11 Music Application Instances Base GetSong PutSong Simple Base GetSong PutSong NoBritney HideBritney Base EraseCopyright GetSong Thief ThreadSpawn GetSong leaf-types …

12. 12/7/00Java Layers/RC,CL12 Application Assembly is Easy class Simple extends PutSong > {…} class NoBritney extends HideBritney >> {…} class Thief extends ThreadSpawn >> {…}

13. 12/7/00Java Layers/RC,CL13 Base Class class Base { } static public class Server { void dispatchLoop(){for(;;) dispatch(readRequest());} void dispatch(Req req){errorUnknownReq(req);} … } static public class Client {…}

14. 12/7/00Java Layers/RC,CL14 GetSong Mixin class GetSong 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); } … } constraintnested mixins

15. 12/7/00Java Layers/RC,CL15 Other Mixins class EraseCopyright extends T { static public class Client extends T.Client { void eraseCopyright(…){…} } … } class ThreadSpawn extends T { static public class Server extends T.Server { void dispatchLoop(){…} } … }

16. 12/7/00Java Layers/RC,CL16 Stepwise Program Refinement ClientServer Base EraseCopyright GetSong class Thief extends ThreadSpawn >> {…} ThreadSpawn Layers [Batory92]

17. 12/7/00Java Layers/RC,CL17 Drawbacks of Mixins Superclass initialization Runtime efficiency Leaf-type references Composition validation Semantic validity Syntactic correctness

18. 12/7/00Java Layers/RC,CL18 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

19. 12/7/00Java Layers/RC,CL19 Part II – Java Layers Java Layers Overview Two JL Language Features Status Conclusion

20. 12/7/00Java Layers/RC,CL20 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

21. 12/7/00Java Layers/RC,CL21 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

22. 12/7/00Java Layers/RC,CL22 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

23. 12/7/00Java Layers/RC,CL23 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

24. 12/7/00Java Layers/RC,CL24 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

25. 12/7/00Java Layers/RC,CL25 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

26. 12/7/00Java Layers/RC,CL26 Deep Conformance Example class HideBritney 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

27. 12/7/00Java Layers/RC,CL27 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

28. 12/7/00Java Layers/RC,CL28 A Use of Virtual Types class Node {Node next;} class DoubleNode extends Node {DoubleNode prev;} class Node {virtual Node; Node next;} class DoubleNodeextends 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

29. 12/7/00Java Layers/RC,CL29 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)

30. 12/7/00Java Layers/RC,CL30 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.

31. 12/7/00Java Layers/RC,CL31 This Example Base GetSong Client- Factory PutSong class ClientFactory extends T deeply { static public class Client extends T.Client { static Client clientFactory() {return new Client();} } … } class ClientFactory extends T deeply { static public class Client extends T.Client { static This clientFactory() {return new This();} } … } leaf-type

32. 12/7/00Java Layers/RC,CL32 Work Completed Implemented JL prototype Compared JL to OO Frameworks Reengineered Schmidt’s ACE ICSE 2001 paper

33. 12/7/00Java Layers/RC,CL33 Future Work Develop new JL compiler Implement language described here Build a family of related applications Compare JL and OO approaches

34. 12/7/00Java Layers/RC,CL34 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

35. 12/7/00Java Layers/RC,CL35 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?

36. 12/7/00Java Layers/RC,CL36 THE END Think Layers