FP The Good, the Bad and the Ugly @DanielaSfregola LSUG - November 2019 

Hellooooo • Italian living in London UK • Former Java Developer • Scala Lover 

• Rome, Cinecitta' 
 23 December 1966 • Director
 Sergio Leone • Music
 Ennio Morricone 

Everything in Life • Good Parts
 the bits that we like • Bad Parts
 the traps to avoid • Ugly Parts
 the parts that we need to live with 

FP: The Good 

Increased Productivity 

Immutability private var i: Int = 0 while (i < 10) { // do stuff here i = i + 1 } OOP 

Immutability private var i: Int = 0 while (i < 10) { // do stuff here i = i + 1 } OOP (0 until 10).foreach { i => // do stuff here } FP 

Immutability private var i: Int = 0 while (i < 10) { i = i * 2 println(i) i = i + 1 } OOP (0 until 10).foreach { i => println(i * 2) } FP 

Purity def length(s: String): Unit = { // implementation here } Impure 

Purity def length(s: String): Unit = { // implementation here } Impure def length(s: String): Int = { // implementation here } Pure 

Purity Composability 

Puzzle Coding! from https://scalameta.org/metals/ Metals 

FP: The Bad 

Learning Curve 

Functional Programming
 != 
 Categorical Programming 

You do not need to know Category Theory to write good 
 Functional code 

...but Monads are EASY! 

A Monad is just a Monoid in the Category of Endofunctors 

Monads are like
 Burritos from https://twitter.com/monadburritos/status/915624691829587968 

Is Lasagna a Monad? 

The importance of talks and tutorials for Beginners 

The Rock Star Developer Syndrome 

The Rock Star Developer from https://twitter.com/honeypotio/status/689811823281991681 

Be a Leader not a "Rock Star" 

FP: The Ugly 

Knowing when to break the rules 

Case Class to Array def toArray(product: Product): Array[Any] = { product // Product .productIterator // Iterator[Any] .toArray // Array[Any] } FP 

Case Class to Array def toArray(product: Product): Array[Any] = { product // Product .productIterator // Iterator[Any] .toArray // Array[Any] } def toArray(product: Product): Array[Any] = { val size = product.productArity val arr = new Array[Any](size) var i = 0 while (i < size) { arr(i) = product.productElement(i) i = i + 1 } arr } FP OOP 

Benchmarking* import com.danielasfregola.randomdatagenerator.RandomDataGenerator._ def avgRunTime[A](f: => A, n: Int = 1000): Double = { val start = Instant.now.toEpochMilli (0 until n).foreach(_ => f) val end = Instant.now.toEpochMilli val diff = end - start diff / n.toDouble } case class BigExample(f1: String, f2: Int, f3: Long, f4: Char, f5: String, f6: String, f7: Int, f8: Long, f9: Char, f10: String, f11: String, f12: Int, f13: Long, f14: Char, f15: String, f16: String, f17: Int, f18: Long, f19: Char, f20: String, f21: String, f22: Int, f23: Long, f24: Char, f25: String, f26: String, f27: Int, f28: Long, f29: Char, f30: String) val big = random[BigExample] avgRunTime(toArrayFP(big)) avgRunTime(toArrayOOP(big)) *not a serious benchmarking, executed on my laptop 

Benchmarking* import com.danielasfregola.randomdatagenerator.RandomDataGenerator._ def avgRunTime[A](f: => A, n: Int = 1000): Double = { val start = Instant.now.toEpochMilli (0 until n).foreach(_ => f) val end = Instant.now.toEpochMilli val diff = end - start diff / n.toDouble } case class BigExample(f1: String, f2: Int, f3: Long, f4: Char, f5: String, f6: String, f7: Int, f8: Long, f9: Char, f10: String, f11: String, f12: Int, f13: Long, f14: Char, f15: String, f16: String, f17: Int, f18: Long, f19: Char, f20: String, f21: String, f22: Int, f23: Long, f24: Char, f25: String, f26: String, f27: Int, f28: Long, f29: Char, f30: String) val big = random[BigExample] avgRunTime(toArrayFP(big)) avgRunTime(toArrayOOP(big)) *not a serious benchmarking, executed on my laptop toArrayFP avg execution: 0.028 ms toArrayOOP avg execution: 0.002 ms 

JVM and FP do not always go along... OOP version is much faster than the FP one! 

My ideal implementation of map function for List[A] final override def map[B](f: A => B): List[B] = { @tailrec def loop(l: List[A], res: List[B]): List[B] = { l match { case head :: tail => loop(tail, res :+ f(head)) case Nil => res } } loop(this, res = Nil) } 

The real implementation of map function for List[A]* final override def map[B](f: A => B): List[B] = { if (this eq Nil) Nil else { val h = new ::[B](f(head), Nil) var t: ::[B] = h var rest = tail while (rest ne Nil) { val nx = new ::(f(rest.head), Nil) t.next = nx t = nx rest = rest.tail } releaseFence() h } } *scala 2.13.0 

If you have a really good reason, break the rules! ...but keep the ugly bits isolated 

Scala FP OOP 

Scala is Perfect 

Scala is Perfect not 

Not even Scala is perfect... • Slow Compiler • pipelining compilation by Jason Zaugg • zinc by Eugene Yokota • Tooling • bloop by Jorge Vicente Cantero • metals by Ólafur Páll Geirsson 

Thank You! •Twitter: @DanielaSfregola •Blog: danielasfregola.com •Book: Get Programming with Scala
 by Manning