This document discusses concurrent processing and distributed computing using Akka and Scala. It defines concurrent processing as executing instructions simultaneously using multiple processors for better performance. It describes two types of concurrency: shared-state which uses shared memory and message passing which involves exchanging messages asynchronously. Akka is a toolkit that uses the actor model where everything is an actor that can respond concurrently to messages by sending messages or spawning new actors. The document provides an example Akka code in Scala for calculating pi in a concurrent manner.

1. Concurrent Processing and
Distributed Computing
A case study on Akka and Scala
Rahul Ramteke-2K13/SE/066

2. What is concurrent processing?
Concurrent processing is a computing model in which multiple processors
execute instructions simultaneously for better performance. Concurrent
means something that happens at the same time as something else. Tasks are
broken down into subtasks that are then assigned to separate processors to
perform simultaneously, instead of sequentially as they would have to be
carried out by a single processor.

3. Concurrency methodologies
When you look at the topic of concurrency in the general sense, there really are only two
types: shared-state concurrency and message passing for concurrency. Shared-state
concurrency has dominated for a long time, but before it did, the idea of message passing
was the mainstay. Multiprocessing was used to carve up work between processes on a
machine, and communication between those processes was accomplished using file
descriptors on which you could simply read and write. This was message-passing in its
most primitive form.

4. Shared State concurrency
When using shared state concurrency, the threads tend to use the same memory address
for computations and processing. This type of concurrency has been profoundly used in
java and c#.
Shared State Concurrency has the following advantages...
• Can be very fast.
• Makes Global Consensus much easier to achieve
• Makes passing around Reference Objects that much easier, especially if a
pointer/reference valid in one process is valid in another.

5. Message passing concurrency
Concurrent components communicate by exchanging messages (exemplified by Scala).
The exchange of messages may be carried out asynchronously, or may use a synchronous
"rendezvous" style in which the sender blocks until the message is received. Asynchronous
message passing may be reliable or unreliable (sometimes referred to as "send and pray").
Message-passing concurrency tends to be far easier to reason about than shared-memory
concurrency, and is typically considered a more robust form of concurrent programming.

6. introduction to akka and scala
Scala, to many, is a programming language which compiles to Bytecode and has functional
features. To me, it’s more of a paradigm. The name does indicate that scalability is involved
somewhere and it actually is. As they say, scala grows with you.
Akka is a toolkit that specializes in easing the task of concurrency for the beginners and
being an ultimate concurrency resource for seasoned devs. You can think of it as a
framework which is strongly based on actor model.

7. The actor model
The Actor model adopts the philosophy that everything is an actor. This is similar to the everything is an object
philosophy used by some object-oriented programming languages, but differs in that object-oriented software is
typically executed sequentially, while the Actor model is inherently concurrent.
An actor is a computational entity that, in response to a message it receives, can concurrently:
• send a finite number of messages to other actors;
• create a finite number of new actors;
• designate the behavior to be used for the next message it receives.
• There is no assumed sequence to the above actions and they could be carried out in parallel.

8. The working of akka
As i said before, scala to me is a paradigm and so is akka. It opens your mind when it comes
to concurrency, allows you to think in new and better ways. Let’s see how it actually
works.
Akka is based on actor model. So, yes, actor is the atom here. The actor does most of the
heavy lifting in our applications due to its flexibility,its location independence,and its fault
tolerant behaviour. But even beyond these features, there’s an interesting consequence of
the actor design—it helps make concurrency development more intuitive.

9. The working of akka
o Messages come into a mailbox through (unless you want otherwise) a non-blocking enqueue operation.
• This allows the caller to go about his business and doesn’t tie up a waiting thread.
o The enqueue operation wakes up the dispatcher who sees that there’s a new message for the actor to process.
o The dispatcher sends the message to the actor and the actor processes it on whatever thread it was put on to do the
work.
• During the time when the actor is processing the message, it’s in its own little world.
• It can’t see other messages being queued and it can’t be affected by anything else that’s happening elsewhere.
o Eventually, the actor will finish processing the message.

10. A sample akka code in scala
Apparently calculating 22/7 through your code isn’t enough for calculating pi.
∞ −1 ^푛
푛=0
2∗푛+1
= Pi/4
So, here we have a code which calculates value of pi to a certain precision, which depends
on the value of ‘n’ and the limits of the data type used.

11. Doing it the java way
Had it been plain old java. The imperative style would have forced us to do it the old way
of having mutable objects, having threads, and synchronizing them to prevent deadlocks.
You can imagine what a mess it would have been.
Not saying that java is bad for concurrency. But isn’t good too when you actually need
scalability. As seen in the code,I can Actually scale the scala code for n=200 million in 8-10
lines and 2 minutes. And the optimum core use is handled by akka.

12. The working of akka
As i said before, scala to me is a paradigm and so is akka. It opens your mind when it comes
to concurrency, allows you to think in new and better ways. Let’s see how it actually
works.
Akka is based on actor model. So, yes, actor is the atom here. The actor does most of the
heavy lifting in our applications due to its flexibility,its location independence,and its fault
tolerant behaviour. But even beyond these features, there’s an interesting consequence of
the actor design—it helps make concurrency development more intuitive.