This document discusses functional programming concepts like pure functions, immutable data, and avoiding side effects. It notes that FP uses higher-order functions, function composition, and transformation of immutable data structures rather than mutable state and assignment. FP allows for easier reasoning about programs, safer concurrency, and avoids problems introduced by mutable state. The document also advocates for representing data simply without defining classes and encourages practicing FP to understand its benefits.

1. Some basic FP concepts
@friemens

2. Why is mutable state problematic?
Functions as Values
Programming without assignment?
Handle mutable state safely
Leave data alone!

3. Nothing new here!
1930s Lambda Calculus
1960s Lisp
1990s Haskell

4. „Familiarity and Simplicity are orthogonal concepts.“
Rich Hickey

5. Why is mutable state problematic?

6. A system without side-effects is useless,
but...

7. Mutation hinders reasoning.

8. Mutable state increases test effort.

9. 1. 2.
Mutation introduces order.

10. Mutable state makes concurrency hard.

11. FP programming
OOP programming
Side-effects restrict how the machine can help us.

13. Context dependance
Pure Functions
Side-effects
The future-proof structure of any software system.

14. Functions as Values

15. Pure Function
=
No side-effects
+
Result depends only on param values

16. Lambda Expression
=
An anonymous function.

17. Closure
=
A function + some captured environment.

18. Higher-Order Function
Fn: [Any... -> Any]
F: [Any -> Fn]
G: [Fn -> Any]
H: [Fn -> Fn]
A function that
- does something with another function
- or returns a function,
- or both.

19. Function Application
Fn: [Any... -> Any]
apply: [Fn Any* -> Any]
Take collection of param values
and invoke function.

20. Partial Application
Fn: [Any1...Anym...Anyn -> Any]
partial: [Fn Any1...Anym ->
[Anym+1...Anyn -> Any]]
Create a new function with some arguments
fixed.
(„Currying“ is automatic partial application.)

21. Function Composition
F: [X -> Y]
G: [Y -> Z]
compose: [G F -> [X -> Z]]
Concatenate computations.

22. Programming without assignment?

23. Good bye =, for, while and cousins, ...
… say hello to let, map, filter and friends!

24. map
Thinking in collection transformations.
xs
ys
z
filter
concat reduce

25. map filter mapcat into
Don't be so eager!

26. Cheap parallelization.
reduce
combine

27. Handle mutable state safely

28. State x State x'
f
swap!
Identity
Separate state from identity.

29. Give identities well-defined concurrency semantics.

30. Share immutable state liberally.
Be restrictive with access to identities.

31. Leave data alone!

32. BigHero
-a string
-a map
+method1
+method2
+method3
Objects claim feature completeness.

33. You can't foresee the future.

34. You will violate the Open-Closed-Principle.

35. „Inventing a class with its own interface
to hold a piece of information is like inventing
a new language to write every short story. “
Rich Hickey

36. Data is simple.

37. DSL
API
Data Model

38. Wrap up

39. OO makes code understandable
by encapsulating moving parts.
FP makes code understandable
by minimizing moving parts.
Michael Feathers

40. The future is functional.
You need to practice FP before you „get“ it.
It's more fun!

41. Questions?