Scala on Android

Scala on Android

“All languages are equal, but some
languages are more equal than others”

Jakub Kahovec @kahy
jakub.kahovec@gmail.com

What is Scala ?
“Scala is a modern multi-paradigm
programming language designed to express
common programming patterns in a
concise, elegant, and type-safe way. It smoothly
integrates features of object-oriented and
functional languages”

father of Scala Martin Odersky

16.4.2012 Scala on Android

Who is using it ?
• LinkedIn
– Social Graph represented by 65+
million nodes, 680+ million edges
and 250+ million request per day
• Twitter
– Queuing, Social Graph, People
Search, Streaming – 150 million
tweets per day
• The
Guardian, Novell, Sony, Xerox, ED
F, Siemens etc.

Why Scala ?
• Object-oriented
• Functional
• Statically typed
• Expressive & concise
• Extensible
• Runs on JVM
• Fast


Scala is Object Oriented
• Every value is an object 1.toString()
• Classes, Singleton objects and Traits
– Describe types and behavior of objects
• Mixin-based composition
– Replacement for multiple inheritance
• Operators are simply methods 1.+(2)  1 + 2
• No static methods or fields


Classes
• Can be instantiated into objects at runtime
• Fields and methods are public by default
• Fields and methods share the same namespace
class Person (val firstName: String, var lastName: String) {
private var _age: Int
def name = firstName + " " + lastName
def age = _age
def age_=(newAge:Int) = if (newAge > 0) _age = newAge
}
val person = new Person("Jakub", "Kahovec")
println(person.name) -> "Jakub Kahovec"
println(person.firstName) -> "Jakub"

Singleton objects
• Only a single instance created at runtime
• Initialized the first time some code accesses it
• Standalone vs. companion singletons
object ImageUtil {
def preloadImages( url: String) { … }
def createImageManager() : ImageManager { .. }
}
ImageUtil.preloadImages("http://www.rbw.com/images/")
val imageManager = ImageUtil.createImageManager


Traits
• Encapsulate methods and fields definitions, which can be
reused by mixing them in classes
trait Ordered[A] {
def compare(that : A) : Int
def < (that : A) = (this compare that) < 0
def > (that : A) = (this compare that) > 0
def >= (that : A) = (this compare that) >= 0
def <= (that : A) = (this compare that) <= 0
}

class Animal
trait Furry extends Animal
trait FourLegged extends Animal with HasLegs
trait HasLegs extends Animal
class Cat extends Animal with Furry with FourLegged

Scala is functional
• Every function is a value
• First-class functions
• Anonymous, nested and curried functions
• Pattern matching
• Case classes
• Lazy evaluations
• By-Name parameters


First-class functions
• Function (x: Int) => x + 1
• Functions as values val inc = (x: Int) => x + 1
• Functions as parameters
List(1, 2).map( (x: Int) => x + 1 )
List(1, 2).map( x => x + 1 )
List(1, 2).map( _ + 1 )

• Function as closures
val something = 5
val addSomething = (x: Int) => x + something

Anonymous, nested and curried functions
• Anonymous functions
val inc = (x: Int) => x + 1 inc(6) -> 7
val mul = (x: Int, y: Int) => x * y mul(6, 7) -> 42
val hello = () => "Hello!" hello() -> “Hello!"

• Nested functions
def factorial(i: Int): Int = {
def fact(i: Int, acc: Int): Int = if (i <= 1) acc else fact(i - 1 , i * acc)
fact(i, 1)
}
• Curried functions
def add(x: Int)(y: Int) = x + y add(2)(3) -> 5


Pattern matching
• Matching on any sort of data
def matchAny( a: Any) : Any = a match {
case 1 => "one"
case "two" => 2
case i : Int => "scala.Int"
case <a>{ t }</a> => "Content of <a> " + t
case head :: tail => "Head of the list " + head
case (a, b, c) => "Tuple " + a + b + c
case Person(name,age) => "Name " + name + “,age " + age
case n : Int if n > 0 => "Positive integer " + n
case _ => "default"
}


Case Classes
• To be matched and extracted
abstract class Result
case class ScoreResult( points : Int, wins: Int, loses: Int, draws: Int )
case class TimeResult( bestTime: Long )

def matchResult( r: Result) = r match {
case ScoreResult( points, wins, loses, int) => "Points " + points
case TimeResult( bestTime) => "Best time is " + bestTime
}


Lazy evaluations
• Evaluations performed when first accessed
val normalVal = { lazy val lazyVal = {
println("Initializing normal val") println("Initializing lazy val")
"Normal val" "Lazy val"
} }
"Initializing normal val" println(lazyVal)
println(normalVal) "Initializing lazy val"
"Normal val" "Lazy val"
println(lazyVal)
"Lazy val"


By-Name parameters
• Parameter is not evaluated at the point of
function application, but instead at each use
within the function.
def nano() = { In delayed method
println("Getting nano") Getting nano
System.nanoTime Param: 4475258994017
} Getting nano
def delayed(t: => Long) = { 4475259694720
println("In delayed method")
println("Param: "+t)
t
}
println(delayed(nano()))

Scala is statically typed
• Rich static type system
• Type inference
• Implicit type conversions
• Generic classes
• Structural typing
• Compound types


Scala's type hierarchy


Type inference
• Feeling like dynamic, while being static
val str = "Hello"  val str : String = "Hello"

val num = 5  val num : Int = 5

val list = List(1, 2, 3)  val list : List[Int] = List(1, 2, 3)

def sayHello = "Hello !"  def sayHello : String = "Hello !"


Implicit conversions
• Allow adding methods to existing classes
• Compiler performs “magic” behind the scene

println("How Are You !".countSpaces) // Won’t compile

class MyRichString(str: String) {
def countSpaces = str.count(_ == ' ')
}
implicit def stringToMyRichString(str: String) = new MyRichString(str)

println("How Are You !".countSpaces) -> 2


Generic classes
• Classes parameterized with types
class Stack[T] {
var elems: List[T] = Nil
def push(x: T) { elems = x :: elems }
def top: T = elems.head
def pop() { elems = elems.tail }
}

val stack = new Stack[Int]
stack.push(5)


Structural typing
• Type safe duck typing
class Duck {
def quack = println("Quack !")
}
class Person {
def quack = println("Imitating a duck.")
}

def doQuack( quackable : { def quack } ) = quackable.quack

doQuack( new Duck ) -> "Quack !"
doQuack( new Person ) -> "Imitating a duck ."
doQuack( "StringDuck" ) -> won’t compile


Compound types
• Intersections of object types
trait Callable {
def call() = println("Comes to you")
}
trait Feedable {
def feed() = println("Feeds")
}
class Dog extends Callable with Feedable

def callAndFeed( obj: Callable with Feedable) {
obj.call
obj.feed
}


Scala is expressive & concise
• Type inference var capitals = Map("France" -> “Paris" )
• Semicolon inference capitals += ("Japan" -> “tokio" )
capitals mkString ",“
• Closures as control for ( (country, city) <- capitals)
abstraction capital s+= (country -> (city.capitalize))

• Optional parenthesis List(1, 2, 3) filter isEven foreach println
and dots class Person (var name: String)
• Lightweight classes


Rich Collections Library
• Lists, Maps, Sets, Tuples, Queues, Trees, Stacks
• Immutable collections favored to mutable
• High level operations
val list = List(1 , 2, 3)
list.map( _ + 1) -> List(2, 3, 4)
list.filter( _ < 2 ) -> List(3)
list.exists( _ == 3) -> true
list.reverse -> List(3, 2, 1)
list.drop(1) -> List(2, 3)
… and much more


XML Literals and querying
• Makes XML bearable
val cities = <cities>
<city><name>{ city.name }</name></city>
….
</cities>

cities match {
case <cities>{ cities @ _* }</cities> =>
for (city <- cities) println("City:" + (city "name").text)
}


Concurrency with Actors
• Concurrency demystified with message passing
val mathService = actor {
loop {
react {
case Add(x,y) => reply ( x + y )
case Sub(x, y) => reply ( x - y )
}
}
}
mathService ! Add(4 , 2) -> 6


Scala is extensible
• New language constructs supported smoothly
– By using Curried functions and By-Name parameters
def unless(condition: => Boolean)(body: => Unit) = if (!condition) body
val b = false
if (b) {
println("it's true")
}
unless ( b ) {
println("it's false")
}
"it's false"


Scala runs on JVM and its fast
• Compiled to bytecode and runs on JVM
– Using all JVM goodness

• 100% interoperable with Java
– any Java library can be used ( Android, ORMs etc.)

• Performance usually on a par with Java


Tools support
• Decent tools support and growing
– Standalone compiler: scalac
– Fast background compiler: fsc
– Interactive interpreter shell: scala
– Testing framework: ScalaTest, ScalaCheck
– Documentation : scaladoc
– Build Tool (Simple Build Tool) : sbt
– Packaging system (Scala Bazar) : sbaz
– Plugin for Eclipse IDE: Scala IDE

What is Android ?

“Android is a software stack for mobile devices
that includes an operating
system, middleware and key applications”


Why Android ?
• Rich set of features
• Java programming interface
• Reaching vast amount of users
– 250,000,000 activations
• Google Play - Application market
– Easily Search for, (Buy) and Install an application
– 11,000,000,000 application downloads so far
• Vibrant ecosystem and community

Features
• Application framework
– Enabling reuse and replacement of components
• Optimized graphics
– Powered by a custom 2D graphics library; 3D graphics based on the OpenGL
• SQLite
– For structured data storage
• Media support
– For common audio, video, image formats
• GSM Telephony
• Bluetooth, EDGE, 3G, and WiFi
• Camera, GPS, compass, and accelerometer
• Rich development environment
– Including a device emulator, tools for debugging, memory and performance
profiling, and a plugin for the Eclipse IDE


Android components
• Activity
– Represents the presentation layer of an Android application, roughly
equivalent to a screen
• Views
– User interface widgets, e.g buttons, textfields etc.
• Intent
– Asynchronous messages allowing the application to request
functionality from other components
• Services
– Perform background tasks without providing a user interface
• Content provider
– Provides a structured interface to application data.

Development on Android
• Prepare your development environment
– Download Eclipse IDE
• Download the Android SDK
– Includes only the core SDK tools for downloading the rest
• Install ADT (Android Development Tool) for Eclipse
– To easily set up new project, create UI, debug or export app
• Add more platforms and other packages
– Use SDK Manager to download add-ons, samples, docs etc.
• Create a New Android Project
– Use enhanced Eclipse to develop your Android apps

Development on Android with Scala
• Install Scala IDE for Eclipse
– To write, build, run and debug Scala applications
• Install Eclipse plugin - AndroidProguardScala
– Plumbing all together
• Write your Android application in Scala
• Build your application and deploy it to an
Android device or to an emulator
• Enjoy !

Demo application - Scorepio
• A scoreboard application developed in Scala
on Android
• Check out the QR code you’re going to be
given
• There are 5 beers to be won ;-)


Resources
• Scala's home page:
– http://www.scala-lang.org
• Scala's online interactive shell
– http://www.simplyscala.com
• Programming in Scala book
– http://www.artima.com/shop/programming_in_scala_2ed
• Scala IDE for Eclipse
– http://scala-ide.org/
• Eclipse plugin AndroidProguardScala
– https://github.com/banshee/AndroidProguardScala
• Android developer home page
– http://developer.android.com


Thank you !

Any questions ?


Scala on Android

More Related Content

What's hot (20)

Viewers also liked (6)

Similar to Scala on Android (20)

Recently uploaded (13)

Scala on Android

Editor's Notes