OO in Scala - The unloved side of the cake?

Component composition in Scala using a variant of the cake pattern

Transcript

1. OO in Scala The unloved side of the cake?
2. About Me Tobias Neef Consultant / Dev at innoQ doing stuff in Berlin
3. This talk is about OO and cakes in Scala
4. Disclaimer I love FP but OO still has it’s values
5. Everybody loves cakes. Do you love the cake in Scala?
6. The How and Who of component composition
7. How
9. I
10. I C C C
11. I C C C C
12. I C C C C C
13. Who
14. object composition == component configuration
15. Who combines the objects in the required configuration to one component?
16. We can solve this with DI right?
17. IoC
18. IoC Who == the container
19. The typical DI has some serious issues
20. It evolves into a add-on language
21. @Component public class OrderRepo { @Autowired BookingWriter bookingWriter; @Autowired OrderHeaderDao orderHeaderDao; ...
22. Not covered by the typesystem
23. @Component public class OrderRepo { @Autowired BookingWriter bookingWriter; @Autowired OrderHeaderDao orderHeaderDao; ...
24. Managed Instances
25. new MyClass == this is not a component
26. Cyclic dependencies are hard not to express
27. Back to the cake
28. Cake Pattern == Scala flavored OO component composition
29. Ingredients
30. Traits Are like interfaces with implementation
31. trait CustomerTS {! def getTicket(id:Long) def default = new ... }
32. Self-Types Manual typing of the this reference
33. trait CustomerTS {! self : CustomerDao => ... }
34. Dependency Context Though composed traits
35. trait Component { def instance : ManagedClass trait ManagedClass { def method():Int } }
36. trait Component { def instance : ManagedClass trait ManagedClass { def method():Int } } Logic Context
37. trait Component { def instance : ManagedClass trait ManagedClass { def method():Int } } Component Context Logic Context
38. trait Component { / / New Instances / / Unique Instances / / Dependencies / / Component Inheritance }
39. trait ManagedClass { / / normal class / / access to component / / application logic }
40. trait AuthComponent { def authComponent: Auth trait Auth { def load(name: String, pass: String): Option[User] protected def internalUser() = .. } }
41. Dependencies
42. Class 1 Class 2 Component 1 Component 2 Depends Uses
43. trait BookingServiceComponent { ! self : AuthComponent => def bookingService = ! new BookingService() class BookingService { def book(user: String, pass: String, !! itemId:Id) = ! ! ! authComponent.load(user,pass) ... } }
44. Inheritance
45. Class 1 Class 2 Component 1 Component 2 Is Uses Extends
46. trait LocalAuthComponent extends AuthComponent { def authComponent = new LocalAuth() class LocalAuth extends Auth { def load(name: String, pass: String) = ... } }
47. trait LDAPAuthComponent extends AuthComponent { def authComponent = new LDAPAuth() class LDAPAuth extends Auth { def load(name: String, pass: String) = ... } }
48. The Application Cake
49. trait BookingApp extends AuthComponent BookingServiceComponent
50. class LiveBookingApp extends LdapAuthComponent BookingServiceComponent Dependencies are checked at compile time
51. A cake component == a partial application with dependencies
52. Is made of the core Scala language It is checked at compile time It requires no IoC It uses the most specific type available It can express cyclic dependencies It can’t change its configuration at runtime The Cake
53. Bakery of Doom
54. Does everything have to be a cake?
55. Not everything in your app is a component interface
56. But most of your app should belong to a component
59. The cake package pattern
60. Component Package Component Interface Internal Package Internal Component ...
61. packages in Scala are more than namespaces
62. visibility rules can shield the component internals
63. Your App == Functional Components / Packages Result
65. Functional and technical contexts
66. Functional Contexts enhance the functionality of an application
67. Technical Contexts are the basis for the Functional Contexts
68. Technical Contexts can bridge the outside world and the cake world
69. trait TechnicalComponent { def tc : TechnicalContext }
70. trait FunctionComponent { ! this => TechnicalComponent def fc: FunctionClass trait FunctionClass { ... } }
72. Requires
73. Builds Requires
74. Builds Requires PlayAkka ActorSystem Provides
75. trait GlobalActorSystem { private[core] def actorSystem: ActorSystem private[core] implicit val defaultTimeout = Timeout(4,TimeUnit.SECONDS) } Default Implicits Technical Context
76. class PlayServiceModule( val actorSystem: ActorSystem, ...) extends ServiceModule with GlobalActorSystem ...
77. import play.api.Play.current lazy val app = new PlayServiceModule( play.api.libs.concurrent.Akka.system, ...) Bridge the Play framework to an application cake
78. Thanks!