I had fun at OSCON last year, so I decided to go back this year. It’s incredible experience being part of hundreds of developers (more than 2500), who are excited about open source and upcoming technogolies. Though, there were a number of tracks, but I was mainly interested in Mobile Computing, Cloud Computing, No-SQL, and Scala. There were also interesting sessions on Emerging Languages and Hardware Hacking with Arduino, but I didn’t get chance to attend them.
Tutorials Day One
I arrived in Portalnd on Sunday night and the first session I attended on Monday morning was on Android. I saw fair number of Android phones at the conference and people were excited about Android. There was a lot of bashing of Apple, but I won’t get into it. Here are some of the highlights from the Android session:
Android is a specially designed O/S based on Linux that uses a number of open source libraries and custom framework for building mobile applications. It even comes with a command line tool adb that opens shell directly on the device or emulator. Though, Android applications are written in Java but the byte-codes are converted into Dalvik instruction sets (.dex files). Dalvik is a register based Java VM as opposed to Sun’s stack based and uses JavaSE minus Swing/AWT APIs. You use Dalvik generated executable and resources (images, audio, configurations, etc.) to build the application file (APK), which is then signed by self-generated certificate. The best part of Android development is their deployment, which is an order of magnitude easier compare to Apple iOS.
Android SDK
Before developing, you would need to download the Eclipse IDE, Android SDK and then install Eclipse plugin from https://dl-ssl.google.com/android/eclipse/.
Creating Android Device
One of the downside of Android is variations of the capabilities of all Android devices, however you don’t need to own all variations. All you need is to create Android device by giving name, target version, SD card, skin and other hardware limitations. Android comes with emulator as opposed to simulator with iPhone SDK and follows hardware much more closely. On the downside, it takes a long time to start the Android emulator, but on the upside you can emulate call, SMS, and launch multiple emulators, which can other emulators. Note, the android device file definition goes into ~/.android/avd directory.
Hello World
You can create a new project and specify the build target, application name, package name, and main activity class. An activity class represents a controller class, which you define for each screen. Android uses UI to generate layout file (R file). If your application need resources such as images and property files, you store them in res directory. You can also create resource files for storing strings to make your application easily localized for various languages.
Activities
Activities represent screens and are managed by the activity managers. The activity can be in one of five states: starting, running, paused, stopped, and destroyed. The Activity class defines callback methods such as onCreate, onStart, onRestoreInstanceState, and onResume when the state changes.
Intent
Intent represents events or actions, which can be explicit or implicit.
Services
One of the key advantage of Android has been its support of multi-tasking and you can have a background processing using services. Services also have lifecycle, but simpler than activities.
Content Providers
Content providers allow sharing data between applications such as contacts, mediastore, settings, etc.
Broadcast Receivers
These allow pub-sub based mechanism for system events such as SMS messages.
Architecture of Android applications
Here are some of the tips that Marko Gargenta gave when designing application:
Adapters
Android allows easily access large datasets as arrays that can be displayed on the screen.
Logging
Android uses custom libc and Java for Logging and you can add logging as:
Log.debug("ClassName", "button clicked");
You can use “adb logcat” command to view logs, e.g. “adb logcat Twitter:* *:S”
Security Permissions
Any permissions that user need must be defined in the manifest file.
Advanced components
Android comes with a number of advanced components such as Map, Menus, Graphics, Animations, Multimedia, Preferences, Sqlite databases, etc.
Cloud to Device Push
This is a new service similar to iPhone push notification.
Debugging
Marko suggested use of Eclipse debugger, logcat, hierarchy viewer and traceview for debugging.
For more information on Android session, Download the slides.
For the second half of the day, I attended Dean Wampler’s session on Scala. I have been long interested in Scala and have done a little development on my own. As OSCON offered a lot of sessions on Scala, I took the opportunity to learn more on Scala. Dean highlighted concurrency, concise code, and correctness, better object model as major benefits of Scala.
Introduction
Scala comes with a number of features for concise code such as implicit type conversion, properties with uniform access principle and optional semicolons and paranthesis when function arguments are one or empty. Scala allows objects to act as function using apply method, e.g.
class Logger(val level: Level) {
def apply(message: String) = {
log(level, message)
}
}
val error = new Logger(ERROR) ...
error("Network error.")
Also, Scala treats primitive types as objects, but are comiled down as primitivies. Scala also treats functions as objects, e.g. you can create list or map without new
val list = List(1, 2, 3, 4, 5)
val map = Map("name" -> "Dean", "age" -> 39)
Above list syntax is same as 1::2::3::4::5::Nil. Scala also allows any symbol for function name so you can define functions that look like operator overloading. Scala uses infix operator notation, for example, following two expressions are equivalent:
"hello" + "world"
"hello".+("world")
Scala gives you higher level operations such as map, filter, fold/reduce, e.g.
val list = "a" :: "b" :: Nil
list map {
s => s.toUpperCase
}
Generics
Martin Ordesky added limited support of Generics in Java, but he added fully functional generics support in Scala, e.g.
class List[A] { ...
def map[B](f: A => B): List[B]
...
}
Traits
One of nice feature of Scala is its support of Traits, which are interfaces with implementation and are similar to Ruby mixins. Here is an example:
trait Logger { def log(level: Level,
message: String) = { Log.log(level, message)
} }
val dean = new Person(...) extends Logger
dean.log(ERROR, "Bozo alert!!")
Scala also defines traits for functions to convert them into objects, e.g.
trait Function1[A,R] extends AnyRef {
def apply(a:A): R
... }
User-defined factory methods
You can define functions as factory-methods to instantiate objects, e.g.
val persons = Map("dean" -> deanPerson, "alex", -> alexPerson)
DSL
Scala offers powerful semantics to define internal DSLs, e.g. you can create your own controls, e.g.
import java.io._ object Loop {
{...}
}
def loop(file: File, f: (Int,String) => Unit) =
...
loop (new File("...")) { (n, line) => ...
}
Options as alternative to Null
Scala avoid NullPointerExceptions by wrapping nulls into options, e.g.
abstract class Option[T] {...} case class Some[T](t: T)
extends Option[T] {...} case object None
extends Option[Nothing] {...}
Case Classes
Case classes provide succint syntax for creatng Javabeans.
For comprehensions
Scala provides for comprehensions, which are similar to Python generators, e.g.
val l = List( Some("a"), None, Some("b"), None, Some("c"))
for (Some(s) <- l) yield s
Actors
Scala provides Actor based concurrency similar to Erlang, though there are multiple implementations and Akka seems to provide better implementation than what comes with Scala. Here is an example:
case class Point(
x: Double, y: Double)
abstract class Shape { def draw()
}
....
package shapes import scala.actors._, Actor._ object ShapeDrawingActor
extends Actor { def act() {
loop { receive {
case s:Shape =>
s.draw()
... }
} }
}
Tutorials Day Two
On day two, I attended all-day Scala summit, which covered various topics for practical Scala.
Why Scala?
The summit started with session on "Why Scala?" by Alex Payne and Dean Wampler. Dean repeated some of same concepts from Monday's session on Scala's conciseness, concurrency, correctness, infix operator, type inference, case classes, etc. Dean then gave some examples of actors using Akka, where he calls multiple services using actors and then gather the results, e.g.
val futures = for { s <- services
server <- allServersFor(s) }
yield (server !!! HeartBeat)
Futures.awaitAll(futures) val results = for {
future <- futures
result <- future.result } yield result val all = results reduceLeft(
(r1, r2) => r1 merge r2 ) compact(render(all))
}}
Jonas Bonér then gave brief overview of Akka, which provides a number ofabstractions for concurrency such as actors, STM, and agents. Jonas gave introduction to actors, which provide concurrency based on message-passing, shared-nothing, and mailbox. In Akka, actors can be thread based or event based, where event based actors are very light-weight and you can create millions of them (each actor takes about 600 bytes as opposed to 300 bytes in Erlang).
factory-methods
Akka uses factory-methods to hide type of actors, e.g.
val counter = actorOf[Counter] // counter is ActorRef
actor.start
actor.stop
Jonas suggested use of actorOf as opposed to "new Counter" syntax as it avoids calling methods on the objects directly. Akka uses !, !! and !!! notations to send messages, where ! is just fire and forget, !! collects results using Futures and !!! returns Future, e..g
counter ! Tick // send message -- fire-forget
val result = (actor !! Message).as[String] // uses Future under the hood with timeout
val resultOption = actor !! Message
val result = resultOption.getOrElse(defaultResult)
val result = resultOption.getOrElse(throw new Exception("time out"))
val future = actor !!! Message
future.await
val result = future.get
Futures.awaitOne(List(fut1, ..))
Futures.awaitAll(List(fut1,))
You use self.reply to reply back to the sender and access sender using self.sender or self.senderFuture.
Immutable Messages
In order to keep actors free of side effects, messages must be immutable using case classes, tuples or lists, e.g.
- case class Register(user: User)
- actor ! Register(user)
- actor ! (username, password)
- actor ! List("xxx", "yy")
Dispatchers
Akka comes with a number of dispatches such as event based, thread based, reactor, etc. See Dispatchers class for more information.
Queues
Akka also comes with various queue types such as unbounded LinkedBlockingQueue, bounded LinkedBlockingQueue, etc.
ActorRegistry
ActorRegistry provides lookup methods for actors such as ActorRegistry.actorsFor.
Fault tolerance
Akka borrows concepts of hierarchy of supervisors for managing actors or processes from Erlang. Erlang's philosophy for fault tolerance is let it crash and the supervisor automatically starts failed process or group of processes. You use link(actor), unlink(actor), startLink(actor) to connect actors with supervisors and trap events using trapExit = List(classOf[ServiceException], classOf[PersistentException]), e.g.
class Supervisor extends Actor {
import self._
trapExit = List(classOf[Throwable])
}
class FaultTolerantService extends Actor
override def preRestart
override def postRestart
Remote Actors
You can start a node, which is remotely accessible using:
RemoteNode.start("localhost", 9999)
spawnLinkRemote[MyActor]("darkstar", 9999)
RemoteNode.register("service:id", )
STM, Transactors, Modules, Camel, Storage
We ran out of time for the rest of contents, but you can read more from the Slides.
Next, Mark Harrah presented SBT, which everyone raved at the summit. SBT uses Scala based DSL for writing build scripts and internally uses Ivy for managing dependencies. You can create a new project by creating a new directory and typing sbt. You can set various properties in sbt shell such as target version, e.g.
set build.scala.versions 2.80
reload
You can easily create custom tasks in sbt by extending DefaultProject, e.g.
import sbt._
class MyProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val hi = task { println("Hi"); None}
lazy val goodbye = task { println("Bye"); None} dependsOn(hi)
}
You can also target tasks for just test using
import sbt._
class MyProject(info: ProjectInfo) extends DefaultProject(info) {
val sc = "org.scala-tools.testing" %% "scalacheck" % "1.7" % "test"
}
OR
import sbt._
class MyProject(info: ProjectInfo) extends DefaultProject(info) {
val sc = "org.scala-tools.sbt" %% "launcher-interface" % "0.74"
val tt = "org.scala-tools.sbt" %% "launcher-interface" % "0.74" % "test"
}
You can define main application as follows:
import xsbti._
class HW extends AppMain {
def run(config: AppConfiguration): MainResult = {config.arguments foreach println; new Exit {def code = 0}}
}
You generate executable jar by typing publish-local in sbt shell. You can define plugins as follows:
class Plugins(inf: ProjectInfo) extends PluginDefinition(info) {
val android = "org.scala-tools.sbt" % "sbt-android-plugin" % "0.5.0"
}
Finally, sbt allows you to create processors, which behave like scaffolding in Rails, e.g.
import xsbti._
import processor._
class HW extends BasicProcessor {
def apply(project: Project, args: String) {
import project._
val contents = "This is " + name + "" + version + "\n" + args + "\n"
FileUtilities.write(info.projectPath / "README" asFile, contents, log)
}
}
When you type publish, it will create README file for the project. That was pretty much the introduction to the sbt.
Eric Torreborre talked about Spec, which a BDD based testing tool for Scala. Spec provides support for BDD, Structures, Matchers, ScalaCheck, Mocks, Runners and databases. You use matchers to compare strings or XML contents, e.g.
class Reverse2Spec extends Specficiation {
reverse("") must_== ""
...
You can restrict scope by defining tag method, e.g.
class Example(des : String) {
def in(arg: Any) = expectations
def tag(t : String) = this
}
Scala DSL
Spec uses a number of tricks for simplifying the syntax such as implicit parameters, operators, lazy evaluation.
"With a 3 tests ok" in {
prop
}
//Some paraemeters can be implicit
implicit val defaultparams = new Params
"this should not explode" in {
error("boom")
}
def in(e: => Any) = // parameters are evaluated lazily when you use it
It also uses principles such as add principle by adding new functionality, e.g.
result + 1
result.pp + 1
Spec also supports table similar to Fit and Fitness for writing concise tests. Overall, I was impressed with wide set of tools for writing tests.
Lift is a Scala based web framework for writing secure, typesafe, concise, and interactive (like desktop) applications. It abstracts much of plumbing of HTTP, which I personally don't like as I have found web frameworks that does that results in leaky abstractions. Lift also uses stateful web applications, which require sticky sessions, which is another area that I have found to be problematic for scalability and upgrade. Here is an example of Lift chat server:
package code.comet
import net.liftweb._
import http._
import actor._
import scala.xml.
object ChatServer extends LiftActor withListenerManager {
private var msgs = List("Welcome")
def createUpdate = msgs
override def lowPriority = {
case s: String => msgs ::= s; updateListeners()
}
}
class Chat extends CometActor withCometListener {
private var msgs: List[String] = Nil
def regiserWith = ChatServer
override def lowPriority = {
case l: List[String] = msgs = l; reRender(false) // don't use reRender
}
def line(in: NodeSeq) : NodeSeq = msgs.reverse.flatMap(m => bind("chat", in, "item" -> m))
def render = bind("chat", "line" -> line _)
}
In Lift, every component has GUID and version that was used to render and then sets up long poll and then receive deltas (every 100ms). You can use sbt to deploy jetty and prepare war file, e.g.
sbt
>jetty-run
>prepareWeb // uses JRebel to reload classes
This was another interesting talk by Nathan Hamblen for using Scala for writing Android applications. The key selling point of Scala has been conciseness of the language, and you can write simple code such as:
dialog.setOnShowListener { di: DialogInterface =>
runSomeCode()
}
instead of
dialog.setOnShowListener(
new DialogInterface.OnShowListener() {
public void onShow(DialogInterface interface) {
runSomeCode();
}
}
);
or
future { runSomeCode(myObject) }
instead of
new AsyncTask () {
protected Integer doInBackground(MyObject... objs) {
runSomeCode(objs[0]);
}
}.execute(myObject);
Nathan showed how you can define Scala traits to add lazy handlers for android code, e.g.
trait ScalaActivity extends Activity {
...
lazy val handler = new Handler
def post(block: => Unit) {
handler.post(new Runnable{
def run { block }
})
}
Or you can extend APIs, e.g.
implicit def f2cancel(block: DialogInterface => Unit) =
new DialogInterface.OnCancelListener {
def onCancel(dialog: DialogInterface) {
block(dialog)
}
}
...
new AlertDialog.Builder(this)
.setOnCancelListener {
di: DialogInterface => finish()
}
Nathan also showed a plugin (sbt-android-plugin) to create type-safe layout instead of using R.java file generated by Android, which you can get it from git clone git://github.com/meetup/meetabout.git. On the downside, Scala based android applications require Scala jar files and the size of application becomes considerable large. Though, you can use tools to extract the classes that you need, but it would still be larger than Java code.
Alex Payne and Coda Hale had a section on Scala in practice, but it was only Q/A session. I was a bit disappointed that they didn't come prepare with actual usage or war stories from their work environment.
The last section of the day was a bit on type and category theory, which was interesting but mostly theortical. Daniel Spiewak explained difference between kind and type system. The only tip from the session I got was that Values are to types as types are to kinds. Finally, Daniel explained that newly released 2.8.0 version of Scala supports continuation but it's all broken and useless.
Summary
Overall, I found sessions on both Android and Scala were well worth the time and it peaked my interest in both. I think the ecosystem of Scala has matured and there is better tools support with the new version (2.8). I am going to try to influence co-workers into using it for new development. I am also going to start Android project pretty soon but I am a bit hesitant on writing in Scala due to increased application size.
