This document provides an overview of reactive computing concepts with Scala examples. It discusses: 1. Reactive systems that react to events in their environment to create desirable effects. 2. Observable streams that push values and errors to registered observers, and can be composed using operators like map, filter, and combineLatest. 3. An immutable Scala implementation of a reactive snake game that processes keyboard events as streams to update the immutable snake and apple states, which are published as streams for the view. 4. Reactive Streams, the industry standard for asynchronous stream processing that specifies the interfaces between publishers, subscribers, and processing elements.

1. REACTIVE COMPUTING
W I T H S C A L A E X A M P L E S

2. Preview

3. Snake Game 3

4. Reactive Design 4
State
State
Snake
Apple
Stream
Combinator
Ticker
Input Game
State
Move
Turn
Grow
Game

5. Definitions

6. Academia 6
A reactive system is a system that, when switched on,
is able to create desirable effects in its environment
by reacting to events.

7. Typesafe 7

8. ReactiveX 8
The Observer pattern done right
ReactiveX is a combination of the best ideas from
the Observer pattern, the Iterator pattern, and
functional programming

9. Points to Remember 9
1 Events/Messages
2 Observer/Observable
3 Streams
4 Composition
5 Reacting
6 Effects

10. Computing
Concepts
Overview

11. Functions 11
INPUT
Needs to be passed in and can
be thought of as a single value
CALLER
Holds references to the
function, input and output
and it typically blocks to
wait for the output (pulls
returned values)
OUTPUT
Can be a value, another
function, Future, etc.
f
Input
Output

12. Generators and Iterators 12
NO INPUT
EXAMPLES
Python yield, Scala yield,
ES7, random number
generators, collections
exposed as iterators
OUTPUT
Varies based on some state and
needs to indicate termination
f
Output

13. Objects 13
ENCAPSULATED STATE
Typically not exposed directly
CALLER
Holds references to objects,
and it typically blocks to
wait for the methods’ return
values
PUBLIC INTERFACE
Methods are passed
arguments and return values
m
Input
Output
State
PublicMethods

14. Function/Object Composition 14
Input
Output
f
g
h
PROGRAMS
Can be seen as an
orchestration of functions and
object methods calls
COORDINATION
Function calls need to be
coordinated (think
concurrency, blocking,
synchronicity)
EXECUTION
Sequence of pushing and
pulling values to and from
functions/methods calls

15. Queues 15
PRODUCERS
Push values to the queue instead
of directly to consumers
QUEUES
Decouple producers from
consumers and help with
coordination (threads,
waits, delays, etc.)
CONSUMERS
Pull values from the queue
Producers Consumers

16. Actors 16
ACTORS
Receive messages asynchronously
on an internal queue
OUTPUT
Is optionally sent to another
actor
MESSAGES
Are pulled sequentially and
processed by a partial function
State

17. Observer Pattern 17
OBSERVABLE/SUBJECT
Pushes values to registered
observers/subscribers
NO DECOUPLING QUEUE
Between the observable and
observers, but the observable
could use one internally
OBSERVERS
Process values pushed by
the observable
Observable/Subject
Observers
abstract class SubjectObserver {
type S <: Subject
type O <: Observer
trait Subject {
// self-type annotation
// we can now use "self" as an alias for "this"
self: S =>
private var observers = List[O]()
def addObserver(observer: O) = observers ::= observer
def notifyObservers = observers foreach (_.onUpdate(self))
}
trait Observer {
def onUpdate(subject: S)
}
}

18. Streams

19. ReactiveX 19
An API for asynchronous
programming with
observable streams
CREATE
Easily create event streams or data streams.
COMBINE
Compose and transform streams with query-
like operators.
LISTEN
Subscribe to any observable stream to perform
side effects.

20. Observable Streams 20
OBSERVABLE
Pushes values and errors to
registered observers/subscribers
COMPOSITION
Observables can be composed
with an intuitive DSL
OBSERVERS
Implement onNext, onError and
onCompleted and are registered
with the observable
Observable
Observers

21. Subscriber API 21

22. Examples 22
CREATE
COMBINE AND LISTEN
snakeObservable.combineLatest(appleObservable).subscribe(
pair => {
Game.update(pair._1.body, pair._2)
},
(t: Throwable) => t.printStackTrace(),
() => {}
)
tick.subscribe(
_ => events.onNext(Move()),
(t: Throwable) => println("tick error : " + t),
() => {}
)
val tick = Observable.interval(Duration(150, TimeUnit.MILLISECONDS))
val events: PublishSubject[Event] = PublishSubject[Event]()

23. map 23

24. filter 24

25. combineLatest 25

26. scan 26

27. Reactive
Snake
Game

28. Observable Snake 28
EVENTS
Keyboard events are converted to
semantic events and streamed
COMPOSITION
Stream operators are used to
compose observables
STATE PUBLISHING
Event processing results in internal
state changes that are published/
streamed for view consumption

29. Scala Code 29
IMMUTABLE SNAKE STATE
SNAKE EVENTS PROCESSING AND STATE PUBLISHING
case class Snake(body: List[WorldLocation], direction: WorldLocation) {
def go(toDirection: WorldLocation): Snake = Snake(body, toDirection)
def moved: Snake = Snake((head + direction) :: body.take(body.size - 1), direction)
def grown: Snake = Snake((head + direction) :: body, direction)
def head: WorldLocation = body.head
}
def createSnake(init: Snake, events: Observable[Event]): Observable[Snake] = {
events
.scan(init)((snake, event) => event match {
case Move() => snake.moved
case Grow() => snake.grown
case Turn(direction) => snake.go(direction)
})
}
APPLE EVENTS PROCESSING AND STATE PUBLISHING
def createApple(init: WorldLocation, snakeObservable: Observable[Snake],
events: Subject[Event, Event]): Observable[WorldLocation] = {
snakeObservable.scan(randomLocation())((loc: WorldLocation, snake: Snake) => snake.head match {
case head if head == loc =>
events.onNext(Grow())
randomLocation()
case _ => loc
})
}

30. Industry
Standardization

31. Reactive Streams 31

32. Reactive Streams Flow 32

33. State
Subjects

34. Computation Ingredients 34
Event Processor
The processor can be thought
of as a partial function whose
domain consists of all possible
events and whose output is the
new internal state.
External State/Value
Internal state is converted to
ideally one single external value
to be published on change
Internal State
If the computation is
stateful then the initial
state evolves based on the
events that are
subsequently processed

35. State Subjects 35
SUBJECT
The component is both
subscribing and publishing events
OUTPUT
The external value(s) are
published so any subscriber
can read to them
MESSAGE PASSING
No methods and no return
values
State

36. Comparison 36
Domain-Like Entities
Service-Like
filter-scan-map
4
5
63
2
1
Similar to Actors
Similar to Objects
Composable
State Subject
State

37. Alan Kay 37
It was probably in 1967 when someone asked me what I was doing, and I
said: "It's object-oriented programming”.
I thought of objects being like biological cells and/or individual
computers on a network, only able to communicate with messages.
The key in making great and growable systems is much more to design
how its modules communicate rather than what their internal properties
and behaviors should be.
http://c2.com/cgi/wiki?AlanKayOnMessaging
http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en