Scala Language Intro - Inspired by the Love Game

A brief Scala introduction… Or – LoveGame in 4 lines of code… Move over Java, here comes Scala…

Some questions…

Please ask questions if you are curious! – Interactive conversation!

43 slides and counting – less than two minutes per slide, so we’ll be lucky! Just how keen are you?

Who knows or has used a functional language before?

Who has heard of Scala? Erlang, Lisp, Scheme?

Who knows what a POM is? (not pom poms ;)

I had tried out Groovy (Grails ++) but…

I kept hearing something called Scala mentioned with a lot of respect, wanted to give it a go, just needed an excuse!

Quick love game run through

Who knows what the love game is?

Going to demonstrate the language through writing an algorithm

Demonstrate on the board

The Love Game

We will start off by going over the Love Game java pseudo code…

( I actually had trouble fitting it all onto the slide…!!)

Java - LoveGame

DISPLAY argument 0 + “ “ + argument 1 + “ “ + argument 2 + “ “ + argument 3 + “ “ + argument 4

FORMAT bothNames = argument 0 + argument 1 + argument 3 + argument 4

CHANGE bothNames toLowerCase()

FORMAT compWord = argument 2

CHANGE compWord toLowerCase()

//Creates two character arrays to enable comparison.

CHANGE FORMAT bothNames to character array bothNamesArray

CHANGE FORMAT compWord to character array compWordArray

//Creates an Integer array to store count results

FORMAT Integer Array tallyArray = new Integer Array [compWord.length]

FORMAT tallyArrayPointer = 0

FORMAT matchCounter = 0

//While loop counts the occurrences of each letter.

PROCESS WHILE tallyArrayPointer is less than compWord.length

PROCESS FOR i = 0 ; i is less than bothNames.length; increment i

FORMAT char nameLetter = element i in array bothNamesArray

FORMAT compLetter = element tallyArrayPointer in array compWordArray

IF nameLetter = compLetter

THEN increment matchCounter

ENDIF

tallyArray[tallyArrayPointer] = matchCounter

END FOR

RESET matchCounter

INCREMENT tallyArrayPointer

END WHILE

Java – LoveGame 2

DECLARE tallyCounter

DECLARE totalAdder

//Calculates the percentage compatibility by taking consecutive elements in the array and

//adding them together.

PROCESS WHILE the third element of tallyArray is not equal to -1

RESET tallyCounter

PROCESS WHILE tallyCounter is less than length of tallyArray -1 & tallyArray[tallyCounter+1] is not equal to -1

totalAdder = tallyArray[tallyCounter] + tallyArray[tallyCounter + 1]

tallyArray[tallyCounter] = totalAdder

INCREMENT tallyCounter

END WHILE

tallyArray[tallyCounter] = -1

END WHILE

DECLARE finalPercentage = (1st element of tallyArray + 2nd element of tallyArray) * 2

DISPLAY Calculated compatibility = finalPercentage %

Scala - LoveGame

Most of this improvement is due to being able to write in a functional manner vs the imperative style of looping and state manipulation

We will now elaborate…

The Love Game in 4 lines of code…

var loves = "loves" . toList map ( x => "roger federer maria sharapova" . toList count ( x == _ )) while (loves . length > 1) loves = loves zip ( loves tail ) map { x => x . _1 + x . _2 } println ( "3 line compatibility = " + loves . head * 2 + " %" )

History

Scala was created at the École Polytechnique Fédérale de Lausanne (EPFL) in 2001 by Martin Odersky .

It was released publicly on the Java platform in January 2004, and on the .NET platform in June the same year. A second version of the language was released in March 2006.

General purpose

Express common programming patterns in a concise , elegant , and type-safe way

Stands for “scalable language.”

Designed to grow with the demands of its users.

Wide range of programming tasks, from small scripts to building large systems.

Smoothly integrates features of object-oriented and functional languages.

Interoperable with Java . Both ways.

Aims to make the most common case, easy.

It is both a scripting language and a compiled one.

Imutability and lack of side effects are key to distributed paralleism which are features of functional languages - a modern issue facing IT today with multi core process.

So - compatibility, brevity, high-level abstractions

Woah. (Scala Features)

Scala is object-oriented

Everything is an object!

every value, even primitives, are an object

Every function is an object

Most operators are actually methods! (operator overloading)

2 * (4 + 6) is actually compiled to (4.+(6)).*(2)

Types and behaviour of objects are described by classes and traits

Multiple inheritance solution with mixins of traits

Strong type system – type inference, generics

singleton objects,

Traits

Uniform access principle - “…client code should not be affected by a decision to implement some attribute as a field or as a method.”

Scala is functional

every function is a value

Higher-order functions

Anonymous functions

Function currying / partial functions

(multiple parameter lists)

Lazy evaluation

Infinite ranges

built-in support for pattern matching

Scala is statically typed

Not dynamic – No speed trade off’s (Compared to Groovy and Ruby), but less flexible at runtime (can be argued either way)

But - Local type inference mechanism – don’t need to specify types if they can be inferred

Generics (parameterised types)

Scala is extensible (scalable)

Implicit type conversions

Allows language extensions - empowers you to create new language constructs

The much beloved “Pimp my Library pattern”

Unique combination of language mechanisms makes it easy to smoothly add new language constructs in the form of libraries

Interoperates with Java and .NET (.NET support is ‘rough’ atm)

Optional semi colons, often option parenthesis and ‘dots’

Built in language support for XML processing through natural extention of pattern matching

Great community

Active mailing list – Martin himself replied to my query about Regex Parsers

Recursive version

For demonstration purposes, we will work with my original recursive (slightly longer) version

val initialList = "loves" . toList . map ( x => "roger federer maria sharapova" . toList . count ( x == _ ))

def loveReduce ( numbers : List [ Int ]): Int = numbers match {

case head :: Nil => head * 2

case _ => loveReduce ( numbers . zip ( numbers . tail ). map { case ( a , b ) => a + b })

}

println ( "Compatibility = " + loveReduce ( initialList ) + " %" )

Line by line… The Map Function and Higher-Order Functions

val initialList = "loves" .toList.map( F(x) )

[ 1, 2, 3, 4]

F(x) ------ 

[ f(1), f(2), f(3), f(4) ]

If F(x) = x^2 we get :

[ f(1), f(4), f(9), f(16) ]

F(x) = "roger federer maria sharapova" .toList.count( H(y,x) )

H(y,x) = y == x

val initialList = "loves" .toList.map( x => "roger federer maria sharapova" .toList.count( y => y == x ))

Method Signatures

public int loveReduce(List<Integer> numbers) {…}

def loveReduce (…)…

def loveReduce ( numbers : List [ Int ]): Int …

(Need to specify return type only for recursive functions, otherwise the compiler invokes the type inference mechanism)

def loveReduce ( numbers : List [ Int ]): Int = numbers match {…}

Don’t need surrounding braces as it’s a single statement

Recall – Java Case statements

// checks if a number between 1 and 10 is prime

int number = 4;

switch ( number ) {

case 1 : return true ;

default : return false ;

}

Recall – Java Case statements

If each case statement doesn’t return, need to also include break statements to prevent unwanted fall through

switch ( number ) {

case 1 : object . operation1 ( number );

break ;

break ;

break ;

break ;

break ;

default : object.defaultOp ( number );

}

Pattern Matching in Scala – Java case statements on steroids

Generalised form of case statement

But more powerfull

No ‘fall through’ (common case)

number match {

case 1 => return true;

case _ => return false; //similar to Java’s default case

}

Case statements in Scala

But we can do better…

Drop the semicolons, of course

Drop the return statements

Again, scala’s type inference kicks in – return value of function is simply last resolved statement

number match {

case 1 => true

case 2 => true

case 3 => true

case 5 => true

case 7 => true

case _ => false

}

Clean eh?

Pattern matching

List constructor – the ‘cons’ notation – “::”

head :: tail // matches 1 or more (can also use foo :: bar )

foo :: 2 // 2 element list where 2nd element is integer 2

head :: Nil // Nil (is an object – extends List) represents an empty list – matches 1 element list

x :: xs // matches 1 or more

Nil and :: are actually case Classes!

remember, there is nearly no restriction on characters used for class and method names etc

Any method which takes a single parameter can be used as an infix operator – but :: (cons) when used in pattern matching is a special case

That is, the infix operator “::” here, is treated as a constructor pattern ::(foo, bar)

From scala-lang.org: Case classes are regular classes which export their constructor parameters and which provide a recursive decomposition mechanism via pattern matching .

Checks the entire tree of the objects match

Can do things like: case Foo ( x , Bar ( y )) if x == y => true

numbers match {

case _ => {…}

}

Recursion in Functional Scala

Who can describe what a recursive function is?

Recursion in computer programming defines a function in terms of itself.

Recursion: *see Recursion .

def loveReduce ( ... )...{

...

... loveReduce ( g(x) )

}

Our reduce function

For g(x) we need to return a list one element smaller in order for our recursion to work (i.e. reduce )

Step 1

numbers.zip(numbers.tail)

Step 2

.map{ x => x._1 + x._2 }

Nicer syntax – using a match expresion in place of a function literal

.map{ case (a,b) => a + b }

“ A match expression can be used anywhere a function literal can be used. Essentially, a match expression is a function literal, only more general.”

Recursion in Functional Scala

loveReduce(numbers.zip(numbers.tail)

.map{ case (a, b) => a+b})

Each call, calls loveReduce, with a list one element smaller (due to the zip call)

Putting it all together -> Recursion

def loveReduce ( numbers :List [ Int ]) :Int =

numbers match {

case _ => loveReduce ( numbers . zip ( numbers . tail )

. map { case ( a , b ) => a + b })

}

NB: Don’t need surrounding curly braces because it’s a single statement

Java - LoveGame

DISPLAY argument 0 + “ “ + argument 1 + “ “ + argument 2 + “ “ + argument 3 + “ “ + argument 4

FORMAT bothNames = argument 0 + argument 1 + argument 3 + argument 4

CHANGE bothNames toLowerCase()

FORMAT compWord = argument 2

CHANGE compWord toLowerCase()

//Creates two character arrays to enable comparison.

CHANGE FORMAT bothNames to character array bothNamesArray

CHANGE FORMAT compWord to character array compWordArray

//Creates an Integer array to store count results

FORMAT Integer Array tallyArray = new Integer Array [compWord.length]

FORMAT tallyArrayPointer = 0

FORMAT matchCounter = 0

//While loop counts the occurrences of each letter.

PROCESS WHILE tallyArrayPointer is less than compWord.length

PROCESS FOR i = 0 ; i is less than bothNames.length; increment i

FORMAT char nameLetter = element i in array bothNamesArray

FORMAT compLetter = element tallyArrayPointer in array compWordArray

IF nameLetter = compLetter

THEN increment matchCounter

ENDIF

tallyArray[tallyArrayPointer] = matchCounter

END FOR

RESET matchCounter

INCREMENT tallyArrayPointer

END WHILE

DECLARE tallyCounter

DECLARE totalAdder

//Calculates the percentage compatibility by taking consecutive elements in the array and

//adding them together.

PROCESS WHILE the third element of tallyArray is not equal to -1

RESET tallyCounter

PROCESS WHILE tallyCounter is less than length of tallyArray -1 & tallyArray[tallyCounter+1] is not equal to -1

totalAdder = tallyArray[tallyCounter] + tallyArray[tallyCounter + 1]

tallyArray[tallyCounter] = totalAdder

INCREMENT tallyCounter

END WHILE

tallyArray[tallyCounter] = -1

END WHILE

DECLARE finalPercentage = (1st element of tallyArray + 2nd element of tallyArray) * 2

DISPLAY Calculated compatibility = finalPercentage %

Scala - LoveGame

Note the optional ‘.’ notation

Which do you think will be easier to maintain?

Any questions?

The Love Game in 4 lines of code…

var loves = "loves" . toList map ( x => "roger federer maria sharapova" . toList count ( x == _ ))

while ( loves . length > 1 )

loves = loves zip ( loves tail ) map { x => x . _1 + x . _2 }

println ( "3 line compatibility = " + loves . head * 2 + " %" )

For the cynics out there… smaller Java implementation

public static int loveMatch ( String name1 , String name2 , String compWord ) {

int [] tally = new int [ compWord . length ()];

for ( char c : ( name1 + name2 ). toCharArray ())

for ( int t = 0 ; t < tally . length ; t ++)

if ( c == compWord . charAt ( t )) tally [ t ]++;

for ( int i = tally . length - 1 ; i >= 0 ; i --)

for ( int j = 0 ; j < i ; j ++)

tally [ j ] += tally [ j + 1 ];

return tally [ 0 ] * 2 ;

}

And for the side ball….

C#.NET LINQ

var loves = “ loves ” . Select ( x => “ roger federer maria sharapova ” . Count ( c => x == c )). ToList ();

while ( loves . Count > 1 )

loves = Enumerable . Range ( 0 , loves . Count - 1 ). Select ( i => loves [ i ] + loves [ i + 1 ]). ToList ();

Console . WriteLine ( loves . Single () * 2 );

More Scala to come…

Pimp my library!

Implicit conversion functions

Examples:

MyRichString

E.g. JScience interface

Measure length = Measure .valueOf(50, SI .CENTI( SI .METER)).plus( Measure .valueOf(25.0, SI .METER));

Measure lengthInCentimeters = length .to( SI .CENTI( SI .METER));

System.out .println ( "length in centimeters is " + lengthInCentimeters.getEstimatedValue());

VS

var len = 50 .centimeters + 25 .meters

println(" length in centimeters is " + len)

More Scala to come…

Class properties VS instance variables

Static?

Currying

the technique of transforming a function that takes multiple arguments into a function that takes a single argument (the other arguments having been specified by the curry).

Advanced Pattern Matching and Case Classes

Actors Library

concurrent processes that communicate by exchanging messages.

Combinator Parsing

Define language parsers out of context free grammar definitions

8 * ( 4 + 2 )

expr ::= term { '+' term | ‘-’ term}.

term ::= factor { '*' factor | '/' factor}.

factor ::= numericLit | '(' expr ')'.

Combinator Parsing

object ArithmeticParsers extends StandardTokenParsers {

lexical . delimiters ++= List ( "(" , ")" , "+" , "-" , "*" , "/" )

def expr : Parser [ Any ] = term ~ rep ( "+" ~ term | "-" ~ term )

def term = factor ~ rep ( "*" ~ factor | "/" ~ factor )

def factor : Parser [ Any ] = "(" ~ expr ~ ")" | numericLit

}

val tokens = new lexical . Scanner ( args ( 0 ))

println ( args ( 0 ))

println ( phrase ( expr )( tokens ))

This of course also parses ( 36 / 8 * ( 4 + 2 ) ) / ( ( 5 – 3 ) * 6 )

Combinator Parsing

More complex and practical example:

(buy 100 IBM shares at max USD 45, sell 50 CISCO shares at min USD 25, buy 100 Google shares at max USD 800) for trading_account "SSS1234"

http://debasishg.blogspot.com/2008/04/external-dsls-made-easy-with-scala.html

Combinator Parsing

// ClientOrder.java

public class ClientOrder {

public enum BuySell {

BUY ,

SELL

}

private String accountNo ;

private List < LineItem > lineItems = new ArrayList < LineItem >();

// LineItem.java

public class LineItem {

private final String security ;

private final int quantity ;

private final ClientOrder . BuySell bs ;

private final int price ;

public LineItem ( String security , int quantity , ClientOrder . BuySell bs , int price ) {

this . security = security ;

this . quantity = quantity ;

this . bs = bs ;

this . price = price ;

Properties / Class Parameters

Scala’s concise syntax

this is Java

class MyClass {

private int index ;

private String name ;

public MyClass ( int index , String name ) {

this . index = index ;

this . name = name ;

}

}

In Scala, you would likely write this instead:

class MyClass ( index : Int , name : String )

Implicit Conversions (and mixins with traits)

class MyRichString (str: String ) {

def countOccurances (haystack: String) =

str.toList.map( x => haystack.toList.count(x == _ ))

}

trait MyConversions {

implicit def string2MyRichString (str: String) = new MyRichString(str)

}

object MyConversionsTest extends Application with MyConversions {

val m = "cow"

println(m.countOccurances("o"))

}

Working with XML with language level support

Consider the following XML document:

<html>

<head>

<title> Hello XHTML world </title>

</head>

<body>

<h1> Hello world </h1>

<p><a href = "http://scala-lang.org/" > Scala </a> talks XHTML </p>

</body>

</html>

This document can be created by the following Scala program:

val page =

<html>

<head>

<title> Hello XHTML world </title>

</head>

<body>

<h1> Hello world </h1>

<p><a href = "scala-lang.org" > Scala </a> talks XHTML </p>

</body>

</html> ;

println(page.toString())

It is possible to mix Scala expressions and XML:

object XMLTest2 extends Application {

import scala . xml . _

val df = java . text . DateFormat . getDateInstance ()

val dateString = df . format ( new java . util . Date ())

def theDate ( name : String ) =

< dateMsg addressedTo ={ name }>

Hello , { name }! Today is { dateString }

</ dateMsg >;

println ( theDate ( "John Doe" ). toString ())

}

Actors and Concurrency

class Ping ( count : int , pong : Actor ) extends Actor {

def act () {

var pingsLeft = count - 1

pong ! Ping

while ( true ) {

receive {

case Pong =>

if ( pingsLeft % 1000 == 0 )

Console . println ( "Ping: pong" )

if ( pingsLeft > 0 ) {

pong ! Ping

pingsLeft -= 1

} else {

Console . println ( "Ping: stop" )

pong ! Stop

exit ()

}

class Pong extends Actor {

def act () {

var pongCount = 0

while ( true ) {

receive {

case Ping =>

if ( pongCount % 1000 == 0 )

Console . println ( "Pong: ping " + pongCount )

sender ! Pong

pongCount = pongCount + 1

case Stop =>

Console . println ( "Pong: stop" )

exit ()

val pong = new Pong

val ping = new Ping ( 100000 , pong )

ping . start

pong . start

With the advent of multi-core processors concurrent programming is becoming indispensable.

Actors are basically concurrent processes that communicate by exchanging messages, instead of sharing state.

Companion objects and Static

Singleton and Static considered harmful

Static methods cannot be polymorphic

Inheritance problems

So - all static members are now grouped in their own ‘object’

Scala’s “companion ‘object’” (singleton object)

More and more and more….

Nested Functions

By-name parameters

Lazy evaluation

Logging – no more stupid ( if ( log.isEnabled() ) protection! )

Private packages

LiftWeb (Rails/Grails like web app for Scala)

The Option type – optional values – Some or None

First-class Properties coming…

Properties are objects (OO sense)

Govern access to a (possibly calculated) field.

Properties can have other methods in addition to get/set logic, such as registering event listeners.

Writing new control structures

val file = new File ( "date.txt" )

withPrintWriter ( file ) {

writer => writer.println ( new java.util.Date )

}

More Technologies are out there!

Expand your mind!

Online Ajax HelpRequestList program in 9 lines!!

Groovy on Grails

Maven the modular build system Connoisseur!

Groovy Builder and G-Strings

Groovy Command Line Interpreter

Groovy Wicket builder

Polygot programming

a computer program or script written in a valid form of multiple programming languages , which performs the same operations or output independently of the programming language used to compile or interpret it.