functional principles for object-oriented development

1. functional principles for object-oriented development • @jessitron

4. Imperative Procedural Functional Object-Oriented Logic Aspect-Oriented

7. Data In, Data Out Immutability Verbs Are People Too Declarative Style Specific Typing Lazy Evaluation

8. What is it? Principle Java / C# What is it? Scala / F# What’s the point? We already do it What is it?

9. Data In, Data Out

10. access global state modify input change the world

11. output input Data In -> ? -> Data out

12. Testable Easier to understand

13. the flow of data

15. List<Deposit> List<Donation> List<Match<Deposit,Donation>> List<Donation>

16. Problem easier, because we know each step of the way of data.

17. public string CreateAccount(UserDbService db, String email, String password) { … }

18. String password; String email; private boolean invalidPassword() { return !password.contains(email); }

19. private boolean invalidPassword(String password, String email) { return !password.contains(email); }

20. Immutability

21. modify anything

22. Concurrency fewer possibilities

23. NPE

24. c c

25. String Effective Java Effective C#

26. Scala val qty = 4 // immutable var n = 2 // mutable

27. F# let qty = 4 // immutable let mutable n = 2 // mutable n = 4 // false n <- 4 // destructive update

28. C#: easy public struct Address { private readonly string city; public Address(string city) : this() { this.city = city; } public string City { get { return city; } }

29. Java: defensive copy private final ImmutableList<Phone> phones; public Customer (Iterable<Phone> phones) { this.phones = ImmutableList.copyOf(phones); }

30. Java: copy on mod public Customer addPhone(Phone newPhone) { Iterable<Phone> morePhones = ImmutableList.builder() .addAll(phones) .add(newPhone).build(); return new Customer(morePhones); }

31. fruit.add(tomato) fruit

32. F#: copy on mod member this.AddPhone (newPhone : Phone) { new Customer(newPhone :: phones) }

33. C#: shallow copy public Customer AddPhone(Phone newPhone) { IEnumerable<Phone> morePhones = // create list return new Customer(morePhones, name, address, birthday, cousins); }

34. Thing doStuff() Option<T> NPE SomeThing doStuff() {…} Some<T> NullThing doStuff() {} None this talk is brought to you by… the Option type!

35. FSharpOption<T> Optional<T> … because null is not a valid object reference.

36. Verbs Are People Too

38. Imperative Procedural != Functional Object-Oriented Logic Aspect-Oriented

39. release ( ) OnClick() Command Strategy

40. Java class CostInflation implements FunctionOverTime { public float valueAt(int t) { return // some calculated value; } }

41. Scala val costInflation = Variable ( “Cost Inflation”, t => Math.pow(1.15,t)) val seasonalVolume = Array(0.95,0.99,1.01,…) val seasonalAdjustment = Variable(“Season”, t => seasonalVolume(t))

42. C# private readonly Func<int, double> calc; public Func<int, double> ValueAt { get { return calc; } }

43. C# var inflation = new Variable(“Inflation”, t => Math.Pow(1.15,t)); inflation.ValueAt(3);

44. Java Variable inflation = new Variable (“Inflation”, new Function<Integer, Double>() { @Override public Double apply(Integer input) { return Math.pow(1.15, input); } });

45. Java 8 Variable inflation = new Variable (“Inflation”, t => Math.pow(1.15, t) );

46. Declarative Style

47. say what you’re doing, not how you’re doing it

48. Select ROLE_NAME, UPDATE_DATE From USER_ROLES Where USER_ID = :userId

49. readable code smaller pieces

50. familiar !=readable