Play Framework

This is an asynchronous framework built upon Akka, QUOTE: "Akka is a toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on the JVM.". The reason I mutter about old technology, is systems I worked on 20+ years ago used asynchronous everywhere (e.g. RSX11 QIO), so this to me is a step back in time. In those days we would not think of writing code that blocked, semaphores, events etc. were everyday fodder.

Unlike a threaded web server in the Play Framework the actions all run on a very small number of shared threads. If you block these threads for even short periods of time then the application throughput will suffer. So when implementing the controller methods (Actions) you need to be aware of what calls may block, i.e. database calls. Play provides the concept of a Promise of something, i.e. I am going to give you the result at somepoint but not yet. Think of a richer form of Future. In Java setting these up looks scary, I suspect this will be simpler with Lambdas in Java 8.

    public static Promise<Result> index() {
            return Promise.promise(
                                    new Function0<List<Track>>() {
                                            public List<Track> apply() {
                                                    return factory.findSome();
                                            }
                                    }
                            ).map( new Function<List<Track>, Result>()
                                            {
                                                    public Result apply(List<Track> t)
                                                    {
                                                            return ok(tracks.render(t));
                                                    }
                                            }
                                    );
}

If we break this down we return from our action a Promise, the framework will call the first Function apply that returns a List<Track> and when it completes it will then call the second Function apply to convert the List into a rendered result to be returned to the caller.

The boiler plate is using an anonymous class to achive similar functionality to the use of a Lambda, providing an anonymous function (the apply method defined within the anonymous class) to be called.

In Scala where functions are first class entities this simplifies to.

def index() = Action.async {
    scala.concurrent.Future { factory.findSome() }.map( t => Ok(tracks.render(t)) )
}

I can see clearly what happens with the Scala version but the Java one is a little bit like black magic.

Cassandra

Cassandra is a nosql database (I love translation of nosql -> Not Only SQL). Instead of seeing a database that stores everything in two dimensions it can store things in 3 dimensions (maybe more, thats where my brain stopped for now). For my investigations I basically treated it as a two dimensional database, I had a csv file of some singles lying around (yes track listing for 7" vinyl) from a long time ago. I used this to load a table in cassandra and then generated some simple pages and json from the data. This was using the datarax Java driver in blocking mode

So a TrackFactory to access a cassandra column family (AKA Table) and we have a simple integration of Cassandra and Play.

Afterthought

The hardest part was getting my head around the Java Promise functionality, this is a case of the language not really supporting modern paradimes. It was also interesting getting my head around the workings of an alternate nosql database, the other one I have used is mongodb.

I think the most powerfull tool here is Cassandra, it makes you look at data in a different way. You have to change the way you model your data. Also as the aims of Cassandra are redundancy and performance we start dropping some of the core RDBMs rules, such as Normalization.

So another couple of usefull tools in my box.