Scala reactive programming : build scalable, functional reactive microservices with Akka, Play, and Lagom / Rambabu Posa.

Format:

Book

Author/Creator:

Posa, Rambabu, author.

Language:

English

Subjects (All):

Scala (Computer program language).

Physical Description:

1 online resource (518 pages) : illustrations

Edition:

1st ed.

Place of Publication:

Birmingham, [England] ; Mumbai, [India] : Packt Publishing, 2018.

Biography/History:

Posa Rambabu: Rambabu Posa has been working as Java developer since 2004 and a Scala developer since mid-2015. He loves Functional Programming in the Test-Driven Development way to develop Reactive microservices. He loves teaching and has been giving online training and writing tutorials on both the Java and Scala ecosystems. He loves developing Reactive systems using Lightbend's Reactive Platform Technology stack like Lagom Framework, ConductR, Scala, Akka Toolkit, Akka Streams, Play Framework, and others.

Summary:

Reactive programming is a better, scalable, and faster way to build applications, and one that helps us write code that is concise, clear, and readable. It can be used for many purposes such as GUIs, robotics, music, and more, and is central to many concurrent systems. This book will be your guide to getting started with Reactive programming.

Contents:

Cover

Title Page

Copyright and Credits

Dedication

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: Getting Started with Reactive and Functional Programming

Introduction to Reactive

What is Reactive?

What is Reactive programming?

What is a data stream or stream?

RP versus Reactive systems versus Reactive architecture

Event-Driven versus Message-Driven

Benefits of Reactive systems with RP

Functional programming

What is functional programming?

Principles of functional programming

Benefits of functional programming

Functional Reactive programming

Types of RP

Why FP is the best fit for RP

Reactive Manifesto

Need of Reactive Manifesto

Principles of Reactive systems

Message-Driven

Elasticity

Resilience

Responsiveness

Why Reactive Streams specification?

Why is Play Framework the best for Reactive systems?

Reactive systems versus traditional systems

The Java 9 Flow API

Flow API - Publisher

Flow API - Subscriber

Flow API - Subscription

Flow API - Processor

Flow API - Flow

Implementations of Reactive Streams

Lightbend's Reactive Platform

Pivotal's Reactor project

Microsoft's Reactive Extensions (RX)

Netflix's RxJava

Eclipse's Vert.x

Ratpack

How are Reactive Streams born?

Marble diagrams

What is a Marble diagram?

Data transformation

Benefits of Marble diagrams

Rules of Marble diagrams

Important FRP operators

FRP - the map() function Marble diagram

FRP - the flatMap() function Marble diagram

FRP - the merge() function Marble diagram

FRP - the filter() function Marble diagram

FRP - the reduce() function Marble diagram

FRP - the concat() and sorted() functions Marble diagram

Observer pattern versus Reactive pattern

Summary

Chapter 2: Functional Scala.

Introduction to Scala

The Scala ecosystem

Understanding the Scala Application

Scala REPL

Principles of Scala FP

FP Design Patterns

Scala FP features in action

Immutability

Scala functions

Scala pure functions

Pattern matching

Scala combinators

For-comprehensions

Scala implicits

Implicit parameters

Implicit conversions

Scala anonymous functions

Everything is an expression

Referential transparency

Functions are first-class citizens

Partial functions

Function currying

Higher-Order Functions

Scala tail-recursion

Types of recursions

Benefits of linear recursion

A linear-recursion example

Benefits of tail-recursion

A tail-recursion example

Scala Type class

Benefits of Type classes

Scala Collections in action

Scala List

Scala List Cons operator

Right associative rule

Scala Map

Scala Range

Scala Functional Design Patterns

Scala map() function

Scala flatMap() function

Advantages of flatMap

Scala Monads in action

Scala Option

Scala Either

Scala Case class and object

Benefits of Scala Case class

Scala Traits in action

Trait as an interface

Traits linearization

Linearization rules

Chapter 3: Asynchronous Programming with Scala

Introduction to Scala AP

What is asynchronous?

Differences between asynchronous and synchronous

Benefits of asynchronous programming

Differences between Concurrency and Parallelism

How Scala supports AP

The Scala Future API

Building blocks of the Scala Future API

Benefits of the Scala Future API

The Scala Future

What is a Future in Scala?

What is a computation unit?

Future Trait definition

Future Companion object

The complete Scala Future API

Scala Future examples

The Scala Promise.

What is a Scala Promise?

The Scala Promise API

Scala Promise examples

Scala ExecutionContext

What is ExecutionContext?

The relationship between Scala Future components

Differences between a Future and a Promise

Scala Future API callbacks

Scala Future API combinators

Scala Future.sequence()

The Scala Async Library

Scala Async API

The Scala Future API in Play Framework

The Scala Future API in the Akka Toolkit

A Scala Future versus a Java Future

Chapter 4: Building Reactive Applications with Akka

Introduction to Akka

What is Akka?

Applications on the JVM (Java Virtual Machine)

Features of Akka

Benefits of Akka (or why do we need Akka?)

Building blocks of the Akka Toolkit

Akka Extensions (or modules)

Akka Clients

Actor Model in-depth

What is the Actor Model?

Principles of the Actor Model (or properties of Actor in the Actor Model)

Issues with the Shared-State Concurrency model

Benefits of the Actor Model

Components of the Actor Model (or building blocks of the Actor Model)

What are the benefits of immutable messages in the Actor Model?

How Akka implements the Actor Model

Other Actor Model implementations

Akka ActorSystem

What is the ActorSystem?

Roles and responsibilities of ActorSystem

How to create an Akka ActorSystem?

How to shut down an Akka ActorSystem?

Components of Akka's ActorSystem

What is materialization and Akka's implementation?

Akka Actors

What is an Actor?

Components of Akka Actor

Akka Actor - ActorRef

Akka Actor - Dispatcher

Benefits of the dispatcher pattern

Akka Actor - Mailbox(MessageQueue)

Akka Actor - Actor

Akka Actor - ActorPath

Actor versus thread

The lifecycle of an Akka Actor

Actor's preStart() lifecycle method

Actor's postStop() lifecycle method.

Actor's preRestart() lifecycle method

Actor's postRestart() lifecycle method

Why Actors are lightweight?

Actor basic operations

Defining an Actor

Creating an Actor

Sending messages to an Actor

The tell (!) function

The ask (?) function

Replaying messages from an Actor

Actor to Actor communication

Actor to non-Actor communication

Stopping an Actor

Killing an Actor

Become/unbecoming an Actor

Case object Switch

Supervise an Actor

Akka Supervision

What is supervision?

What is the main goal of Akka's supervision?

Benefits of supervision

Why don't we write exceptions or failures handling in Actor itself?

Rules of Akka Supervision

Akka Supervision strategies

Akka's supervision hierarchy

Actor's Path

What is Akka's Let It Crash model?

Akka HelloWorld Actor example

Akka Actors communicate example

Akka Actor's lifecycle example

Akka parent-child Actors example

Actor's Path versus Reference

Differences between ActorRef and ActorPath

When we execute actorRef.tell (message), what happens internally?

MessageDispatcher

How to configure a dispatcher?

Akka Configuration

Akka SBT Templates

Akka Logging

Business problem

Problem discussion

Akka Actor's implementation

Chapter 5: Adding Reactiveness with RxScala

Introduction to RxScala

Reactive Extensions

Understanding Rx implementations

RxScala

Benefits of Reactive Extensions

Limitations of Reactive Extensions

Building blocks of RxScala

Understanding the Observable

Developing RxScala HelloWorld with an Observable

Observer

Extending RxScala HelloWorld with Observer

Subscriber

Extending RxScala HelloWorld with Subscriber

Subscription

Scheduler

RxScala Marble diagrams

RxScala's map() function

Summary.

Chapter 6: Extending Applications with Play

Introduction to Play Framework

What is Play Framework?

Features of Play Framework

Benefits of Play Framework

Why Play Framework is so fast?

Clients of Play Framework

Building blocks of Play Framework

Play Routings

Client Request

Controller Action

Routes

Play Controllers

View Templates

Benefits of Twirl Templates

Model and Forms

Other components - services and repositories

Configuration

Play Framework View Template constructs

Twirl View Templates

Twirl Template Constructs

Architecture of Play Framework

The new features of Play Framework

Play Framework 2.5.x features

Play Framework 2.6.x features

Play Application project structure

Play/Scala HelloWorld example

What is Play Dependency Injection (DI)

Benefits of DI

Extend HelloWorld Example With DI

Extending HelloWorld example with Scala Futures

Play Form - Data Model

Play Framework Form API

Play Form - Binding Data

Play Form functions

Play Framework Form-based web application

Extending Play/Scala HelloWorld example with Akka Toolkit

Play Fileupload web application

Chapter 7: Working with Reactive Streams

Introduction to Akka Streams

What is a stream?

Goals of data streaming

What is Akka Streams?

Goals of the Akka Streams API

Features of the Akka Streams API

Benefits of the Akka Streams API

Why do we need Akka Streams and why not just Akka?

Other Reactive Streams implementations

Components of Akka Streams

The Akka Streams API

What is streaming data?

The Akka Streams Source component

The Akka Streams Sink component

The Akka Streams Flow component

RunnableGraph or Graph

Modules of Akka Streams

Akka Materialization

What is materialization?

Akka's Materializer.

Akka's ActorMaterializer.

Notes:

Includes index.

Description based on online resource; title from PDF title page (EBC, viewed March 22, 2018).

ISBN:

9781787282872

1787282872

OCLC:

1463580720