Personal tools
  •  
You are here: Home Tutorials WORLDCOMP'14 Tutorial: Dr. Mark C. Lewis
Conference Proceedings
Get WORLDCOMP'13 & '14 Proceedings
Click Here

Photo Galleries

Call for Papers
Submission of
LATE BREAKING PAPERS

Click here for details


Important Dates
July 21-24, 2014
The WORLDCOMP'14
(including all affiliated conferences)


Featured Workshops
Doctoral Colloquium
&
Demos Sessions

Click here for details


« October 2015 »
Su Mo Tu We Th Fr Sa
123
45678910
11121314151617
18192021222324
25262728293031
 

WORLDCOMP'14 Tutorial: Dr. Mark C. Lewis

Last modified 2014-07-04 17:41


Actor Parallelism and Akka/Scala
Dr. Mark C. Lewis
Professor, Department of Computer Science
Trinity University, USA

Date: July 23, 2014 - 6:00pm
Location: Ballroom 4


Abstract

    The significance of parallelism has grown steadily over the last decade with multicore processors becoming ubiquitous and more computational work moving to web and cloud based platforms that need to scale smoothly for large numbers of users. Many different approaches to parallelism have been developed to deal with this need, ranging from lowlevel, direct control over threads or message passing to higherlevel approaches such as collections supporting dataparallelism.

    The Scala programming language was built to include support for many approaches to parallelism. In this tutorial we will look at one of the approaches that is gaining significant traction for its ability to scale up applications and ease the work of the application developer, actors. In particular, this tutorial will look at Akka and how it can be used with Scala to create efficient, highly scalable application.


Objectives

    The goal of this tutorial is to introduce participants to the actor model of parallelism in general and the Scala/Akka approach in specific. The actor model is probably best known as the approach used by the Erlang language. Scala has built on this and the Akka library provides a robust and high performance implementation of actors for Java and Scala.

    The basic idea of the actor model is that instead of having objects where a thread of control runs through the various objects as different methods are called, picture a sequence diagram, the thread of control is associated with the actor in some manner and actors exchange messages. Each actor has an inbox and reacts to the messages as they are received. In a proper usage of the actor model, any mutable memory is stored in a single actor and only accessed by that actor. This simple rule completely eliminates race conditions without forcing one to go to a completely immutable memory model. It also generally eliminates deadlocks as the client code does not block or wait beyond the natural behavior of the actors.

    Actor based systems are also generally extremely robust against failure. Indeed, the telecommunications industry was one of the primary early adopters of Erlang. This was not only because the actor model in Erlang allowed things to scale well. It was also because the systems built using Erlang and actors were extremely robust. This is because the actor model generally assumes that some form of failure is inevitable and builds in mechanisms to deal with that inevitability instead of being dependent on things always working.

    This is highlighted in the Akka library where you are never certain if messages are delivered. Such assumptions are necessary for working with distributed actors in a way such that the system can survive having nodes in a cluster go down. We will address how this is done under Akka in the workshop to help participants build their own robust and highly scalable systems.

    To get the most out of this tutorial, consider bringing a laptop and have the latest versions of Scala and Akka installed. You can get them at www.scalalang.org and http://akka.io/. You can also get a plugin for Eclipse from www.scalaide.com.


Intended Audience

    This tutorial is intended for anyone who has an interest in actor parallelism in general and how to use it specifically with the Akka implementation.


Biography of Instructors

    Mark Lewis has been teaching Computer Science at Trinity University since 2001. His courses span from introductory to advanced and tend to focus on aspects related to programming/programming languages and simulation/scientific computing. He has been the lead author on over 20 papers spanning a range of topics from planetary ring dynamics in the journal Icarus to the SIGCSE annual conference proceedings. He is also the author of “Introduction to the Art of Programming Using Scala,” published by CRC Press.

Current Event
WORLDCOMP'15
Click Here
Past Events
WORLDCOMP'13
Click Here

WORLDCOMP'12
Click Here

WORLDCOMP'11
Click Here

WORLDCOMP'10
Click Here

WORLDCOMP'09
Click Here

WORLDCOMP'08
Click Here

WORLDCOMP'07
Click Here

WORLDCOMP'06
Click Here


Join Our Mailing List
Sign up to receive email announcements and updates about conferences and future events




 


Administered by UCMSS
Universal Conference Management Systems & Support
San Diego, California, USA
Contact: Kaveh Arbtan