Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1Eg26yd. Rachel Reese sees reactive services and functional languages as a natural pair, demonstrating how functional concepts such as mailboxes and async workflows can help one craft reactive services. Filmed at qconsf.com. Rachel Reese is a long-time software engineer and math geek who can often be found talking to random strangers about the joys of functional programming and F#.

1. Building Reactive Services
using Functional Programming
Rachel Reese
@rachelreese | github: rachelreese | rachelree.se

2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/reactive-services-fp

3. Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
Presented at QCon San Francisco
www.qconsf.com

4. Reactive manifesto
Responsive
Message-driven
Resilient
Elastic
New!

5. Responsive
The system responds in a timely manner if at all possible. Responsiveness is the
cornerstone of usability and utility, but more than that, responsiveness means
that problems may be detected quickly and dealt with effectively. Responsive
systems focus on providing rapid and consistent response times, establishing
reliable upper bounds so they deliver a consistent quality of service. This
consistent behavior in turn simplifies error handling, builds end user
confidence, and encourages further interaction.

6. Events

7. Events in F#
Immutable
Implement
IObservable
First-class Composable

8. First class! Composable!

9. Event combinators
Add Choose Filter Map Merge
Pairwise Partition Scan Split

10. Async workflows
An application of F#’s computation expression syntax.

11. Computation expressions
A single syntactic mechanism
which gives a nice syntax for
multiple abstract computation
types.
Monads, yes
But also:
Applicative functors
Monoids
Additive monads*
Computations constructed using
monad transformers*

12. Async vs. concurrent vs. parallel
•Non-blocking, specifically in reference to I/O operations (not necessarily
parallel, can be sequential).
Asynchronous
•Multiple operations happening at the same time (not necessarily in parallel).
Concurrent
•Multiple operations processed simultaneously.
Parallel

13. Async workflows
Reads similarly to classic, linear synchronous code
Easy to convert
Easy to understand and reason about.

14. Consider classic synchronous
code

15. Async workflow

16. Async workflow

17. Message-driven
Reactive Systems rely on asynchronous message-passing to establish a boundary between
components that ensures loose coupling, isolation, location transparency, and provides the
means to delegate errors as messages. Employing explicit message-passing enables load
management, elasticity, and flow control by shaping and monitoring the message queues in
the system and applying back-pressure when necessary. Location transparent messaging as a
means of communication makes it possible for the management of failure to work with the
same constructs and semantics across a cluster or within a single host. Non-blocking
communication allows recipients to only consume resources while active, leading to less
system overhead.

18. The actor model
An actor is an independent
computational entity which
contains a queue, and
receives and processes
messages.
The actor model is a model of
concurrent computation using
actors which is characterized by
dynamic creation of actors,
inclusion of actor addresses in
messages, and interaction only
through direct asynchronous
message passing with no
restriction on message arrival
order.

19. F# Agents
Actor = Agent = MailboxProcessor

20. Agents: basic syntax

21. Getting replies from an agent

22. Scanning an agent’s queue

23. One major difference from Erlang
F# agents do not work across process boundaries, only
within the same process.
Enter Cricket (previously FSharp.Actor)

24. Cricket

25. Cricket remoting

26. Cricket

27. Resilient
The system stays responsive in the face of failure. This applies not only to highly-
available, mission critical systems — any system that is not resilient will be
unresponsive after a failure. Resilience is achieved by replication, containment,
isolation and delegation. Failures are contained within each component, isolating
components from each other and thereby ensuring that parts of the system can fail
and recover without compromising the system as a whole. Recovery of each
component is delegated to another (external) component and high-availability is
ensured by replication where necessary. The client of a component is not burdened
with handling its failures.

28. Error handling
Tasks that are run using Async.RunSynchronously
report failures back to the controlling thread as an
exception. Use Async.Catch or try/catch to handle.
Async.StartWithContinuations has an exception
continuation.
Supervisor pattern.

29. Async.Catch

30. Async.StartWithContinuations
Getting replies from an agent

31. Async.StartWithContinuations
Scanning an agent

32. Supervisors

33. Supervisors

34. Elastic
The system stays responsive under varying workload. Reactive Systems can react
to changes in the input rate by increasing or decreasing the resources allocated
to service these inputs. This implies designs that have no contention points or
central bottlenecks, resulting in the ability to shard or replicate components and
distribute inputs among them. Reactive Systems support predictive, as well as
Reactive, scaling algorithms by providing relevant live performance measures.
They achieve elasticity in a cost-effective way on commodity hardware and
software platforms.

35. Scaling agents on demand

36. More resources
https://github.com/DCFsharp/ConcurrencyInFsharp
http://fsprojects.github.io/FSharp.Control.Reactive/
https://github.com/fsprojects/Cricket
http://tomasp.net/blog/csharp-async-gotchas.aspx/

37. Building Reactive Services
using Functional Programming
Rachel Reese
@rachelreese | github: rachelreese | rachelree.se

38. Watch the video with slide synchronization on
InfoQ.com!
http://www.infoq.com/presentations/reactive-
services-fp