Downloaded 18 times
![Reactive applications
Promise
Writeable, single-assignment container, which completes a
Future
import scala.concurrent.{ future, promise }
val p = promise[T]
val f = p.future
val producer = future {
val r = produceSomething()
p success r
ContinueDoingSomethingUnrelated()}
val consumer = future {
startDoingSomething()
f onSuccess {
case r => doSomethingWithResult()
}
28
}](https://image.slidesharecdn.com/linuxday2013massimilianodessireactiveapplications-131105152740-phpapp01/85/Reactive-applications-Linux-Day-2013-28-320.jpg)
Uploaded byMassimiliano Dessì
Reactive applications Linux Day 2013
This document discusses reactive applications and the tools used to build them. Reactive applications are event-driven, scalable, resilient, and responsive. They react quickly to events, failures, loads, and through user interfaces. Key tools for building reactive applications include actors, agents, futures, and functional reactive programming. Actors communicate asynchronously through message passing. Agents are reactive memory cells that update asynchronously. Futures allow non-blocking composition. Functional reactive programming uses streams to model events over time.
More Related Content
Similar to Reactive applications Linux Day 2013
Reactive applications Linux Day 2013
- 1.
- 2. Reactive applications Speaker Massimiliano Dessìhas more than 13 years of experience in programming. He’s a proud father of three. @desmax74 Manager of GDG Sardegna, Founder of S SpringFramework IT, co-founder of Jug Sardegna. Author of Spring 2.5 AOP. He works and lives in Cagliari, Italy. 2
- 3.
- 4. Reactive applications Software requirementsnowadays Highly Responsive, Real Time Scalable Resilient Petabytes 4
- 5. Reactive applications New problems Weneed better tools 5 http://www.pacificrimmovie.net/
- 6. Reactive applications Reactive “readily responsiveto a stimulus” Component active and ready to respond to event Event Driven 6
- 7. Reactive applications Reactive React toevents → Event Driven React to failure → Resilient React through a UI → Interactive React to load → Scalable 7
- 8. Reactive applications React toevent - Event driven Asyncronous and loosely coupled + Non blocking = lower latency and higher throughput 8
- 9. Reactive applications React toevent - Event driven Productors push asyncronously data towards consumers (message passing) better resource usage instead of having consumers continually ask for data 9
- 10. Reactive applications React toevent - Event driven Non blocking operation mean have all the time the application responsive even under failure 10
- 11. Reactive applications Event driven Actors, No shared mutable state Promise , Composable Message passing asyncronous, non Blocking Lock free concurrency 11
- 12. Reactive applications Scalable “Capable ofbeing easily expanded or upgraded on demand” Event driven and message passing are the foundations 12
- 13. Reactive applications Scalable “loose couplingand location independence between components and subsystems make it possible to scale out the system onto multiple node” Location transparency != transparent distributed computing 13
- 14. Reactive applications Resilient “the capacityto recover quickly from difficulties” In a reactive application, resilience is part of the design from the beginning 14
- 15. Reactive applications Resilient Bulkheads andCircuit Breaker patterns Isolate failure Manage Failure locally Avoid cascading failure 15
- 16. Reactive applications Resilient Bulkheads Failure ismodeled explicitly in order to be compartmentalized, observed, managed and configured in a declarative way, and where the system can heal itself and recover automatically 16
- 17. Reactive applications Resilient Actor lightweightisolated process (400 bytes of heap space) Each process has its own supervisor In case of failure the supervisor receive as async msg the error The supervisor can choose the recovery strategy kill, restart, suspend/resume 17
- 18. Reactive applications Resilient Actor decouplingbusiness logic from handling error Mailbox Guaranteed Delivery my-dispatcher { mailbox-type = akka.actor.mailbox.filebased.FileBasedMailboxType } 18
- 19. Reactive applications Resilient override valsupervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: java.sql.SQLException => Resume case _: NullPointerException => Restart case _: Exception => Escalate } 19
- 20. Reactive applications Resilient A circuitbreaker is used to provide stability and prevent cascading failures in distributed systems. val breaker = new CircuitBreaker( context.system.scheduler, maxFailures = 5, callTimeout = 10.seconds, resetTimeout = 1.minute).onOpen(notifyMeOnOpen()) doc.akka.io/docs/akka/current/common/circuitbreaker.html 20
- 21. Reactive applications Responsive quick torespond or react appropriately Reactive applications use observable models, event streams and stateful clients. 21
- 22.
- 23. Reactive applications Tools Actors Share nothing Eachactor has a Mailbox (message queue) Comunicates through async and non blocking message passing Location transaparent 23
- 24. Reactive applications Tools Agents Reactive memorycells Send an update function to the agent which: 1) add to an ordered queue, to be 2)applied to the agent async and non blocking Reads are “free” Composes http://clojure.org/agents 24
- 25. Reactive applications Agent import scala.concurrent.ExecutionContext.Implicits.global importakka.agent.Agent val agent = Agent(5) agent.send(7); //Update (atomically and asyncronously) val result = agent.get //Reading an Agent's current value happens immediately If an Agent is used within an enclosing Scala STM transaction, then it will participate in that transaction 25
- 26. Reactive applications Tools Futures Span concurrencywith not yet computed result Write once, read many Freely sharable Allows non blocking composition Monadic Built in model for managing failure 26
- 27. Reactive applications Future Future Read-onlyplaceholder val f1 = Future { "Hello" + "World"} val f2 = f1 map { x ⇒ x.length } val result = Await.result(f2, 1 second) 27
- 28. Reactive applications Promise Writeable, single-assignmentcontainer, which completes a Future import scala.concurrent.{ future, promise } val p = promise[T] val f = p.future val producer = future { val r = produceSomething() p success r ContinueDoingSomethingUnrelated()} val consumer = future { startDoingSomething() f onSuccess { case r => doSomethingWithResult() } 28 }
- 29. Reactive applications Tools Functional reactiveprogramming Extends futures with concept of stream Functional variation of the observer pattern A signal attached to a stream of events The signal is reevaluated for each event Model events on a linear timeline deterministic Compose nicely Rx, RXJava, Scala.RX, Reactive.js, Knockout.js 29
- 30. Reactive applications References ● http://www.reactivemanifesto.org/ ● http://akka.io/ (JAVAand SCALA API) ● Deprecating the observer pattern http://lampwww.epfl.ch/~imaier/pub/DeprecatingObserversTR 2010.pdf 30
- 31.
- 32. Reactive applications Thanks foryour attention 32