Benefits Of The Actor Model For Cloud Computing: A Pragmatic Overview For Java Architects


Benefits Of The Actor Model For Cloud Computing: A Pragmatic Overview For Java Architects

With Jeffrey Hammond and Jonas Bonér

microservices reactive

Audience: Architect, Management
Technical level: Intermediate

As enterprise development teams increase the time they spend using cloud computing, many are challenged by a move from a scale-up (monolithic) to a scale-out (distributed) architecture. Reactive system development and microservices are two evolving answers that architects are embracing, but making them work well at scale calls for a departure from the traditional approach of object-oriented programming models and defensive programming through try-catch, which is now being replaced by a highly-resilient supervision model and a "let it crash" philosophy.

In this webinar for Architects, guest speaker Jeffrey Hammond, Forrester Vice-President and Principal Analyst joins Jonas Bonér, CTO/Co-founder of Lightbend and creator of Akka, the actor-based, message-driven runtime for the JVM, to discuss one emerging programming pattern that’s gaining popularity with teams developing for the cloud––the Actor model. They will discuss some history, why the Actor model is a better fit for large, scale-out systems and microservices delivery, the types of workloads using it today, and how to implement an Actor-based system in your existing Java environment.


Related Videos

Using the Actor Model with Domain-Driven Design (DDD) in Reactive Systems



Using the Actor Model with Domain-Driven Design (DDD) in Reactive Systems

with Vaughn Vernon

Is the Actor Model just a new "shiny object" for developers to chase after, a fad soon to be abandoned? In fact, the Actor Model was first designed in 1973–over 20 years before brands like Yahoo! and Hotmail first arrived at the burgeoning internet. Created to address the long-term direction of computing and software development, it is almost as old as the formal definition of object-oriented programming.

Fast forward to 2017, where we are faced with an online and mobile world that continues to grow exponentially, and a third wave of IoT aims to add hundreds of billions of connected devices to our lives.

To manage today’s demanding needs and to prepare for the coming wave, enterprises like Intel, Samsung, Walmart, PayPal, Hootsuite, and Norwegian Cruise Lines are embracing distributed, Reactive systems deployed on hybrid cloud infrastructures. Central to these systems and applications is the Actor Model, which is seeing “renewed interest as cloud concurrency challenges grow,” according to Forrester Research.

In this webinar, special guest Vaughn Vernon explains why actors are so vital to the future of software development. You will learn:

  • Why actors are so exceptionally well-suited for use with Domain-Driven Design, speaking the Ubiquitous Language of your core business domain.
  • How actors are designed to gracefully handle failure, maintaining system resilience and responsiveness to users no matter what’s happening.
  • How actors help you reactively scale your systems meet concurrency demands, elastically growing up and out to handle peak load, and shrinking when not minimizing your infrastructure and hardware footprint.

Exploring Reactive Integrations with Akka Streams, Alpakka and Kafka


reactive akka akka-streams

Exploring Reactive Integrations with Akka Streams, Alpakka and Kafka

with Konrad Malawski

Audience: Architects
Technical level: Introductory

Since its stable release in 2016, Akka Streams is quickly becoming the de facto standard integration layer between various Streaming systems and products. Enterprises like PayPal, Intel, Samsung and Norwegian Cruise Lines see this is a game changer in terms of designing Reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages.

This comes from the Reactive Streams initiative in part, which has been long led by Lightbend and others, allowing multiple streaming libraries to inter-operate between each other in a performant and resilient fashion, providing back-pressure all the way. But perhaps even more so thanks to the various integration drivers that have sprung up in the community and the Akka team—including drivers for Apache Kafka, Apache Cassandra, Streaming HTTP, Websockets and much more.

In this webinar for JVM Architects, Konrad Malawski explores the what and why of Reactive integrations, with examples featuring technologies like Akka Streams, Apache Kafka, and Alpakka, a new community project for building Streaming connectors that seeks to “back-pressurize” traditional Apache Camel endpoints.

  • An overview of Reactive Streams and what it will look like in JDK 9, and the Akka Streams API implementation for Java and Scala.
  • Introduction to Alpakka, a modern, Reactive version of Apache Camel, and its growing community of Streams connectors (e.g. Akka Streams Kafka, MQTT, AMQP, Streaming HTTP/TCP/FileIO and more).
  • How Akka Streams and Akka HTTP work with Websockets, HTTP and TCP, with examples in both in Java and Scala.

The Basics Of Reactive System Design For Traditional Java Enterprises


reactive java

The Basics Of Reactive System Design For Traditional Java Enterprises

with Sean Walsh and Duncan DeVore

Like most things in life, in software there exists an Old and a New way of doing things. The growth of computing power, increase in the sheer number of users, cheaper and more available hardware, and the explosive IoT market mandates that we build our systems using modern methods that diverge from past.

This modern way is called “Reactive”, which was first co-authored by Lightbend in 2013 with the Reactive Manifesto and now has over 15,000 signatories. With 2017 nearly upon us, we now see the market widely embracing Reactive in response to the many Architects, Developers and DevOps practitioners failing to meet tough new demands on their systems using last year’s technologies and monolithic designs.

Yet with this popularity, the term Reactive is being overloaded and confused. Some believe that asynchronous messaging alone is good enough. As we will see, this is only part of the puzzle.

In this webinar aimed at Architects and Developers working with more traditional Java environments, Lightbend’s Sean Walsh and Duncan DeVore take us on a journey that goes beyond just asynchronous programming and into the very basics of designing Reactive systems as a whole.

We will review:

  • Why simply implementing asynchronous messaging is only part of the puzzle, and what it means to build entire systems as a whole based on the principles of Reactive system design: message-driven, resilient, elastic and responsive.
  • How to avoid repeatedly building monoliths by embracing tried-and-true concepts of Domain Driven Design (DDD), Command Query Responsibility Segregation (CQRS) and Event Sourcing.
  • How the Actor Model with Akka makes concurrency a breeze and harnesses clustered computing capabilities to divide and conquer work.
  • How to design systems that can self-heal, self-scale, both up and down and truly provide the most real time and responsive experience for your customers, clients and partners while being a joy to program and maintain.

Introducing Reactive Platform 2.0



Introducing Reactive Platform 2.0

with Hywel Evans & Justin Pihony

Architects, App Dev Managers, Directors and other decision makers are welcome to join this presentation covering our newest release of Reactive Platform v2.0, plus the chance to ask questions to our expert team.

Monitoring Microservices in Production with Lightbend Platform


microservices monitoring production-suite

Monitoring Microservices in Production with Lightbend Platform

with Duncan DeVore and Henrik Engström

Audience: DevOps, Architect
Technical level: Intermediate

Reactive systems are the next major evolution of the Internet. They allow for applications to be responsive, scalable and resilient by building on a fully message-driven foundation; but though the Reactive approach enables us to build highly scalable and resilient applications, it also introduces new challenges in how to monitor them.

The issue is that almost every current monitoring tool relies on a stack frame-based approach where using the stack trace can provide good answers to what caused exceptional states.

In asynchronous, message-driven applications, this approach no longer provides any useful information about issues like bottlenecks, hotspots and performance degradation. We therefore need to invent new approaches for how to monitor these types of applications.

During this session by Lightbend experts Henrik Engström and Duncan Devore, we take a look at the traditional approach to monitoring synchronous applications, what it takes to successfully monitor asynchronous applications, and finally show the way we have chosen to build a monitoring tool for Reactive systems at Lightbend.

  • Report

    Going Reactive 2016

    How Microservices & Fast Data are driving adoption of Reactive systems

    Get Report
  • Video

    How is Typesafe Reactive

    Learn how Typesafe technologies are Reactive

    Watch Now
  • White Paper

    Microservices In Production

    What Ops Should Know About Reactive Systems

    Get White paper