Scalable Scala

Building scalable systems with Java, Scala, and Akka

Scalable applications

Scalability is a crucial aspect of modern application development. Depending on your platform, scalability
can take different forms. On devices and personal systems, applications need to scale up to use multiple cores
efficiently in order to deliver a quality user experience. On servers, applications also need to scale out to
distribute work across systems.

The Scala programming language is designed around scalability. It gives you the tools you need to spread
work across multiple cores with minimal impact on your application design. When combined with the open source
Akka toolkit it also allows you to easily spread your application across multiple systems.

Scala additionally offers the advantage of building on the Java™ programming language and platform.
Not only can you use all the familiar Java libraries directly in your Scala code, you can also intermingle
Scala with existing or new Java code. Akka also works with both Scala and Java code, and although it's been
easier to use Akka with Scala in the past the new Java 8 lambdas feature is bringing the two languages to a
more equal footing.

The site name emphasizes the Scala language since that's central to my view of developing scalable
applications, but the site is actually devoted to helping developers learn about building scalable applications
with Java, Scala, and Akka, with other toolkits and extensions to come in the future.

Looking for help with scalability or performance issues, in Java or Scala?
Email me
to find out about my consulting, training, or mentoring services.

Recent Articles

The first four articles in my IBM developerWorks® JVM
Concurrency series have been published (along with a companion article to the second one):

The Scalable Scala blog on this site includes background and added information on the
articles.

Recent Presentations

Acting Concurrent: The Akka actor model for Java and Scala is my presentation to the Seattle Java Users Group
meeting on 19 August 2014. This starts with a look at Java 8 and Scala concurrency features, then moves on to using
Akka actors in both Scala and Java, including discussion of retrofitting existing Java applications to Akka. You can view
the full video on Vimeo. Click the image below to view the slide set (use
mouse clicks or arrow keys to move through the slides, or scroll with your mouse wheel).

Building on Akka I/O: Using Akka Asynchronous Actor Networking is my presentation to the
Scala at the Sea meetup
group on 12 August 2014. This starts with an introduction to the akka.io UDP and TCP support, then shows how the TCP
support can be used to build an SMTP client, including an implementation based on Akka's Finite State Machine (FSM)
support. It also discusses the evolving state of the Reactive Streams Akka implementation, which is intended to provide
support for higher-level protocols in the future. Click the image below to view the slide set (use
mouse clicks or arrow keys to move through the slides, or scroll with your mouse wheel).

About me

I've been developing software for more than 30 years, using everything from assembler language to Lisp —
and more recently, Scala. Most of my earlier work was in data communications, often interfacing with custom
hardware for real-time processing of events via interrupts. From that I moved into working with XML in Java, and
then into web services. I'm still involved in web services today, as a committer on Apache CXF and by providing
Java web services training and consulting services for clients worldwide,
but also increasingly involved in developing other types of scalable, reactive, server applications.

Much of my background has been focused on performance and scalability. The approach of developing code without
regard to performance, based on the assumption that you can "tune" it afterward, has led many organizations
into massive time and cost overruns. Performance requirments need be clearly spelled out as part of any
substantial development work, and developers need to have a feeling for how their design choices effect the
potential performance of the application. Scalability is one very important factor in performance — to
the extent that your application is scalable you can add more resources as needed to meet performance demands,
which takes pressure off other aspects of your design. But scalability doesn't just happen, it needs to be
part of how your developers structure the application.

Fortunately, tools like Scala and Akka, and even Java 8, are making
it easy to build more-scalable applications. On this site, and in my IBM developerWorks series of articles,
I'll be covering some of the ways you can do this.