Speaking Scala: Refactoring for Fun and Profit (Workshop)

Speaking
Scala
Refactoring for Fun and Profit
Tomer Gabel, August 2015

Agenda
• Part 1, where we’ll:
– Show examples
– Identify patterns
– … and anti-patterns
– Discuss our findings
– And learn!

Agenda
• Part 2, where you
do the lifting:
– Fork (the repo)
– Bork (the code)
– Work (the tests)

Prepare Thyself
• You’ll need…
–Your favorite IDE
–Sbt
–Git
–And of course…

Our Victim
• … is ScalaChess
– Provides a full domain
model for chess
– Great test coverage
– High quality code
– MIT license
– Integrated in lichess.org
* ScalaChess is an open-source project by Thibault Duplessis

Fork that shit:
http://github.com/holograph/scalachess

Naming Things
• Scala adds certain classes of offenses:
– Infix notation (a.k.a dot-free syntax)
– Symbolic operators
case class Geo(lat: Double, long: Double) {
def distance(other: Geo): Double = // ...
}
val (center, loc): Geo = // ...
if (centre.distance(loc) <= radius)
Some(loc) else None

Naming Things
def distanceFrom(other: Geo): Double = // ...
}
if (loc distanceFrom center <= radius)
Some(loc) else None

Naming Things
def <->(other: Geo): Double = // ...
}
if (loc <-> center <= radius)
Some(loc) else None
Why would you do that?!

Naming Things
• There are worse offenders. Take Dispatch:
import dispatch.Http
import Http._
val server = url("http://example.com")
val headers = Map("Accept" -> "application/json")
Http(server >>> System.out) // GET
Http(server <:< headers >>> System.out) // GET
Http(server << yourPostData >|) // POST

Naming Things
• There are worse offenders. Take scalaz:
def s[A](a: A) = a.success[List[String]]
val add3 = (x: Int) =>
(y: Int) =>
(z: Int) => x + y + z
val res = (7) <*> (s(8) <*> (s(9) ∘ add3))
assert(res == s(24))

Stringly Typed
“Used to describe an implementation
that needlessly relies on strings when
programmer & refactor friendly options
are available.”
-- Coding
Horror

Stringly Typed
• Examples:
– Passing dates as strings
– Carrying unparsed data around
– Using empty strings instead of Options
case class Person(name: String, created: String)
def resolveConflict(p1: Person, p2: Person): Person = {
val c1 = dateParser.parse(p1.created)
val c2 = dateParser.parse(p2.created)
if (c1 compareTo c2 > 0) p1 else p2
}
1. Parser needs to be well-known
2. Error handling all over the place
3. What’s with all the boilerplate?

Stringly Typed
• Examples:
case class Person(name: String, location: String)
def nearest(to: Person, all: List[Person]): Person = {
val geo: Point = Point.parse(to.location)
all.minBy(p => geo.distanceTo(Point.parse(p.location)))
}
1. Inefficient (space/time)
2. Error handling all over the place
3. What’s with all the boilerplate?

Stringly Typed
• Examples:
case class Person(name: String, location: Point)
def nearest(to: Person, all: List[Person]): Person =
all.minBy(p => to.location distanceTo p.location)1. Efficient (only parsed once)
2. Sane error handling
3. Zero boilerplate!

Stringly Typed
• Examples:
case class Person(firstName: String, lastName: String)
def render(p: Person): String =
s"""
|<div id='first-name'>${p.firstName}</div>
|<div id='last-name'>${p.lastName}</div>
""".stripMargin
1. Nothing enforces emptiness check!
2. Scala has a great type for these :-)

Collective Abuse
• Scala has a massive
collection library
• Loads of built-ins too
– Case classes
– Functions and partials
– Tuples, tuples, tuples
• Fairly easy to abuse

Collective Abuse
• Common anti-patterns:
– Too many inline steps
– Tuple overload
val actors: List[(Int, String, Double)] = // ...
def bestActor(query: String) =
actors.filter(_._2 contains query)
.sortBy(-_._3)
.map(_._1)
.headOption
1. What does this even do?!
2. How does data flow here?

Collective Abuse
– Tuple overload
def bestActor(query: String) = {
val matching = actors.filter(_._2 contains query)
val bestByScore = matching.sortBy(-_._3).headOption
bestByScore.map(_._1)
} Name intermediate steps!

Collective Abuse
– Tuple overload
def bestActor(query: String) =
actors.filter(_._2 contains query)
.sortBy(-_._3)
.map(_._1)
.headOption
What’s with all these
underscores?

Collective Abuse
– Tuple overload
case class Actor(id: Int, name: String, score: Double)
def bestActor(query: String, actors: List[Actor]) =
actors.filter(_.name contains query)
.sortBy(-_.score)
.map(_.id)
.headOption
Scala classes are cheap.
Use them.

Scoping
• Correct scoping is incredibly
important!
–Separation of concerns
–Code navigation and discovery
–Reduced autocompletion noise

Scoping
• Scala offers an
impressive toolbox:
– Nested scopes
– Companion objects
– Traits
– Visibility modifiers
– Type classes

Scoping
class User(var name: String,
var age: Int,
initialStatus: UserStatus = New) {
private var _status = initialStatus
def status = _status
def delete(): Unit = {
_status = Deleted
Mailer.notify(Mailer.userDeletion, this)
}
}
Mutable data ⇒ Boilerplate
SoC broken!

EXAMPLE TIME!
https://github.com/holograph/scala-refactoring

Scoping
• Lessons learned:
–Keep logic and data separate
–Case classes are your friends!
–Add “aspects” via type classes

Scoping
• Rules of the road:
–Keep your public API small
–Make everything else private
–Put helpers in companions
–… or via implicit extensions

Speaking Scala: Refactoring for Fun and Profit (Workshop)

Recommended

More Related Content

What's hot (20)

Similar to Speaking Scala: Refactoring for Fun and Profit (Workshop) (20)

More from Tomer Gabel (20)

Recently uploaded (20)

Speaking Scala: Refactoring for Fun and Profit (Workshop)

Editor's Notes