The document summarizes a presentation about becoming a functional programmer. It covers topics like immutability, pure vs impure functions, recursion, higher-order functions, and concurrency. The goal is to introduce functional programming concepts and vocabulary. The presentation includes an agenda, introductions, pre-requisites, topics to be covered, and next steps for learning more about functional programming in Scala.

1. Becoming a
Functional
Programmer Presented By : Harit Himanshu

2. 2
Agenda
About Harit
Goal of the talk
Pre-requisites
Topics
Next Steps
Final Thoughts

3. 3
About Me
harittweets
Software Consultant
Favorites Work Product Trave
l
moneybonsai.com

4. 4
Goal
Vocabulary and Concepts
Scala JavaScript
Elm Haskell
OCaml Java
Languages

5. 5
Pre-requisites
Language Personal Finance
Functions
Variables
Income
Taxes
Expenses

6. 6
ImmutabilityPure and Impure Functions
Expressions and
Statements
Topics
Functions

7. 7
CurryingRecursion
Higher-Order Functions
Topics (contd.)
Referential
Transparency Concurrency

8. 8
Function
X Y
Time Money

9. 9
Types of Functions
Pure Impure

10. Pure function is a function where the return
value is only determined by its input values,
without observable side effects

11. 11
def grossMonthlySavings(grossMonthlyIncome: Double, expenses: Double) =
grossMonthlyIncome - expenses
grossMonthlySavings(10000.0, 4000.0) // 6000.0
grossMonthlySavings(10000.0, 4000.0) // 6000.0
grossMonthlySavings(10000.0, 4000.0) // 6000.0

12. 12
Impure Function Examples
API
Calls
Read/Write
to
Databases

13. 13
Pure vs Impure Functions
Pure Impure

14. 14
Pure and Impure Functions
Pure
Impure

15. 15
Pure Function Benefits
Easy to Test Reusable Parallelizable

16. An expression is something that yields a value

17. 17
val savings = income - expenses
Expression Example

18. Statement is some code that does some action

19. 19
def printUserName(userId: Int, name: String) = {
println(s"The user[$userId] is called as $name")
}
Statement Example

20. Immutability

21. 21
i = 10
j = 20
k = i + j // 25
Mathematics

22. 22
i = 10
j = 20
k = i + j // 30
i = 100
j = 90
k = i - j // 10
Imperative Programming

23. 23
Why Care About Immutability?
Easier to Reason No accidental changes Parallelizable

24. 24
Immutability in Real World?
Bank Transaction

25. 25
Variables in Scala
var expenses = 4000.0
expenses = 5000.0
val income = 10000.0
// compilation error
income = 9000.0
var (Mutable) val (Immutable)

26. 26
Mutability in var References
Amazon
Salaryt2
t1

27. 27
Mutability in var References
Amazon
Salaryt2
t1

28. 28
Immutability in val References
Amazon
Salaryt2
t1

29. 29
Immutable Reference Mutable Memory
Amazont1

30. An expression is (said to be) referentially
transparent if it can be replaced with its value
without changing the program’s behavior.

31. Recursion

32. 32
Recursion Properties
Base
Case
Recurse
To
Reduce

33. 33
Iteration Recursion
Iteration vs Recursion

34. Tail recursion is a technique where the
calculations are completed first, before passing
in the results to the next recursive call

35. Higher-Order Functions are functions that
take other functions as input or return functions
as the result

36. 36
def getFoodExpenses(ts: List[Transaction]): Double = {
val amounts = for (i <- ts.indices if ts(i).category == Food) yield ts(i).amount
amounts.sum
}
Creating Higher-Order Function
(Transaction) => BooleanTransaction => Boolean

37. 37
def getFoodExpenses(ts: List[Transaction], pred: Transaction => Boolean): Double = {
// Implementation goes here
}
Creating Higher-Order Function
val amounts = for (i <- ts.indices if pred(ts(i))) yield ts(i).amount
amounts.sum

38. Express what needs to happen instead of how

39. 39
Map is a Transformation
val amounts: List[Double] = transactions.map((t: Transaction) => t.amount)
List.map => List
Set.map => Set

40. 40
Filter is a Projection
val filtered: List[Transaction] = transactions.filter((t: Transaction) => t.debit == true)

41. 41
Opening a Bank Account

42. 42
Opening another Bank Account
Document Collection Counter Cash Counter

43. Currying is when a function that takes multiple
arguments is divided into a series of functions
that take part of the arguments

44. Concurrency

45. 45
Low-Level Concurrency
Threads Locks Synchronization

46. 46
Computing in Future
val resultInFuture: Future[Double] = Future {
// some asynchronous computation returning Double
}

47. 47
Next Steps

48. 48
Programming in Scala, 3rd
Edition

49. 49
https://www.pluralsight.com/courses/scala-big-picture

51. 51
Thank You
harittweets