Akka

Knolx Sesion: Akka 2.0 Reloaded

Reading Time: < 1 minute Akka allows us to write concurrent, fault tolerant and scalable applications. We recently migrated our product from Akka 1.3x to Akka 2.x. The new version is quite different from 1.3x versions. It is not merely an API change but an overall change. We have to also think differently to develop applications. This session was presented at Knolx Session at Knoldus. This talk gently introduces Akka Continue Reading

Building Massively Scalable Applications with Akka 2.0

Reading Time: < 1 minute Recently Knoldus, presented at the IndicThreads conference, New Delhi on the power of Akka 2.0. The case study involved a demonstration on how a major white goods company is able to analyse their social feeds in real time and respond back to customers needs. The solution currently runs on a cluster of 40 nodes with 16 cores on each node. The presentation emphasized on the Continue Reading

ZeroMQ Module In AKKA 2.0 Some Gotchas

Reading Time: 5 minutes Akka framework supports ZeroMQ in its ZeroMQ extensions module. Akka is a great framework and we have our product built on its version 1.3x. We were looking at ZeroMQ support in our product and we stumbled on this issue. We found that ZeroMQ applications built on Akka extensions are running slower than an application built in plain scala. Please read about our discussion thread on Continue Reading

Handling Large Data File Using Scala and Akka

Reading Time: 6 minutes We needed to handle large data files reaching size Gigabytes in scala based Akka application of ours. We are interested in reading data from the file and then operating on it. In our application a single line in a file forms a unit of data to be worked upon. That means that we can only operate on lines in our big data file. These are Continue Reading

Using Akka Dispatchers In Scala

Reading Time: 4 minutes Akka dispatchers are extremely important in Akka framework. They are directly responsible for optimal performance, throughput and scalability. Akka supports dispatchers for both event-driven lightweight threads and thread-based Actors. For thread-based Actors each dispatcher is bound to a dedicated OS thread. Default dispatcher is a single event-based dispatcher for all Actors created. The dispatcher used is this one: Dispatchers.globalExecutorBasedEventDrivenDispatcher For many cases it becomes mandatory Continue Reading

Power of Parallel Processing in Akka

Reading Time: 4 minutes If you have been following the Inphina blog and our work with Scala related technologies, you would have noticed a spurt in our blog feeds. The reason being that we have recently come out of a very successful massively scalable framework created with Akka. Inphina holds an active stake in the product and the details of the framework would follow once the embargo is over. Continue Reading

Manage Akka Actors With Supervisors

Reading Time: 4 minutes We are building a concurrent and massively scalable system using Akka framework. Akka uses light-weight Actor paradigm of managing concurrency. Most of the times a bunch of Akka actors are required for a common functionality; therefore we do tend to manage them as a group. This is where Akka Supervisor comes into the picture. Akka Supervisors are responsible for starting, stopping and monitoring child Akka Continue Reading

AMQP and AKKA

Reading Time: 3 minutes AMQP is a message protocol that deals with publishers and consumers. It would look a lot like JMS but it is not. The main entities are Exchanges, Queues and Bindings. Look at the following diagram So a producer would send a message to the exchange and it is the job of the message broker (RabbitMQ in our case) to ensure that the messages are delivered Continue Reading

Akka Actors on Mac beating the S#!t Out of my Dell

Reading Time: 2 minutes Let me explain the scenario. We have n (tens, hundreds or thousands) of Akka actors listening to a queue on RabbitMQ server. So the scenario looks something like this AMQP.newConsumer(connection, ConsumerParameters("*", actor, Some(queueName), Some(exchangeParameters))) As you would notice, each of the actors gets a message from the Q and invokes a plugin to do the processing and returns the results back to the result Q. Continue Reading