Scala for dummies

MADRID · MAR · 2015
Scala Programming @ Madrid
Scala
David Vallejo & Javier Santos

About us
Javier Santos @jpaniego
«Hay dos formas de programar sin
errores; solo la tercera funciona»
Alan J Perlis
David Vallejo @dvnavarro
«Una expresión regular es una
expresión que no es del todo buena,
pero tampoco del todo mala.»
@borjamonserrano

What’s Scala?
According Wikipedia:
Scala (/ˈskɑːlə/ SKAH-lə)[6] is an object-functional[7] programming language for general software
applications. Scala has full support for functional programming and a very strong static type system. This
allows programs written in Scala to be very concise and thus smaller in size than other general-purpose
programming languages. Many of Scala's design decisions were inspired by criticism over the shortcomings
of Java.[5]

What’s Scala?
According to the official website:

What’s Scala?
According to newbies:

What’s Scala?
● General purpose language that runs on the JVM.
● Martin Odersky
● Multiple Inheritance
● Multi-paradigm: functional & object-oriented
● Typesafe (2011)
● TIOBE (41st position)

Why so fashionable these days?
● Useful tools to build concurrent systems
○ More cores, more concurrency
○ Avoid side effects using functional programming and immutable values
○ Actor paradigm with the toolkit called Akka
● Awesome frameworks and tool-kits: Play Framework, Akka, Spark, Spray ...
● Others
○ Powerful mechanisms for embedding DSL like, for example, implicits
○ The best of functional world and the best of OO world
○ Elegant & concise

Who uses it?

Developer environment
● REPL (Read-eval-print loop)
http://scala-lang.org/download/
● SBT
http://www.scala-sbt.org/
● IDES:
Eclipse http://scala-ide.org/download/sdk.html
Intellij https://www.jetbrains.com/idea/features/scala.html
NetBeans http://wiki.netbeans.org/Scala

Features

val vs var
● Type inference
● var: variables (mutable)
● val: values (immutable)
● lazy vals: Not evaluated until necessary

val vs var
● vals are always immutable?
Stateful objects (mutable collections for example) (watch out with side effects)

Methods/functions
● Type inference
● Only braces means Unit
● No return necessary
● Variable args number (*)

What about class?
● A class may contain
○ attributes (var/val)
○ methods (def)
○ expressions that
will be evaluated
at instantiation time.

What about class?
● A simple class with no parameters

What about class?
● A simple class with parameters

What about class?
● A simple class with parameter accessors

What about abstract class?
● It cannot be instantiated, unless ...

What about case class?
● A case class provides:
○ parameter accessors
○ companion object with apply and unapply
○ extends from Serializable
○ copy method
● ...but it cannot be extended (We can handle that)

What about case class?

Rich interfaces: trait
● Methods can be implemented.
● Multiple inheritance.

Inheritance: mixing in stuff...
● Linearization (Watch out the order)

What about nulls in Scala?
● Use option instead
● Two possible values: Some(t) and None

Options in Scala
● Besides it’s iterable!
● Nice functional methods like fold.

Generics
● For classes and traits

Generics
● For methods

Generics
● Variance: C[T] != C[+T] != C[-T]

Conditional statements: if

Conditional statements: match
● Similar to a Java switch...

● ...except that it’s not only a switch :-)
● Pattern matching.

● So it’s great, but be carefull with

Loop statements: while
● Not very commonly used (vars and so on…)

Loop statements: for
● for-comprehensions: syntactic sugar for

Loop statements: for
● Typical example:
Is this purely functional?

Loops in Scala

Your new friend: fold
● Two signatures: foldLeft and foldRight (iterative vs. recursive)
● Same example:

Other common friends: map
● Convert each element to another (or same) type.
● Example:

Other common friends: flatMap
● Map each element to some monad-like type and flatten them
● Example:

More cool stuff: Type alias
● Useful for specifying anonymous tuple types

More cool stuff: Higher order functions
● Javascript ninjas gonna like…

More cool stuff: Higher order functions

More cool stuff: Infix notation, semicolon inference...
● Allows writing readable code
● Specially useful for DSLs.

More cool stuff: Infix notation, semicolon inference...

More cool stuff: Implicits

More cool stuff: Implicits
● Defined by scope (be careful with ambiguity)
● Specially difficult to trace: use only in very located places

More cool stuff: Self types
● Used for disambiguating with duplicated val/function names

Conclusions
● Steep learning curve
● It's hard to know which is the best way to do something
● Language expanding. More and more Scala enthusiasts.
● Mix the functional world and the OO world :)

scalerablog.wordpress.com
@scalerablog

Scala for dummies

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (16)

Ähnlich wie Scala for dummies

Ähnlich wie Scala for dummies (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Scala for dummies