iOSDevUK'16 talk on how to start using FP without giving up on using OOP

1. Functional
Programming for
busy OOP
Now with obligatory kitten!

2. Hello, World!
• Diego Freniche 1
• @dfreniche
• 100% remote dev (iOS / Android)
• writing new bugs @ Mobile Jazz
1
CV: git clone http://www.github.com/dfreniche/cv

3. BASIC days
• What I've already learnt at
iOSDevUK'16:
• I'm a dinosaur
• We're getting older
• Nostalgia is in the air

5. GLORY days
• self taught PASCAL before starting
College
• just to find C was the language of choice
• saw several languages: Ada, C, C++
• fell in love with C++ (pre-STL times...)

7. Wait, am I an imperative
programmer?
• Cursed for life !
• Spoiled by BASIC, C++
• will never get a job in CS. Ever.

8. Well maybe I can call
myself a REAL OOP
developer
• this book is really hard to read
• I mean, like really hard
• that's only imperative++

9. Wait, I was taught LISP in
College
• You know:
• Lost In Stupid Parentheses
• Lots of Irritating Superfluous
Parentheses
• ...

10. F.P.: a new thing, right? !
• invented in the late 50's (1958)
• only ALGOL is older
• derived from the Lambda Calculi
(developed in the 30's)

11. A word (or two) on LISP
• simplest syntax in ANY programming language
• Code:
(+ 3 2)
• List of data:
'("hello", "world")

12. A word (or two) on LISP
• homoiconicity: "the structure of
program code is represented faithfully
and directly in a standard data
structure"
• we have direct access to the compiler's
AST
• Much power. So cool. Such compiler.
Wow

13. • homoiconicity == less syntax to learn
• turn all your fancy { } and [ ] into ( ) and
you get LISP again!
• because I've never used http://
goshdarnblocksyntax.com

14. Eval: treat data like code, code like data
• Eval: treat data like code, code like data
CL-USER> '(+ 3 4)
(+ 3 4)
CL-USER> (+ 3 4)
7
CL-USER> (eval '(+ 3 4))
7
! https://repl.it/languages/scheme

15. Ideas piooneered by LISP
• tree data structures
• automatic storage management
• dynamic typing
• conditionals
• higher-order functions
• recursion
• the self-hosting compiler
• REPL: Read Eval Print Loop interpreter

16. Greenspun's tenth rule 2
Any sufficiently complicated C or Fortran program contains an ad
hoc, informally-specified, bug-ridden, slow implementation of half of
Common Lisp.
2
maybe the NSA, Santa Claus, Zuck and your peers who hate F.P.

17. F.P. is back!
• Closures & High Order Funcions in Swift. Inmutability. Optionals.
• Blocks in Objective-C to mimic Closures.
• Scala
• C# / F#
• JavaScript?

18. Being a Functional Language vs. having Functional
Constructs
There's no accepted definition of functional programming language.
_
If you define functional language as the language that supports first class
functions and lambdas, then yes, JavaScript is a functional language.3
3
http://stackoverflow.com/questions/3962604/is-javascript-a-functional-programming-language

19. Functional Programming
... functional programming is a programming paradigm ... that treats
computation as the evaluation of mathematical functions and
avoids changing-state and mutable data. It is a declarative
programming paradigm,

20. Functional Programming
... the output value of a function depends only on the arguments
that are input to the function, so calling a function f twice with the
same value for an argument x will produce the same result f(x) each
time eliminating side effects
https://en.wikipedia.org/wiki/Functional_programming

22. All the talks I've been
before
• Me: "Hi, I'm Diego, need to lose some
weight"
• Someone at the Gym: "No problem, you
can start doing this Arnold lift weigthing
routines from his training to became
Mister Olympia"
• Me: !

23. All the talks I've been
before
• I know nothing about it, but want to
learn! ☝
• Functors, Monads, Functional purity, etc.
"
• Talks like "Type Check Removal Using Lazy
Interprocedural Code Versioning" #

24. Why you hate FP?
• Functional programming is declarative
• we were born as imperative
programmers!
• say what you want, not micromanage how
to do it
• you're already doing it! (hating)
• SQL
• CSS
• Regular expressions

25. OK, Something practical, please?

26. Inmutability, avoiding state, don't shoot yourself in the
foot
• Value types and immutability
• compiler can optimize your code !
• eats more memory "
• also CPU (making all those copies) "
• this can be optimized
• optimizes programmer's time #

27. Inmutability
• Diego's constants dumb rule
Declare everything as a constant, let compiler warn you when you're
changing something. That's a variable.
// Java: final everything
final String s = "";
s = "other thing"; // nope
// Swift
let s: String = ""

28. Inmutability: nice to avoid mistakes
- (void)printAStringReallyStupidBug:(NSString *)aString {
aString = nil; // stupid mistake
// really clever code
// trust me, I know what I'm doing
// in this 300 lines method
NSLog(@"Printing: %@", aString);
}

29. Inmutability
func removeFromString( _ s: inout String, Character c:Character) -> Int {
var nRemoved = 0
while let ix = s.characters.index(of: c) {
s.removeSubrange(ix...ix)
nRemoved += 1
}
return nRemoved
}

30. Inmutability: a clear example
- (void)version1 {
NSString *myString = @"iOSDevUK 16";
NSLog(@"myString BEFORE: %@", myString); // BEFORE: iOSDevUK 16
[self printAStringAllGood:myString];
NSLog(@"myString AFTER: %@", myString); // AFTER: iOSDevUK 16
NSLog(@"myString BEFORE: %@", myString); // BEFORE: iOSDevUK 16
[self printAStringReallyStupidBug:myString];
NSLog(@"myString AFTER: %@", myString); // AFTER: iOSDevUK 16
NSLog(@"myString BEFORE: %@", myString); // BEFORE: iOSDevUK 16
[self printAStringEvilBug:&myString];
NSLog(@"myString AFTER: %@", myString); // AFTER: iOSDevUK 16
}
- (void)printAStringAllGood:(NSString *)aString {
NSLog(@"Printing: %@", aString);
}
- (void)printAStringReallyStupidBug:(NSString *)aString {
aString = nil; // stupid mistake
NSLog(@"Printing: %@", aString);
}
- (void)printAStringEvilBug:(NSString **)aString {
*aString = @"HaHa";
NSLog(@"Printing: %@", *aString);
}

31. Inmutability lessons
• learn to use debug breakpoints
• change your code to call that function
• we can use blocks, function pointers, Swift closures...
• a little tradegy in that backward language
NSString const *myString = @"iOSDevUK 16";
⚠ Sending 'const NSString *__strong' to parameter
of type 'NSString *' discards qualifiers

32. Inmutability: don't use ++
var i = 0
print("( ++i )")
• direct translation from assembler INC
• does several things at once
• hard to reason about
• nice syntax !

33. Optionals are not a new thing
• non-optionals are the new thing!
class Person {
var name: String
// compiler ERROR: you can't fool me!
}

34. Optionals are not a new thing
class Politician: Hyena {
// still compiler ERROR
}

35. High order functions
• Functions that take functions as
parameters
• Map, Filter, Reduce, Flatmap
• Let's do something with these fruits

36. Map
• "Do THIS to every single element in the list"
• add 1 to every element in this list
• takes a function (add one) & a list
• returns a list
• with a basket of fruit: peel every fruit in this basket
• think of SQL update

37. Map example
let basket = ["!", """, "#", "$", "%"]
basket.map { (e: String) -> String in
return "&" + e
}

38. Map Benefits
• map is a level of indirection
• can be run in parallel (applying a function on element n doesn't
depend on element n+1)

39. Filter
• "I only want oranges from that basket"
• SQL select WHERE clause

40. Filter example
• "I only want Apples"
let basket = ["!", """, "#", "$", "%", "&"]
let newBasket = basket.filter { $0 == "!" || $0 == "&"
}

41. Reduce
• takes a function (add) & a list
• returns just one element
• make multi-fruit juice
• think of AVG function in SQL

42. Reduce example
let numbers = [1, 2, 3, 4, 5, 6]
numbers.reduce(0, combine: +) --> 21

43. Flatmap
• Like map, but also "flattens" the list
• some of the fruits in the basket are wrapped with paper

44. Flatmap example
// how do you add 2 to all the numbers in this array?
let fa2 = [[1,2],[3],[4,5,6]]
let fa2m = fa2.flatMap({$0}).map({$0 + 2})
fa2m

45. This is from Clean Coding... or not
• Functions should be:
• Small
• Smaller than that
• < 150 chars per line
• < 20 lines

46. Inject all your parameters
• even if you're using properties from your own class
• makes everything inmediately testable
• no side effects: everything is clear when calling
• you get your own Domain Specific Language to express your
problem

47. So what?
• you don't need to be an athlete to run
and be healthier
• you don't need to be pure to benefit from
some FP goodness

48. So what?
• use inmutable structures where possible
• in Java, for example, final everything
• in Swift, prefer structs (value types) vs classes (reference types)

49. So what?
• map / filter / reduce helps sometimes
• think of it as having SQL at your fingertips
• not everything is a for loop

50. Use the best of OOP + the best of FP.
Nobody will ever know. 2
2
maybe the NSA, Santa Claus, Zuck and your peers who hate F.P.

51. Thanks!
• No Trademarks were hurt during the
making of this talk.
• all trademarks belong to their owners, so
please don't sue me.

52. Additional reading
• A really good post on what F.P. is (with Swift examples!) http://
five.agency/functional-programming-in-swift/
• A parallel map implementation: http://
moreindirection.blogspot.com.es/2015/07/gcd-and-parallel-
collections-in-swift.html