1 / 50

Enhancing Extensibility in OOP and Functional Programming through Modular Design

This presentation explores the integration of modular design principles within both object-oriented programming (OOP) and functional programming paradigms, focusing on the use of units and mixins. It discusses the challenges of extensibility, emphasizing how new operations can be added without modifying existing clients. By examining the definition of shapes and displaying them, the presentation illustrates how programming with an abstract factory can facilitate the addition of new datatypes and operations dynamically, addressing the core problems in software design and enhancing code reuse.

salim
Télécharger la présentation

Enhancing Extensibility in OOP and Functional Programming through Modular Design

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. Modular OOP with Units and Mixins Paper by Finder/Flatt Presentation by Dan Licata

  2. Scheme in Fixnum Minutes > 4 4 >(define x 4) > x 4

  3. Scheme in Fixnum Minutes >(+ 4 4) 8 > (+ (+ 4 (+ 4 4)) (+ 4 4)) 20

  4. Scheme in Fixnum Minutes > 5 5

  5. Scheme in Fixnum Minutes > (define add2 (lambda (x y) (+ x y))) > (add2 4 5) 9 > add2 <#procedure...>

  6. Scheme in Fixnum Minutes (define add2(lambda (x y) (+ x y)) > (add2 4 5) 9 (define mk-add(lambda (x) (lambda(y) (+ x y))))

  7. Scheme in Fixnum Minutes > (mk-add 4) #<procedure> > (define add4 (mk-add 4)) > (add4 5) 1 (define mk-add(lambda (x) (lambda(y) (+ x y))))

  8. Reading a Paper • What problem are they solving? • How do they solve it? • Why should I care?

  9. Reading a Paper • What problem are they solving? • How do they solve it? • Why should I care?

  10. Extensibility! Same story as last time: • Functional programming => easy to add a new operation • OOP => easy to add a new datatype variant What would the ideal be?

  11. Extensibility Shape Clients

  12. Add a New Variant Shape Existing clients should not need to be modified! Clients

  13. Add a New Variant Shape Clients New Clients

  14. Add a New Operation Shape Clients New Clients

  15. Presumptions in the Picture • Add a new operation by subclassing • If the change gets used behind the original interface, unmodified clients should see it In traditional OOP, do they?

  16. Define Original Datatype (define Shape (interface () draw) (define Rectangle (class* null (Shape) (width height) (public [draw (lambda (window x y) …))]))

  17. Define Original Datatype (define Circle (class* null (Shape) (radius) (public [draw (lambda (window x y) ...))]))

  18. Define Original Datatype (define display-shape (lambda (shape) (let ([window ...]) (send shape draw window 0 0))))

  19. Create A Client (display-shape (make-object Rectangle 50 100))

  20. Add a New Variant (define Union (class* null (Shape) (left right) (public [draw (lambda (window x y) ...))]))

  21. Add a Client that Uses It (display-shape (make-object Union (make-object Rectangle 10 30) (make-object Circle 20)))

  22. Add a New Operation (define BB-Shape (interface (shape) bounding-box) (define BB-Rectangle (class* Rectangle (BB-Shape) (w h) (public [bounding-box (lambda () (make-object BB 0 0 w h))]) ...))

  23. Add a New Operation (define display-shape (lambda (shape) (let ([bb (send shape bounding-box)] (let ([window ...] [x ...] [y ...]) (send shape draw window x y)))))

  24. Do the Old Clients Use It? (display-shape (make-object Rectangle 50 100)) (display-shape (make-object Union (make-object Rectangle 10 30) (make-object Circle 20)))

  25. Do the Old Clients Use It? (display-shape (make-object Rectangle 50 100)) (display-shape (make-object Union (make-object Rectangle 10 30) (make-object Circle 20)))

  26. Potential Solution • Always program using Abstract Factory • Downsides: • Requires forethought • Contorts the code How can we add language support?

  27. Reading a Paper • What problem are they solving? • How do they solve it? • Why should I care?

  28. Fortune-Cookie Wisdom Every problem in CS can be solved by adding a layer of indirection. • Layers: • Mixins • Units

  29. Mixin Class that is parameterized by its superclass (define BB-Rect (class* Rectangle ...)) (define BB-Rect (lambda (Rect) (class* Rect ...)))

  30. Unit Module that is • Separately compilable • Black-box reusable (has an interface) • Multiply instantiable • Dynamically linkable

  31. Define Original Datatype (define Basic-Shapes (unit (import) (export Shape Rectangle Circle) (define Shape (interface ...)) (define Rectangle (class* ...)) (define Circle (class* ...))))

  32. Define Original Datatype (define GUI (unit (import Shape) (export display-shape) (define display-shape ...)))

  33. Create a Client (define Picture (unit (import Shape Rectangle Circle display-shape) (export) (display-shape (make-object Rectangle 50 100))))

  34. Link Them All Together (define Basic-Program (compound-unit (import) (link [S (Basic-Shapes)] [G (GUI (S Shape))] [P (Picture (S Rectangle) (S Circle) (G display-shape))]) (export)))

  35. And Run It (invoke-unit Basic-Program)

  36. Add a New Variant (define Union-Shape (unit (import Shape) (export Union) (define Union (class* ...))))

  37. Package It Up with the Others (define Basic+Union-Shapes (compound-unit (import) (link [S (Basic-Shapes)] [US (Union-Shape (S Shape))]) (export (S Shape) (S Rectangle) (S Circle) (US Union))))

  38. Add a Client that Uses It (define Union-Picture (unit (import Rectangle Circle Union display-shape) (export) (display-shape (make-object Union (make-object Rectangle 10 30) (make-object Circle 20))))

  39. Link Them All Together (define Union-Program (compound-unit (import) (link [S (Basic+Union-Shapes)] [G (GUI (S Shape))] [P (Picture (S Rectangle) (S Circle) (G display-shape))] [UP (Union-Picture (S Rectangle) (S Circle) (S Union) (G display-shape))]) (export))) Picture is unchanged!

  40. Add a New Operation (define BB-Shapes (unit (import Shape Rectangle Circle Union) (export BB-Shape BB-Rectangle BB-Circle BB-Union) (define BB-Shape (interface ...)) (define BB-Rectangle (class* Rectangle ...)) (define BB-Circle (class* Circle ...) (define BB-Union (class* Union ...) (define BB ...))) Implicit mixin!

  41. Package It Up with the Others (define Basic+Union+BB-Shapes (compound-unit (import) (link [S (Basic+Union-Shapes)] [BS (BB-Shapes (S Shape) (S Rectangle) (S Circle) (S Union))]) (export (S Shape) (BS BB-Shape) (BS BB) (BS (BB-Rectangle Rectangle)) ...))) Rename to preserve substitutability!

  42. Use the New Functionality (define BB-GUI (unit (import BB-Shape BB) (export display-shape) (define display-shape ...)))

  43. Link Them All Together Picture and UnionPictureare unchanged! (define BB-Program (compound-unit (import) (link [S (Basic+Union+BB-Shapes)] [BG (BB-GUI (S BB-Shape) (S BB))] [P (Picture (S Rectangle) (S Circle) (BG display-shape))] [UP (Union-Picture (S Rectangle) (S Circle) (S Union) (BG display-shape))]) (export)))

  44. Reading a Paper • What problem are they solving? • How do they solve it? • Why should I care?

  45. Solves Extensibility Problem • You can add both new variants and new operations without modifying existing clients • Unmodified clients may use the new operation • Or, they may not

  46. Synergy Between Modules and Classes • Modules are good for: • Separate development • Linking • Classes are good for: • Extensible datatypes • Selective reuse • Language should have both!

  47. Separate Definitions and Linking • Module: externally link dependencies • Classs: externally specify superclass In both, allow substitution of subtypes!

  48. In A Statically-Typed Setting • Would this work for Java? • Would this work for ML-with-objects?

  49. Bigger Picture • Do you buy it? • How could it be improved?

More Related