Less Imperative with More Kotlin

LESS IMPERATIVE WITH MORE HUYEN TUE DAO @QUEENCODEMONKEY

Alright. Let’s talk terms.

IMPERATIVE PROGRAMMING a sequence of statements that change state.

focuses on actions. explicit control flow. IMPERATIVE PROGRAMMING

paradigm by which you describe how to do something. IMPERATIVE
PROGRAMMING

100 REM FIND THE SUM OF THE TWO NUMBERS 200
LET X=9 300 LET Y=6 400 LET Z=X+Y 500 PRINT X,Y,Z 600 END

fun average(numbers: List<Int>): Float { var total = 0f for
(i in 0 until numbers.size) { total += numbers[i] } return total / numbers.size }

DECLARATIVE PROGRAMMING describe what you want to do.

CAVEAT you or someone you encounter on StackOverflow may find
this too fluffy, simplistic, imprecise, ambiguous. that’s okay. let’s keep this chill and practical.

DECLARATIVE PROGRAMMING describe what you want to do.

DECLARATIVE STYLE describe what you want to do.

<html> <body> <h1>Heyo, Foursquare!</h1> <p>What's up?</p> </body> </html>

SELECT * FROM [Builds] WHERE [Efficacy] = 'OP'

fun average(numbers: List<Int>): Float {A var total = 0 forA(i
in 0Auntil numbers.size) { total += numbers[i] } return total.toFloat() / numbers.size }A

fun average(numbers: List<Int>): Float {A val total = numbers.sum() return
total.toFloat() / numbers.size }A

DECLARATIVE STYLE “…coding in the imperative style is like talking
to a toddler.” Venkat Subramaniam

DECLARATIVE STYLE “The declarative version is like speaking to a
responsible adult.” Venkat Subramaniam

Take your first left. Continue straight 2 miles. Slight right
onto Raynor St. Left onto Kerrigan Ave. Continue straight .2 miles. DECLARATIVE IMPERATIVE My address is 8 Kerrigan Ave Reference, CO 88888 Tyler McGinnis “How do I get to your house from here?”

FUNCTIONAL PROGRAMMING

FUNCTIONAL STYLE

FUNCTIONAL PROGRAMMING some disagreement on exact definition.

FUNCTIONAL PROGRAMMING style of programming based on evaluating functions

FUNCTIONAL PROGRAMMING style of programming based on evaluating f: x
→ f(x)

FUNCTIONAL PROGRAMMING style of programming based on evaluating expressions

STATEMENTS EXPRESSIONS computations. actions.

fun average(numbers: List<Int>) = numbers.sum().toFloat() / numbers.size

FUNCTIONAL PROGRAMMING mathematical, theoretical foundations. Category Theory. λ-calculus. many high-level
and abstract concepts.

Let’s start with basic and practical, exploring a different way
of thinking

var count = 1 fun calculate(x: Int, y: Int): Int
{A count++ return x + y }A

what are side effects? SIDE EFFECTS when a function makes
modifications of outside state

what are side effects? SIDE EFFECTS name sets them apart
from main result of function.

fun calculateAndCache(x: Int, y: Int): Int { val value =
x + y val sharedPrefs = getPreferences(Context.MODE_PRIVATE) sharedPrefs .edit() .putInt("lastValue", value) .apply() return value }

{A return x + y - count }A

fun calculate(x: Int, y: Int): Int { val value =
x + y + resources.getInteger(R.integer.some_important_integer) return value }

when a function utilizes outside state or I/O SIDE CAUSES
Kris Jenkins

when a function makes modifications of outside state SIDE EFFECTS

when a function interacts with the outside world SIDE EFFECTS

SIDE EFFECTS “Wait. Isn’t that just programming?”

SIDE EFFECTS apps need to interact with the outside world

Here comes the “but”…

make code harder to trace and understand. SIDE EFFECTS

make code harder to test and debug. have to re-create
the environment. SIDE EFFECTS

therefore, can be a source of bugs. SIDE EFFECTS

but we need them. so we want to limit and
control them. SIDE EFFECTS

FUNCTIONAL PROGRAMMING style of programming based on evaluating expressions

FUNCTIONAL PROGRAMMING “Functional code is characterised by one thing: the
absence of side effects.” Mary Rose Cook

FUNCTIONAL PROGRAMMING “Every other ‘functional’ thing can be derived from
this property.” Mary Rose Cook

FUNCTIONAL PROGRAMMING No side effects. Immutability. Higher-order functions. Kotlin in
Action

result depends only on the inputs. there are no side
effects. PURE FUNCTIONS

idempotent function that has the property that: f(f(x)) → f(x)
PURE FUNCTIONS

idempotent multiple calls with same inputs has same effect as
one call. PURE FUNCTIONS

var count = 0 fun increment() { count++ // count
= 1 count++ // count = 2 count++ // count = 3 count++ // count = 4 }

nullipotent calling function zero times has same effect as calling
it once. PURE FUNCTIONS

referential transparency an expression or function may be safely replaced
by its value. PURE FUNCTIONS

{A return x + y }A val result = calculate(1, 2) // result = 3, count = 0

{ return x + y }A val result = 3 // result = 3, count = 0

{A count++ return x + y }A val result = calculate(1, 2) // result = 3, count = 1

{A count++ return x + y }A val result = 3 // result = 3, count = 0

referential transparency an expression or function may be safely replaced
by its value. PURE FUNCTIONS

Absence of side effects. PURE FUNCTIONS

Encourages separation of concerns. PURE FUNCTIONS

Easier to understand and test. PURE FUNCTIONS

FUNCTIONAL PROGRAMMING No side effects. Immutability. Higher-order functions. Kotlin in
Action

So what are the benefits?

Easier to understand.

More concise.

More maintainable.

Easier testing.

Safer multithreading.

Less error-prone.

FUNCTIONAL BITS OF

FUNCTIONAL BITS OF function types + lambdas.

FUNCTIONAL BITS OF data classes + immutable collections

FUNCTIONAL BITS OF functional style APIs in the stdlib

FUNCTIONAL BITS OF functional is not required. can live next
to imperative and OOP code.

Let’s start thinking functionally with .

fun average(numbers: List<Int>) = numbers.sum().toFloat() / numbers.size immutability

fun average(numbers: List<Int>) = numbers.sum().toFloat() / numbers.size pure function

fun average(numbers: List<Int>) = numbers.sum().toFloat() / numbers.size pure function depends
only on input same inputs yield same output

fun average(numbers: List<Int>) = numbers.average()

stdlib is full of functional operators.

functional operators are awesome.

let’s talk about mapping.

val films = listOf( Movie("Beauty and the Beast", 2017, 504.1f),
Movie("Guardians of the Galaxy Vol. 2", 2017, 389.8f), Movie("Dunkirk", 2017, 188.5f), Movie("Rogue One", 2016, 532.18f), Movie("Finding Dory", 2016, 486.30f), Movie("Deadpool", 2016, 363.07f), Movie("Fantastic Beasts and Where to Find Them", 2016, 234.04f), Movie("Hidden Figures", 2016, 169.39f), Movie("Star Wars: The Force Awakens", 2015, 936.66f), Movie("Jurassic World", 2015, 652.27f), Movie("Avengers: Age of Ultron", 2015, 459.01f), Movie("Inside Out", 2015, 356.46f) )

fun getFilmTitles(films: List<Movie>): List<String> {A val names = mutableListOf<String>() for
(film in films) { names.add(film.name) } return names }A

fun getFilmTitles(films: List<Movie>): List<String> {A return films.map { film ->
film.name } }A

Iterable<T>.map(transform: (T) -> R): List<R>

extension function Iterable<T>.map(transform: (T) -> R): List<R>

Iterable<T>.map(transform: (T) -> R): List<R> immutability

Iterable<T>.map(transform: (T) -> R): List<R> higher-order function

fun getFilmTitles(films: List<Movie>): List<String> {A val names = mutableListOf<String>() for
(film in films) { names.add(film.name) } return names }A

fun getFilmTitles(films: List<Movie>): List<String> {A return films.map { film ->
film.name } }A let’s sprinkle on some sugar.

fun getFilmTitles(films: List<Movie>) = films.map { it.name }

fun getFilmTitles(films: List<Movie>) = films.map { it.name } expression body
implicit single parameter name

fun getFilmTitles(films: List<Movie>) = films.map { it.name }

fun getFilmTitles(films: List<Movie>) = films.map(Movie::name) property reference

let’s talk about folding.

fun totalGross(films: List<Movie>): Float { var gross:Float = 0f for
(film in films) { gross += film.gross } return gross }

fun totalGross(films: List<Movie>): Float { return films.fold(0f) { gross, film
-> gross + film.gross } }

fun Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

fun Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R pure function

extension function

immutability

higher-order function

fun totalGross(films: List<Movie>): Float { return films.fold(0f) { gross, film
-> gross + film.gross } }

let’s sprinkle on some sugar. fun totalGross(films: List<Movie>): Float {
return films.fold(0f) { gross, film -> gross + film.gross } }

fun totalGross(films: List<Movie>) = films.sumByDouble { movie -> movie.gross.toDouble() }

let’s talk about filtering.

fun moviesFrom2017(films: List<Movie>): List<Movie> { val results = mutableListOf<Movie>() for
(film in films) { if (film.year == 2017) { results.add(film) } } return results }

fun moviesFrom2017(films: List<Movie>) = films.filter { it.year == 2017 }

fun Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

fun Iterable<T>.filter(predicate: (T) -> Boolean): List<T> pure function

fun Iterable<T>.filter(predicate: (T) -> Boolean): List<T> immutability

fun Iterable<T>.filter(predicate: (T) -> Boolean): List<T> higher-order function

fun moviesFrom2017(films: List<Movie>) = films.filter { it.year == 2017 }

println("2016 Films = ${films.filter { it.year == year }}")

val greaterThan100M = { movie: Movie -> movie.gross > 100.0f
} println("2016 Films = ${films.filter(greaterThan100M)}") starting to look like a strategy pattern

now for some composition.

val names = films .filter { it.year == 2016 &&
it.gross > 100f } .map { it.name } println("Name of 2016 Films Grossing More Than $100M = $names")

experiment with creating declarative structures.

interface Map<K, V> V computeIfAbsent(K key, Function<? super K,? extends
V> mappingFunction) V computeIfPresent(K key, Function<? super K,? extends V> mappingFunction) let’s make our own and sprinkle on function types

inline fun <K, V> MutableMap<K, V>.computeIf(key: K, predicate: (K, V?)
-> Boolean, mappingFunction: (K, V?) -> V?): V? { val oldValue = get(key) if (!predicate(key, oldValue)) return oldValue val newValue = mappingFunction(key, oldValue) if (newValue == oldValue) return newValue if (newValue != null) put(key, newValue) else if (oldValue != null) remove(key) return newValue }

-> Boolean, mappingFunction: (K, V?) -> V?): V? { val oldValue = get(key) if (!predicate(key, oldValue)) return oldValue val newValue = mappingFunction(key, oldValue) if (newValue == oldValue) return newValue if (newValue != null) put(key, newValue) else if (oldValue != null) remove(key) return newValue } extension function

-> Boolean, mappingFunction: (K, V?) -> V?): V? { val oldValue = get(key) if (!predicate(key, oldValue)) return oldValue val newValue = mappingFunction(key, oldValue) if (newValue == oldValue) return newValue if (newValue != null) put(key, newValue) else if (oldValue != null) remove(key) return newValue } functions as inputs

-> Boolean, mappingFunction: (K, V?) -> V?): V? { val oldValue = get(key) if (!predicate(key, oldValue)) return oldValue val newValue = mappingFunction(key, oldValue) if (newValue == oldValue) return newValue if (newValue != null) put(key, newValue) else if (oldValue != null) remove(key) return newValue } all mutability hidden inside

-> Boolean, mappingFunction: (K, V?) -> V?): V? { val oldValue = get(key) if (!predicate(key, oldValue)) return oldValue val newValue = mappingFunction(key, oldValue) if (newValue == oldValue) return newValue if (newValue != null) put(key, newValue) else if (oldValue != null) remove(key) return newValue } blending programming paradigms

cachedConfigs.computeIf( "KittiesOnDemandFeature", { key, previous -> previous?.json != kittyJson },
{ key, previous -> FeatureConfig.from(kittyJson) } )

THANK YOU! SPEAKERDECK.COM/QUEENCODEMONKEY YOUTUBE.COM/ANDROIDDIALOGS RANDOMLYTYPING.COM HUYEN TUE DAO @QUEENCODEMONKEY

val result = x + y computation

val result = x + y action

REFERENCES 147 Wikipedia: Functional Programming | wikipedia.org/wiki/Functional_programming Functional Programming |
https://wiki.haskell.org/Functional_programming What Is Functional Programming? | blog.jenkster.com/2015/12/what-is-functional-programming.html | @krisajenkins An introduction to functional programming | codewords.recurse.com/issues/one/an-introduction-to-functional-programming | @maryrosecook Imperative vs. Declarative Programming | https://tylermcginnis.com/imperative-vs-declarative-programming/ | @tylermcginnis Imperative Style | http://blog.agiledeveloper.com/2015/07/the-imperative-style.html | @venkat_s Declarative Style | http://blog.agiledeveloper.com/2015/07/the-declarative-style.html | @venkat_s Functional Style | http://blog.agiledeveloper.com/2015/08/the-functional-style.html | @venkat_s Beneﬁts of Pure Functions: Offer Referential Transparency | blog.agiledeveloper.com/2016/01/beneﬁts-of-pure-functions-offer.html | @venkat_s Functional Programming Favors Expressions over Statements | http://blog.agiledeveloper.com/2015/08/functional-programming- favors.html | @venkat_s What is function programming? | https://www.quora.com/What-is-functional-programming

REFERENCES 148 Kotlin in Action | manning.com/books/kotlin-in-action WikiWikiWeb | wiki.c2.com/
Why Functional Programming Matters | https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf | John Hughes, The University, Glasgow Kotlin purity and function memoization | https://medium.com/@JorgeCastilloPr/kotlin-purity-and-function-memoization- b12ab35d70a5 Kotlin Functional Programming: Does it make sense? | medium.com/@JorgeCastilloPr/kotlin-functional-programming-does-it-make- sense-36ad07e6bacf | @JorgeCastilloPr Functional, Declarative, Imperative Programming [closed] | https://stackoverflow.com/questions/602444/functional-declarative-and- imperative-programming What are monads in functional programming and why are they useful? | https://www.quora.com/What-are-monads-in-functional- programming-and-why-are-they-useful-Are-they-a-generic-solution-to-the-problem-of-state-in-FP-or-Haskell-specific-Are-they- specific-to-Haskell-or-are-they-encountered-in-other-FP-languages

Less Imperative with More Kotlin

Less Imperative with More Kotlin

More Decks by Huyen Tue Dao

Other Decks in Programming

Featured

Transcript