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.
Git
a distributed revision control / software configuration management project created by Linus Torvalds , initially for the Linux kernel development.

The Full Article
Read the article at:
http://stubbisms.wordpress.com/2008/02/22/my-foray-into-the-world-of-scala/
More Scala links
scala-lang.org
Thanks for listening!

http://stubbisms.wordpress.com	146
http://www.slideshare.net	4
http://www.linkedin.com	4
url_unknown	1
http://webcache.googleusercontent.com	1

Scala Language Intro - Inspired by the Love Game

by astubbs

Accessibility

Categories

Upload Details

Usage Rights

5 Embeds 156

Statistics

Scala Language Intro - Inspired by the Love Game Presentation Transcript