Index
A
- Actor
- about / What's an Actor anyway?, Actors and Message passing
- creating / Creating your first Actor, Creating an actor
- responding, via Future / Having an Actor respond via a future
- remote access, enabling to / Enabling remoting
- messaging patterns / Messaging delivery
- terminating / Terminating or killing an Actor
- killing / Terminating or killing an Actor
- selecting, for Concurrency / Choosing Futures or Actors for concurrency
- working in parallel with / Doing work in parallel, Doing work in parallel with Actors
- testing / Testing actors
- test, using as / Using the test Itself as an Actor
- Actor, anatomy
- about / Anatomy of an Actor
- Java Actor API / Java Actor API
- Scala Actor API / Scala Actor API
- Actor Behavior
- testing / Testing Actor behavior and state
- Actor Code
- writing / Writing some Actor Code
- Actor model
- about / Actor Model origins, Actors and Message passing
- examples / Actors and Message passing
- Actor response, defining to message
- about / Defining Actor response to the Message
- in Java / Java – AkkademyDb.java
- in Scala / Scala – AkkademyDb.scala
- Actors
- Configured Dispatcher, using with / Using a configured dispatcher with Actors
- Actor State
- testing / Testing Actor behavior and state
- Actor system
- about / Actors and Message passing
- main method, used for starting / Main
- Agent module
- Akka
- about / What is Akka
- examples / What we will build, Example 2 – getting lots of work done
- adding, to build.sbt / Adding Akka to build.sbt
- akka-cluster tool
- reference link / Leaving the Cluster Gracefully
- akka.actor.Identify
- used, for finding remote actor / Using akka.actor.Identify to Find a Remote Actor
- akka.cluster.seed-nodes configuration / Seed Nodes
- Akka application
- Akka Cluster / The Evolution of distribution and location transparency
- about / Introducing Akka Cluster
- systems, building with / Building Systems with Akka Cluster
- creating / Creating the Cluster
- project, configuring / Configuring the Project
- starting / Starting the Cluster
- leaving / Leaving the Cluster Gracefully
- Akka features, and modules
- about / Other Akka Features and Modules
- logging / Logging in Akka
- EventBus object / Message Channels and EventBus
- Message Channels / Message Channels and EventBus
- Agent / Agents
- Akka Persistence / Akka Persistence
- Akka I/O / Akka I/O
- Akka Streams / Akka streams and HTTP
- Akka HTTP / Akka streams and HTTP
- Akka HTTP / The Evolution of distribution and location transparency
- about / Akka streams and HTTP
- Akka I/O
- Akka IO / The Evolution of distribution and location transparency
- Akka Mailboxes
- reference link / Configuring mailboxes
- Akka Persistence
- about / Akka Persistence
- Akka Streams
- about / Akka streams and HTTP
- Akka Streams Reactive Streams
- reference link / Circuit breaker examples
- Akka testkit
- about / Akka Testkit
- Java source code / Java
- Scala source code / Scala
- Amazon EC2 instances (AWS) / Failure Detection
- Amazon Web Server (AWS) / The network is reliable
- application design
- approaching / Approaching application design
- Article Parsing Dispatcher / Article parsing dispatcher
- Ask message pattern
- about / Messaging delivery, Ask message pattern
- example application, designing with / Designing with Ask
- callbacks execute, in another execution context / Callbacks execute in another execution context
- timeouts, need for / Timeouts are required
- timeout stacktraces, drawbacks / Timeout stacktraces aren't useful
- hidden overhead / Ask has overhead
- complexity of Actors / Complexity of Actors and Ask
B
- BalancingDispatcher / Creating Dispatchers
- BalancingPool / Routing logic
- Ballooning Response Times
- about / Ballooning response times
- become() method / Hotswap: Become/Unbecome
- Behavior
- defining, in Finite State Machine (FSM) / Defining behavior in FSMs
- Blocking
- versus Event-Driven APIs / Blocking versus event-driven APIs
- broker
- about / Redundancy
- build.sbt
- Akka, adding to / Adding Akka to build.sbt
- modifying / Modifying build.sbt
C
- CallingThreadDispatcher / Creating Dispatchers
- CAP Theorem
- about / CAP Theorem
- consistency / C – Consistency
- availability / A – Availability
- partition tolerance / P – Partition Tolerance
- Circuit Breaker Listeners
- about / Circuit breaker listeners
- Circuit Breakers
- about / Circuit breakers
- examples / Circuit breaker examples
- client
- producing / Producing the client
- building / Building the client
- cluster
- about / Definition of a Cluster
- failure detection / Failure Detection
- messages, routing to / Routing Messages to the Cluster
- designing / Designing the Cluster
- basic key-value store design / Basic Key-Value Store Design
- cluster client, building for clustered services
- about / Cluster Client for Clustered Services
- server project, setting up / Setting up the Server Project
- client project, setting up / Setting up the Client Project
- Message class, sharing between client and server / Sharing the Message Class between Client and Server
- messages, sending to cluster / Sending Messages to the Cluster
- distributed key value store, building / Building a Distributed Key Value Store
- cluster events
- subscribing to / Subscribing to Cluster Events
- cluster member states
- about / Cluster Member States
- failure detection / Failure Detection
- Cluster Specification
- reference link / Gossiping an Eventually Consistent View
- code
- validating, with unit tests / Validating the code with unit tests
- mailboxes, sending in / Selecting a mailbox in code
- compromises, in CAP theorem
- about / Compromises in CAP Theorem
- CP system / CP System – Preferring Consistency
- AP system / AP System – Preferring Availability
- consistency, as sliding state / Consistency as a Sliding Scale
- Concurrency
- Actor, selecting for / Choosing Futures or Actors for concurrency
- Futures, selecting for / Choosing Futures or Actors for concurrency
- Conditional Statements
- about / Conditional statements
- Configured Dispatcher
- using, with Actors / Using a configured dispatcher with Actors
- Consistent Hashing / Routing logic
- Coursera Courses
- about / Coursera Courses
- references / Coursera Courses
- crashing
- about / Crashing
D
- DB
- preparing / Preparing the DB and messages
- starting / Starting the DB
- DB Functionality
- implementing / Implementing the DB functionality
- default dispatcher
- about / Default Dispatcher
- dependencies
- adding, from Maven Central / Adding other Dependencies from Maven Central
- Deployment Configuration
- mailboxes, sending in / Selecting a mailbox in deployment configuration
- deployment tools
- about / Deployment Tools
- dispatchers
- working with / Working with Dispatchers, Dispatchers explained
- creating / Creating Dispatchers
- about / Creating Dispatchers
- deciding, for usage / Deciding Which Dispatcher to use where
- distributed article parse service
- producing / Producing a Distributed Article Parse Service
- Distributed Computing
- Fallacies / The 8 Fallacies of Distributed Computing
- Distributed System
- distributed systems
- reference link / One Giant Monolith or Many Micro Services?, Redundant Nodes
- distribution
- domain, entities
- chatroom / Approaching application design
- user / Approaching application design
- lobby / Approaching application design
- domain model
- designing / Designing, building, and testing the Domain model, Designing the Domain model
- building / Designing, building, and testing the Domain model, Testing and building the Domain model
- testing / Designing, building, and testing the Domain model, Testing and building the Domain model
- specifications / Specifications
- building, by specification / Building by specification
- Domain Specific Languages (DSL)
- about / Ask message pattern
- Drunken Sushi Chef
E
- Eclipse
- about / Eclipse
- project, preparing for / Preparing the project for Eclipse
- project, importing into / Importing the project into Eclipse
- Eclipse (Scala-Ide)
- Elasticsearch
- about / Monitoring Logs and Events
- environment
- setting up / Setting up your environment
- Event-Driven APIs
- versus Blocking / Blocking versus event-driven APIs
- Event-Driven Programming Models
- EventBus object
- about / Message Channels and EventBus
- references / Message Channels and EventBus
- events
- monitoring / Monitoring Logs and Events
- Eventually Consistent View
- example application
- designing, with Ask message pattern / Designing with Ask
- example problem
- stage, setting with / Setting the stage with an example problem
- executors
- about / Executors
F
- failure
- about / Failure
- isolating / Isolating failure
- Failure Cases, Futures
- handling / Handling failure cases
- code, executing / Executing code in the failure case
- recovering from failure / Recovering from failure
- recovering from failure, asynchronously / Recovering from failure asynchronously
- failure detection, Cluster Specification document
- reference link / Failure Detection
- Fallacies, of Distributed Computing
- about / The 8 Fallacies of Distributed Computing
- reliable network / The network is reliable
- zero latency / Latency is zero
- infinite bandwidth / Bandwidth is infinite
- secure network / The network is secure
- network topology doesn't change / Network topology doesn't change
- one administrator / There is one administrator
- zero transport cost / Transport cost is zero
- homogeneous network / The network is homogeneous
- fault-tolerance
- Finite State Machines (FSM)
- about / Finite State Machines (FSM)
- Behavior, defining in / Defining behavior in FSMs
- Forward message pattern
- about / Messaging delivery, Forward
- Future Cheat Sheet
- about / Future cheat-sheet
- Futures
- about / Promises, futures, and event-driven programming models, Understanding futures and promises
- Actor, responding via / Having an Actor respond via a future
- failure, expressing in types / Future – expressing failure and latency in types
- latency, expressing in types / Future – expressing failure and latency in types
- Java8 examples, preparing / Preparing for the Java example
- Scala examples, preparing / Preparing for Scala examples
- anatomy / Anatomy of a future
- Success Cases, handling / Handling success cases
- Failure Cases, handling / Handling failure cases
- composing / Composing futures
- operatoions, chaining together / Chaining operations together
- combining / Combining futures
- selecting, for Concurrency / Choosing Futures or Actors for concurrency
- working in parallel with / Doing work in parallel, Doing work In parallel with futures
- IO Dispatcher Use, blocking with / Blocking IO dispatcher use with futures
H
- high level design
- about / High-Level design
I
- IDE
- installing / Installing an IDE
- installation, Eclipse (Scala-Ide) / Installing Eclipse (Scala-Ide)
- installation, IntelliJ CE
- about / Install IntelliJ CE
- installation, Java
- on Windows / Installing on Windows
- on OSX / Installing on OS X
- on Linux / Installing on Linux or Unix (Universal instructions)
- on Unix / Installing on Linux or Unix (Universal instructions)
- installation, Scala / Installing Scala
- installation, Typesafe Activator
- about / Installing Typesafe Activator
- on Windows / Windows
- on Linux / Linux/Unix/OS X
- on Unix / Linux/Unix/OS X
- on OSX / OS X
- integrated development environment (IDE)
- about / Chapter overview
- integration tests / Testing
- IntelliJ CE
- installing / Install IntelliJ CE
- IO Dispatcher Use
- blocking, with Futures / Blocking IO dispatcher use with futures
J
- Java
- configuration, ensuring / Ensuring Java is configured in your environment
- Java, installing
- about / Installing Java – Oracle JDK8
- on Windows / Installing on Windows
- on OSX / Installing on OS X
- on Linux / Installing on Linux or Unix (Universal instructions)
- on Unix / Installing on Linux or Unix (Universal instructions)
- Java8 examples
- about / Java example
- Scala Futures / Working with Scala futures
- test case / Test case
- Actor Creation / Actor creation
- Java Actor API
- about / Java Actor API
- Java Database Connectivity (JDBC)
- Java SE 8, Lambda Quick Start
- reference link / Installing Java – Oracle JDK8
K
- keys
- redistributing, to nodes / Pre-Sharding And Redistributing Keys to New Nodes
- Kibana
- about / Monitoring Logs and Events
L
- language
- selecting / Choosing a language
- Linux
- Java, installing on / Installing on Linux or Unix (Universal instructions)
- Typesafe Activator, installing on / Linux/Unix/OS X
- linux tar.gz JDK distribution, Oracle
- download link / Installing on Linux or Unix (Universal instructions)
- Lists of Futures
- dealing with / Dealing with lists of futures
- location transparency
- logging, in Akka
- about / Logging in Akka
- logs
- monitoring / Monitoring Logs and Events
- Logstash
- about / Monitoring Logs and Events
M
- mailbox
- about / Actors and Message passing
- mailboxes
- about / Mailboxes
- configuring / Configuring mailboxes
- selecting, in Deployment Configuration / Selecting a mailbox in deployment configuration
- selecting, in code / Selecting a mailbox in code
- deciding, for configuration / Deciding which mailbox to use
- messages, prioritizing in / Prioritizing messages in mailboxes
- mailing address
- about / Actors and Message passing
- main method
- used, for starting actor system / Main
- Maven Central
- dependencies, adding from / Adding other Dependencies from Maven Central
- message
- about / Actors and Message passing
- making / Making the Message first
- making, in Java / Java
- making, in Scala / Scala
- message-passing
- about / Actors and Message passing
- Message Channels
- about / Message Channels and EventBus
- message flow
- testing / Testing Message flow
- message passing
- about / Actors and Message passing
- messages
- preparing / Preparing the DB and messages
- about / The messages
- publishing / Publishing the messages
- immutable / Messages should be immutable
- stashing, between states / Stashing messages between states
- routing, to cluster / Routing Messages to the Cluster
- prioritizing, in mailboxes / Prioritizing messages in mailboxes
- messaging delivery
- about / Messaging delivery
- messaging patterns, Actor
- Ask / Messaging delivery, Ask message pattern
- Tell / Messaging delivery, Tell
- Forward / Messaging delivery, Forward
- Pipe / Messaging delivery, Pipe
- microservices
- reference link / One Giant Monolith or Many Micro Services?
- Mock Actors
- TestProbes, using as / Using TestProbes as mock Actors
- Moore's Law
- about / Moore's law
- multicore architecture, as distribution problem
N
- node
- coordinating / Coordinating Node
- nodes
- keys, redistributing to / Pre-Sharding And Redistributing Keys to New Nodes
O
- Offline State
- about / Online/Offline state
- Online State
- about / Online/Offline state
- Optimal Parallelism
- about / Optimal parallelism
- Oracle Java8 lambda primer
- reference link / Skills check-point
- OSX
- Java, installing on / Installing on OS X
- Typesafe Activator, installing on / OS X
- OSX JDK8 installer (dmg), Oracle
- download link / Installing on OS X
P
- Pinned Dispatcher / Creating Dispatchers
- Pipe message pattern
- about / Messaging delivery, Pipe
- pre-sharding
- project
- creating / Creating a new project
- preparing, for Eclipse / Preparing the project for Eclipse
- importing, into Eclipse / Importing the project into Eclipse
- scaffolding / Scaffolding the project
- sketching / Sketching the project
- core functionality / Core functionality
- Promises
- Props
- about / Props
R
- Reactive Manifesto
- about / Reactive system design
- reference link / Reactive system design
- Reactive platform
- about / Reactive system design
- Reactive Streams
- about / Circuit breaker examples
- URL / Circuit breaker examples
- reference link / Circuit breaker examples
- Reactive System Design
- about / Reactive system design
- Reactive Tenet Correlation
- about / Reactive Tenet Correlation
- Reactive Tenets
- about / The 4 reactive tenets
- Responsive / Responsive
- Elastic / Elastic
- Resilient / Resilient
- Event-Driven/Message-Driven / Event-driven/message-driven
- Red Hat Enterprise Linux (RHEL) / Installing on Linux or Unix (Universal instructions)
- redundancy
- about / Redundancy
- redundant nodes / Redundant Nodes
- remote access
- enabling, to Actor / Enabling remoting
- remote actor
- addressing / Addressing Remote Actors
- finding, akka.actor.Identify used / Using akka.actor.Identify to Find a Remote Actor
- resiliency
- about / Resiliency
- responsive
- staying, under load / Staying responsive under load
- Restarts
- used, for transition through states / Using restarts to transition through states
- right Scala version
- obtaining, with %% / A note on getting the right Scala version with %%
- Round-trip Delay Time (RTD or RTT) / Finite State Machines (FSM)
- Round Robin / Routing logic
- Routees
- supervising, in Router Pool / Supervising the Routees in a Router Pool
- Router
- about / Introducing Routers
- Router Group/Pool
- messages, sending to actor / Sending Messages to All Actors in a Router Group/Pool
- Router Pool
- Routees, supervising in / Supervising the Routees in a Router Pool
- Routing Logic
- about / Routing logic
- Routing Strategies
- Round Robin / Routing logic
- Smallest Mailbox / Routing logic
- Scatter Gather / Routing logic
- Tail Chopping / Routing logic
- Consistent Hashing / Routing logic
- BalancingPool / Routing logic
S
- sbteclipse github project
- reference link / Preparing the project for Eclipse
- SBT Project
- Scala
- installing / Installing Scala
- Scala-Ide
- download link / Installing Eclipse (Scala-Ide)
- Scala Actor API
- about / Scala Actor API
- Scala example
- about / Scala example
- test case / Test case
- Actor Creation / Actor creation
- Scala Futures
- working with / Working with Scala futures
- Scatter Gather / Routing logic
- sharding, and replication
- combining / Combining Sharding and Replication
- sharding, for linear scalability / Sharding for Linear Scalability
- simple build tool (SBT) / Installing Typesafe Activator, Creating your first Akka application – setting up the SBT project
- skills Check-point
- about / Skills check-point
- Sleeping
- about / Note on sleeping
- Smallest Mailbox / Routing logic
- stage
- setting, with example problem / Setting the stage with an example problem
- Stash Leaks
- about / Stash leaks
- State
- about / State
- Online State / Online/Offline state
- Offline State / Online/Offline state
- State Container
- defining / Defining the state container
- States
- defining / Defining states
- states
- messages, stashing between / Stashing messages between states
- Success Cases, Futures
- handling / Handling success cases
- code, executing with result / Executing code with the result
- result, transforming / Transforming the result
- result, transforming asynchronously / Transforming the result asynchronously
- supervision
- evolution / The Evolution of supervision and fault tolerance in Erlang
- about / Supervision
- actor lifecycle / Actor lifecycle
- messages, in restart / Messages in restart, stop
- messages, in stop / Messages in restart, stop
- lifecycle monitoring / Lifecycle monitoring and DeathWatch
- DeathWatch / Lifecycle monitoring and DeathWatch
- Supervision Hierarchies
- about / Supervision hierarchies
- supervision strategies
- supervisor strategies
- defining / Defining supervisor strategies
- systems
- building, with Akka Cluster / Building Systems with Akka Cluster
T
- Tail Chopping / Routing logic
- Tell message pattern
- about / Messaging delivery, Tell
- designing with / Designing with Tell, Handling replies with Tell , Scheduling a Tell Timeout, Avoiding Ask with an Anonymous Actor
- test
- using, as Actor / Using the test Itself as an Actor
- testing
- advice / Testing Advice
- TestProbes
- using, as Mock Actors / Using TestProbes as mock Actors
- tests
- running / Running the test
- threads, blocking in / Blocking threads in tests
- threads
- blocking, in tests / Blocking threads in tests
- Transitioning State / Transitioning state
- Typesafe Activator
- download link / Windows
- Typesafe Activator, installing
- about / Installing Typesafe Activator
- on Windows / Windows
- on Linux / Linux/Unix/OS X
- on Unix / Linux/Unix/OS X
- on OSX / OS X
U
- Ubiquitous Language / Designing the Domain model
- unbecome() method / Hotswap: Become/Unbecome
- unit tests
- code, validating with / Validating the code with unit tests
- Unix
- Java, installing on / Installing on Linux or Unix (Universal instructions)
- Typesafe Activator, installing on / Linux/Unix/OS X
V
- Vector Clocks
- reference link / Redundant Nodes
- Virtual Machine (VM) / The network is homogeneous
W
- Windows
- Java, installing on / Installing on Windows
- Typesafe Activator, installing on / Windows
- windows JDK8 installer (dmg), Oracle
- download link / Installing on Windows