Porting Java To Scala

>
<----
--------->
<----
>

DEVELOPING THE SCALA BINDINGS FOR
THE FLY OBJECT SPACE

Channing Walton

Nigel Warren
channing.walton@casualmiracles.com nige@zink-digital.com

http://www.casualmiracles.com/

CM, Java experience, CRE, UCL
Presentation about my experience porting from Java to Scala

INTRODUCTION

State safe co-ordination and communication between
distributed system components.


SPACES
Tuple Spaces - Linda (a coordination language)

in - put a tuple into a space

rd – get a copy of a tuple from the space

out – remove tuple from the space

Subsequently …

Java Spaces - Jini – Java

Rinda – Ruby

PyLinda – Python
etc., etc.


FLY
Fly is an ‘Object Space’

Network wide - Object level - Storage and Matching

Matching – by Object Templates

Object Serialisation – Native to a language or language neutural

Leasing – Information and resources have prescribed lifetimes


FLY PRIME INTERFACE
public interface FlyPrime {

long
write(Object entry, long leaseTime);

Object
read(Object template, long waitTime);

Object
take(Object template, long waitTime);

}


DESIGN DIAMOND
Minimise Interface

Complexity

Minimise Uses


FLY SPACE DESIGN
Minimal But Complete Interface Write
Read
Take

Threading
Object Locking
Distribution
Matching
Expiring

Pthreads
Minimal Use of Sockets
OS interfaces Malloc - Free


FLY SPACE INTERFACE HIERARCHY
Fly

MultiFly NotiFly
writeMany notifyWrite
readMany notifyTake
takeMany

FlyPrime
write
read
take


FLY SCALA

Scala Application Scala Application
Client Client

Scala Space
Scala Space Interface
Interface

Scala Binding Scala Binding

Fly Server


FROM JAVA TO SCALA

• Syntactic Conversion

• Idiomatic API

• Idioms Internally

• Actors

• Java and Scala Compared

• What Next?

SYNTACTIC
public interface NotiFly extends FlyPrime {
boolean notifyWrite(Object template, NotifyHandler handler, long leaseTime);
boolean notifyTake(Object template, NotifyHandler handler, long leaseTime);
}

trait NotiFly extends FlyPrime {
def notifyWrite(template: AnyRef, handler: NotifyHandler, leaseTime: Long): Boolean
def notifyTake(template:AnyRef, handler:NotifyHandler, leaseTime:Long):Boolean
}


SYNTACTIC
public static void main(String[] args) throws Exception { def main(args: Array[String]) {

FileInputStream f = new FileInputStream(new File(args[0])); val f = new FileInputStream(new File(args(0)));
DataInputStream dis = new DataInputStream(f); val dis = new DataInputStream(f);

StatsDecoder decoder = new StatsDecoder(); val decoder = new StatsDecoder();

long time = dis.readLong(); var time = dis.readLong();
while ( true ) { while (true) {
int size = dis.readInt(); val size = dis.readInt();
StatsBean [] beans = decoder.getStatsArray(dis); val beans = decoder.getStats(dis);
Stats.writeStats(beans); StatsPrinter.writeStats(beans);
System.out.println("--------------"); System.out.println("--------------");
long nextTime = dis.readLong(); val nextTime = dis.readLong();
Thread.sleep(nextTime-time); Thread.sleep(nextTime - time);
time = nextTime; time = nextTime;
} }
} }


IDIOMS - OPTION

An Option represents an optional value

Two subclasses: Some and None

Java has … null


Experiment with Options in Java later

IDIOMS - OPTION

trait FlyPrime {
def read[T <: AnyRef](template: T, waitTime: Long): Option[T]
}

fly.read(template, 0L) match {
case None => {
println("No ball in play")
serveBall(fly)
println("Served Ball - Please start a Pong")
}
case Some(gameBall) => {
println("Received ball - game on!")
returnBall(fly, gameBall)
}
}


pattern matching - scala can extract values from the matching pattern -
Some(ball)
no types

IDIOMS - OPTION

trait FlyPrime {
def read[T <: AnyRef](template: T, waitTime: Long): Option[T]
}

fly.read(template, 0L) match {
case None => // do nothing
case Some(gameBall) => doSomething(gameBall)
}

fly.read(template, 0L).map((x:T) => doSomething(x))

fly.read(template, 0L).map(doSomething(_))


do nothing for none - verbose to use pattern matching
(x:T) => doSomething(x) is a first class function

ASIDE

Options can be implemented in other languages

Clumsy in Java but still useful

An experiment:

Problems exposed where null was not expected

Clarify business logic and behaviour


IDIOMS - RETURN VALUES
int iterations = 10000;
if (args.length > 0) iterations = Integer.parseInt(args[0]);

val iterations = if (args.length > 0) args(0).toInt else 10000

def urlFor(path: String) =
try {
new URL(path)
} catch {
case e: MalformedURLException => new URL("http://www.scala-lang.org")
}


pattern matching for exceptions
exceptions are runtime

IDIOMS - FILTERING
public Collection<FlyServerRep> getMatchingReps(String [] tags) {
Collection matched = new ArrayList<FlyServerRep>();
for (FlyServerRep rep : reps.values()) {
if (rep.tagsMatch(tags)) {
matched.add(rep);
}
}
return matched;
}

def getMatchingReps(tags:Array[String]):Collection[FlyServerRep]
= reps.values.filter((rep:FlyServerRep) => rep.tagsMatch(tags)).toList

def getMatchingReps(tags:Array[String]):Collection[FlyServerRep]
= reps.values.filter(_.tagsMatch(tags)).toList


filter items from a collection

IDIOMS - COMPREHENSIONS
public StatsBean[] getStatsArray(DataInputStream dis) throws IOException {
long statsCount = dis.readLong();
StatsBean [] stats = new StatsBean[(int)statsCount];
for (int i = 0; i < statsCount; i++) {
stats[i] = StatsBean.makeBeanFromStream(dis);
}
return stats;
}

def getStats(dis: DataInputStream): Seq[StatsBean] =
for (i <- 0 until dis.readLong().toInt) yield StatsBean.makeBeanFromStream(dis)


Create an array of items
for comprehension - iterate over something collecting results of the
expression after yield

FOR COMPREHENSION

Syntax: for ( seq ) yield e

Where seq is a sequence of generators, definitions and filters

e evaluated for each binding of generators and definitions

Return a sequence of evaluated values


generator— roughly speaking, an expression that pulls an item from a
collection
easier to show an example...

FOR COMPREHENSION

val names = for {

p <- persons // a generator

n = p.name // a deﬁnition

if (n startsWith "To") // a ﬁlter

} yield n


p bound to each item in persons

IDIOMS - FOLD
/**
* @return the lease of the last entry written
*/
public long writeMany(Collection entries, long lease) {
long lastLease = 0;
for (Object entry : entries) {
lastLease = codec.write( entry, lease );
}
return lastLease;
}

def writeMany(entries: Collection[AnyRef], lease: Long): Long
= (0L /: entries){(previousLease, nextEntry) => codec.write(nextEntry, lease)}


method writes entries to the space and returns the lease of the last item
written
function takes two parameters, ignores previousLease, returns the result of
codec.write
good use of fold?

IDIOMS - ACCESSORS
public class FlyServerRep { class FlyServerRep(var flyAddr:InetAddress, var flyTags:Array[String])

private String [] flyTags;
private InetAddress flyAddr;

FlyServerRep(InetAddress addr, String[] tags) {
flyAddr = addr;
flyTags = tags;
}

public String[] getFlyTags() {
return flyTags;
}

public void setFlyTags(String[] flyTags) {
this.flyTags = flyTags;
}

public InetAddress getFlyAddr() {
return flyAddr;
}

public void setFlyAddr(InetAddress flyAddr) {
this.flyAddr = flyAddr;
}
}

var on constructor parameters, scala generates accessor methods: x and x_

IDIOMS - FUNCTIONS
public Object read(Object template, long timeout) { public Object take(Object template, long timeout) {
Object ret = codec.read(template, 0); Object ret = codec.take(template, 0);
.... ....
while(...) while(...)
ret = codec.read(template, 0); ret = codec.take(template, 0);

def read[T <: AnyRef](template: T, timeout: Long): Option[T] = retrieve(template, timeout, codec.read)
def take[T <: AnyRef](template: T, timeout: Long): Option[T] = retrieve(template, timeout, codec.take)

private def retrieve[T](template: T, timeout: Long, m: (T, Long) => Option[T]): Option[T] = {
var ret = m(template, 0L)
....
while(...)
ret = m(template, 0)


CONTROL ABSTRACTION
System.out.println("Processing " + iterations + " writes and reads");
long start = System.currentTimeMillis();
for (int i = 0; i < iterations; i++) {
space.write(object, 1000);
space.read(template, 0L);
}
long end = System.currentTimeMillis();
ﬂoat timeInSeconds = (ﬂoat) (end - start) / 1000.0f;
System.out.println("Which took " + timeInSeconds + " secondsn");


CONTROL ABSTRACTION
Time("Processing " + iterations + " writes and takes", iterations) {
space.write(obj, 1000)
space.take(template, 0L)
}

object Time {
def apply(name: String, iterations: Int)(block: => Unit): Unit = {
println(name)
val start = System.currentTimeMillis()

for (i <- 0 until iterations) block

val end = System.currentTimeMillis()
val timeInSeconds = (end - start) / 1000.0F
println("Completed in " + timeInSeconds + " secondsn")
}
}


apply methods have special meaning - invoked using a method-less
expression
eg Time (... is the same as Time.apply(...

CONTROL ABSTRACTION
def notifyWrite(template: AnyRef, leaseTime: Long)(block: => Unit): Boolean
}

ﬂy.notifyWrite(template, LEASE){
println("Block Template matched!")
}


ACTORS

Scala’s primary concurrency construct

Concurrent processes communicating by exchanging messages

Scala Actor implementation is a library - several of them


ACTORS
def notifyWrite(template: AnyRef, leaseTime: Long, actor: Actor): Boolean
}

import scala.actors.Actor._
val myActor = actor { // factory method taking a block
loop { // we want the actor to keep processing messages
react { // handle messages
case FlyPrime.ACTOR_MESSAGE => println("Actor received a message!")
}
}
}

ﬂy.notifyWrite(template, LEASE, myActor)


JAVA TO SCALA COMPARED
 Java has 1556 LoC, Scala has 934 LoC => 60%

 Core code is about half the size

 Why?

 Most algorithms can be characterised as Searching, Sorting, Filtering,
Mapping, Combining, Counting (Peter Norvig)

 Scala and functional languages provide good abstractions for these

 Java is 2% faster

 Need more comprehensive tests to ﬁnd out why

WHAT NEXT?
 Scala 2.8

 Port from 2.7.7 complete

 Available for 2.8 soon

 Implement the library from scratch?

 Design of existing library is the same as the Java library

 Current version made improvements in the small

 Perhaps a more functional approach would be better?

>
<----
--------->
<----
>

FROM JAVA TO SCALA


2/3 lines of code
could be better

Porting Java To Scala

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Porting Java To Scala

Similaire à Porting Java To Scala (20)

Dernier

Dernier (20)

Porting Java To Scala