1 / 36

Java Layers

Java Layers. Language Support for Stepwise Refinement. Rich Cardone, IBM Research & UT at Austin Calvin Lin, University of Texas at Austin. Problem. Software development and maintenance is expensive Difficult Takes a long time. Assemble applications from off-the-shelf components

kimama
Download Presentation

Java Layers

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  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 Java Layers/RC,CL

  3. Reuse is Key • Separation of concerns • One application feature per component • Flexible composition Java Layers/RC,CL

  4. Presentation Overview • Part I – Motivation • Mixins • Stepwise Refinement • Drawbacks of Mixins • Part II – Java Layers • Java Layers Overview • Two Language Features Java Layers/RC,CL

  5. Car Box House LockableCar LockableBox LockableHouse lock(), unlock() An OO Problem Problem: Lockable code replicated 3 times Java Layers/RC,CL

  6. Mixin Class class Lockable<T> extends T { lock(){…} unlock(){…} } [Bracha90] An OO Solution • Use same lockable code for all 3 classes • Encapsulate lockable code in a class • Subtype Car, Box, House with new class Java Layers/RC,CL

  7. <T> Car Box House Lockable<T> Lockable<Car> Lockable<Box> Lockable<House> Mixed-In Classes Lockable code reused 3 times Java Layers/RC,CL

  8. 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 Java Layers/RC,CL

  9. 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 Java Layers/RC,CL

  10. 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 • … Java Layers/RC,CL

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

  12. Application Assembly is Easy class Simple extends PutSong<GetSong<Base>> {…} class NoBritney extends HideBritney<PutSong<GetSong<Base>>> {…} class Thief extends ThreadSpawn<GetSong<EraseCopyright< Base>>> {…} Java Layers/RC,CL

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

  14. constraint nested mixins 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); } … } } Java Layers/RC,CL

  15. Other Mixins class 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(){…} }… } Java Layers/RC,CL

  16. EraseCopyright GetSong ThreadSpawn Stepwise Program Refinement class Thief extends ThreadSpawn<GetSong<EraseCopyright<Base>>> {…} Client Server Base Layers [Batory92] Java Layers/RC,CL

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

  18. 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 Java Layers/RC,CL

  19. Part II – Java Layers • Java Layers Overview • Two JL Language Features • Status • Conclusion Java Layers/RC,CL

  20. 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 Java Layers/RC,CL

  21. 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 Java Layers/RC,CL

  22. 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 Java Layers/RC,CL

  23. 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 Java Layers/RC,CL

  24. Java supports shallow type checking • Interfaces and classes The Need for Deep Conformance • JL adds support for deep type checking • Supertypes are checked for required nested types Question: Does Child contain a nested class named Inner? class Parent { class Inner {…} } class Child extends Parent {…} Answer: Maybe Java Layers/RC,CL

  25. 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 Java Layers/RC,CL

  26. 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 {…} } • 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 • HideBritney contains all the public nested types of T • Compiler generates missing nested types if necessary Java Layers/RC,CL

  27. 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 Java Layers/RC,CL

  28. class Node {virtual Node; Node next;} class DoubleNode extends Node {typedef Node as DoubleNode; DoubleNode prev;} [Thorup97] A Use of Virtual Types class Node {Node next;} class DoubleNode extends Node {DoubleNode prev;} • In DoubleNode: • next is type Node • prev is type DoubleNode • In DoubleNode: • next is type DoubleNode • prev is type DoubleNode Java Layers/RC,CL

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

  30. 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. Java Layers/RC,CL

  31. Base GetSong Client-Factory PutSong leaf-type This Example 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();} } … } Java Layers/RC,CL

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

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

  34. 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 Java Layers/RC,CL

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

  36. THE END Think Layers Java Layers/RC,CL

More Related