This is talk is about what remains after more than one year of learning about Functional Programming, Category Theory, Lambda Calculus, Javaslang and some Haskell and Scala too. I work with Apache Spark in Java8 & Javaslang. It’s a distributed computation context that works with large quantities of data. I started my journey into Functional Programming to reduce the complexity of my code.

1. aftermath of functional
programming
the good parts
@ggalmazor
@buntplanet

2. disclaimer

3. functional
programming

4. object orientation

5. “FP != OO”

6. mutation

7. why bother

8. equality rules
Stuff a = new Stuff();
Stuff b = a.changeSomething();
if (a.equals(b))
System.out.println("WTF");

9. output args
Stuff a = new Stuff();
// a.something holds 42
doStuffWith(a);
// a.something holds 33
// WTF

10. entity != value

11. surprises
a.setSuch();
a.setWow();
a.setVery();
a.setCoupling();

12. concurrency

13. control

14. how to avoid it

15. change your design

16. isolate mutation

17. copy on write

18. tips

19. ValueObject
class Stuff {
private final Integer aNumber;
private final String aString;
Stuff(Integer aNumber, String aString) {
this.aNumber = aNumber;
this.aString = aString;
}
…
}

20. class Stuff {
…
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass())
return false;
Stuff stuff = (Stuff) o;
return Objects.equals(aNumber,
stuff.aNumber) &&
Objects.equals(aString,
stuff.aString);
}
…
}
ValueObject

21. ValueObject
class Stuff {
…
@Override
public int hashCode() {
return Objects.hash(aNumber, aString);
}
…
}

22. factories

23. functional data
structures

24. side effects

25. why bother

26. accidental complexity

27. coupling

28. cqrs

29. object serialization in
a distributed context
final AtomicInteger counter =
new AtomicInteger(0);
rdd.map(stuff -> {
int i = counter();
return OtheStuff(i, stuff);
});

30. tips

31. think in pure functions

32. isolate and identify
side effects

33. functional data
structures

34. tools

35. option

36. nulls

37. monad

38. antipatterns
Optional.ofNullable(maybeNull).get();

39. antipatterns
Optional<Object> o =
Optional.ofNullable(maybeNull);
if (o.isPresent())
doStuffWith(o.get());

40. antipatrones
Optional<List<Object>> foo

41. antipatrones
Map<String,Optional<Object>> foo

42. tips

43. tuple

44. design exploration

45. tips

46. try

47. exceptions

48. when i use try

49. when i use try
Try.of(someComputation)

50. Try.of(someComputation)
.onFailure(logger::error)
.get()
when i use try

51. when i use try
Try.of(someComputation)
.flatMap(someOtherComputation)
.onFailure(logger::error)
.get()

52. when i use try
Try.run(someVoidComputation)
.anThen(someVoidComputation)
.onFailure(logger::error)
.get()

53. when i use try
Try.of(someComputation)
.orElse(42)

54. antipatterns

55. antipatterns
Try.run(()-> {
int a = somethingOverHere();
int b = somethingOverThere(a);
doTheGangnamStyle(a,b);
}).onFailure(t-> {
logger.error(“Everything’s f*cked!!!”, t);
}).get();

56. antipatterns
Try.of(thisWillReturnNull).toOption()

57. antipatrones
Try.of(someVoidComputation)
.map(thisWillGetDirty)

58. functional data
structures

59. why bother

60. know your tools

61. filter, map, fold

62. impact in your design

63. tips

64. small blocks

65. don’t go crazy

66. really. don’t go crazy

67. types

68. thanks!