Six years of Scala and counting

7 years of Scala
and counting
Scala Days Vienna 2017
Scala Vienna May 2016 - manuel.bernhardt.io - @elmanu

6 years of Scala
and counting
Scala Vienna User Group May 2016

Agenda
1. Quick introduction to Scala
2. Learning Scala
3. Using Scala
4. Learnings, reﬂection, observations, impressions
5. Questions

Manuel Bernhardt
• I help companies getting started
with using reactive applications in
their distributed systems
infrastructure
• http://manuel.bernhardt.io

Scala: an introduction

Scala introduction
• ﬁrst version released in 2003
• Martin Oderksy, EPFL
• an estimated more than half a
million Scala developers 1
1
http://www.scala-lang.org/blog/2016/03/14/announcing-the-scala-
center.html

Scala Center
• non-for-proﬁt foundation for Scala
education and community
guidance
• established at EPFL
• founding members: IBM, verizon,
Goldman Sachs, nitro, Lightbend

Favourite Feature tour

case classes
public class User {
private final String name;
private final String surname;
private final Integer age;
public User(String name, String surname, Integer age) {
this.name = name;
this.surname = surname;
this.age = age;
}
public String getName() {
return this.name;
}
public String getSurname() {
return this.surname;
}
public String getAge() {
return this.age;
}
@Override public int hashCode() {
// ...
}
@Override public boolean equals(Object that) {
// ...
}
}

case classes
case class User(name: String, surname: String, age: Int)

case classes
val bob = User("Bob", "Marley", 42)
val namedBob = User(name = "Bob", surname = "Marley", age = 22)
val john = bob.copy(name = "John")

case class
• perfect example of the terseness Scala provides
• hashcode, equals, toString for free
• serializable by default

type inference
val foo = "Bar" // foo: String = Bar
val answer = 42 // answer: Int = 42
val price = 9.99 // price: Double = 9.99
val nums = List(1, 2, 3) // nums: List[Int] = List(1, 2, 3)
val map = Map("abc" -> List(1, 2, 3))
// map: scala.collection.immutable.Map[String,List[Int]] = Map(abc -> List(1, 2, 3))

functions and higher-order
functions
def isMajor(user: User): Boolean = user.age > 18

functions
class UserGroup {
def filter(predicate: User Boolean): List[User] = ...
}

functions
class UserGroup {
def filter(predicate: User Boolean): List[User] = ...
}
userGroup.filter(isMajor) // returns only majors

Learning Scala

How "learnable" is
Scala?
• Shadaj Laddad
• http://shadaj.me
• learned Scala at age 11-12
• talks at Scala Days, OSCON since
2012

How "learnable" is
Scala?
• Coursera courses, 400.000+
participants - highest completation
rate in the industry (10%, which is
high for a MOOC 2
)
• Scala as beginner programming
language at Lund University of
Technology 3
3
https://www.lth.se/english/about-lth/news/news/article/scala-will-be-the-
beginner-programming-language-of/
2
Massive Open Online Course

My learning path
• 2010: started dabbling with Scala
(books, using it in tests, small
projects)
• 2011: discovering Functional
Programming through Javascript.
Using Play Framework 1 with the
Scala module in my 2nd
startup
• 2012: ﬁrst large codebase to
migration from Play 1 to Play 2.0.0
(based entirely on Scala)

My learning path
• 2013: several client projects using Scala
• 2014-2016: architecture, prototyping, design,
implementation, review of various production systems with
Scala, Akka, Play Framework; writing Reactive Web
Applications

My learning path
• estimated 6 months to "click"
• imperative declarative
• mutable, global state immutable, expression-oriented
• longer to grasp or use more advanced concepts
• and how not to shoot myself in the foot with them

Your learning path?
• new Coursera courses by the Scala Center
• https://scala.epﬂ.ch
• try to use Scala for something "real"
• and even if it is just tests in a real project

Using Scala

6 years without one of those
pesky NullPointerException-s

Significantly less
problems at
runtime
• Scala compiler spots a whole
plethora of problems at compile-
time
• leveraged by e.g. Play Framework,
high emphasis on "compiling
everything"
• URLs
• Javascript (Google Clojure

Less code yields
higher maintainbility
(Less is more)

IDE / Editors
• IntelliJ IDEA
• Scala IDE for Eclipse
• ENSIME 5
• emacs, Atom, Sublime Text, vim
5
Enhanced Scala and java Interaction Mode for text Editors

Compiler
• slower than the Java compiler
• but not a problem (anymore) on modern hardware
• especially with incremental compilation
• unless you deep dive into type-level and generic
programming (e.g. shapeless library)
• much more precise than the Java compiler (type-safe ++)

Jobs & Developers

http://appliedscala.com/blog/2016/scala-popularity/

What I've learned
Reflection, Impressions, (Advice)

The Dreyfus model of skill
acquisition

Learning #1
Spend a little time understanding
the language design

Understand Scala's essence
and your life will be easier

Learning #2
Understand the purpose of the
language features

Scala has quite a few language features
because it was designed to be extensible

Don't be that kid

Scala language levels 4
• Level A1: Beginning application programmer
• Level A2: Intermediate application programmer
• Level A3: Expert application programmer
4
http://www.scala-lang.org/old/node/8610

Scala language levels 4
• Level L1: Junior library designer
• Level L2: Senior library designer
• Level L3: Expert library designer
4
http://www.scala-lang.org/old/node/8610

The features you need to build
applications
are not the same
as the ones you need to build
librariesScala Vienna May 2016 - manuel.bernhardt.io - @elmanu

SIP 18: Modularizing language
features
import scala.language.implicitConversions
import scala.language.dynamics
import scala.language.postfixOps
import scala.language.reflectiveCalls
import scala.language.higherKinds
import scala.language.existentials
import scala.language.macros

Incidental complexity
Is this really a problem
specific to Scala?

@SuppressWarnings({"unchecked", "rawtypes"})
@Deprecated
@OneToMany(@HowManyDBADoYouNeedToChangeALightBulb)
@OneToManyMore @AnyOne @AnyBody
@YouDoNotTalkAboutOneToMany // Fightclub, LOL
@TweakThisWithThat(
tweak = {
@TweakID(name = "id", preferredValue = 1839),
@TweakID(name = "test", preferredValue = 839),
@TweakID(name = "test.old", preferredValue = 34),
},
inCaseOf = {
@ConditionalXMLFiltering(run = 5),
}
)
@ManyToMany @Many @AnnotationsTotallyRock @DeclarativeProgrammingRules @NoMoreExplicitAlgorithms
@Fetch @FetchMany @FetchWithDiscriminator(name = "no_name")
@SeveralAndThenNothing @MaybeThisDoesSomething
@JoinTable(joinColumns = {
@JoinColumn(name = "customer_id", referencedColumnName = "id")
})
@DoesThisEvenMeanAnything @DoesAnyoneEvenReadThis
@PrefetchJoinWithDiscriminator @JustTrollingYouKnow @LOL
@IfJoiningAvoidHashJoins @ButUseHashJoinsWhenMoreThan(records = 1000)
@XmlDataTransformable @SpringPrefechAdapter
private Collection employees; // http://annotatiomania.com

Learning #3
Don't forget all about Object
Oriented Programming

class SynchronizationService {
private[services] def synchronizeTeeTimes(
suite: Suite,
dataType: SuiteDataType,
eventuallyByteStream: Future[Enumerator[Array[Byte]]],
removeDocsWithOlderTimestamps: Boolean): Future[Int] = ...
private[services] def synchronizeTournaments(
suite: Suite,
removeDocsWithOlderTimestamps: Boolean): Future[Int] = ...
}

class SynchronizationService {
private def synchronizeGolf[T, S](suite: Suite,
toIndexDocuments: (Suite, Issuer, GolfClub) => Seq[T] => Iterable[S], // function!
indexDocuments: Iterable[S] => Future[Boolean], // function!
countDocuments: CountRequest => Future[Long], // function!
verify: (Int, Long) => Unit, // function!
removeDocsWithOlderTimestamps: Boolean)(implicit format: Format[T]): Future[Int] = ...
}

Learning #4
Don't use every feature as a
hammer

for comprehension
val bobUser: Option[User] = ...
val carlUser: Option[User] = ...
val bobCarlAge: Option[Int] =
for {
bob <- bobUser
carl <- carlUser
} yield bob.age + carl.age

for comprehension from hell
for {
stopWatch <- Future.successful(startedStopWatch)
startTimestampOfSync = DateTime.now()
byteStream <- eventuallyByteStream
suiteDocStream = toDocumentStream[T](byteStream)
chunkedStream = suiteDocStream &> ExtraEnumeratees.chunker(ChunkSize)
indexerSuccessStream = chunkedStream &> indexer
indexerSuccess <- indexerSuccessStream.run(Iteratee.fold(true)(_ && _))
_ <- if (removedDocsWithOlderTimestamps)
waitForElasticSearchToFinishIndexing().map(_ => removeDocsUpsertedBefore(issuer, dataType, startTimestampOfSync))
else
Future.successful(())
count <- waitForElasticSearchToFinishIndexing().flatMap { _ =>
verifyCount(issuer, counter.get(), countDocuments, verify)
}
} yield {
if (!indexerSuccess) error(s"Failed to index $dataType for ${suite.url}")
val duration = scala.concurrent.duration.Duration(stopWatch.getNanoTime, TimeUnit.NANOSECONDS).toSeconds
info(s"Done synchronizing ${counter.get()} $dataType for ${suite.url}, it took $duration s")
count
}

Learning #5
Transitioning to Scala
(for teams)

Don't start a Scala project
with a team comprised
of novice and advanced beginners

Don't start a <XYZ> project
with a team comprised
of novice and advanced beginners

It's all about people
The biggest challenges of transitioning to Scala — or anything new
— are rarely technical. Talented programmers can learn a new
syntax, new concepts, and a new IDE. Rather, change often
brings out the weaknesses in other areas like process and
culture. 6
— Kevin Webber
6
https://medium.com/@kvnwbbr/transitioning-to-scala-d1818f25b2b7#.x1tcfcs58

Building up Scala knowledge in
your team
• culture that emphasizes learning, create time for learning
• code reviews, discussions
• try to get one "Competent" on your team
• even if it's a "hired gun" helping to bootstrap & ensure
best practices (& avoiding pitfalls)
• invest in training (Fast track to Scala, etc.)

Conclusion

Conclusion
embrace Scala's terseness

Conclusion
embrace Scala's terseness
don't forget about the language levels

Thank you!
Questions & Comments ?
• http://manuel.bernhardt.io
• @elmanu

Six years of Scala and counting

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (13)

Similaire à Six years of Scala and counting

Similaire à Six years of Scala and counting (20)

Plus de Manuel Bernhardt

Plus de Manuel Bernhardt (14)

Dernier

Dernier (20)

Six years of Scala and counting