by Raymond Roestenburg, Rob Bakker, Rob Williams | Released September 2016 | ISBN: None

"The most readable and up-to-date treatment of Akka I have seen." Kevin Esler, TimeTrade Systems Akka in Action shows you how to build message-oriented systems with Akka. This comprehensive, hands-on tutorial introduces each concept with a working example. You'll start with the big picture of how Akka works, and then quickly build and deploy a fully functional REST service out of actors. You'll explore test-driven development and deploying and scaling fault-tolerant systems. After mastering the basics, you'll discover how to model immutable messages, implement domain models, and apply techniques like event sourcing and CQRS. You'll also find a tutorial on building streaming applications using akka-stream and akka-http. Finally, you'll get practical advice on how to customize and extend your Akka system. Akka makes it relatively easy to build applications in the cloud or on devices with many cores that efficiently use the full capacity of the computing power available. It's a toolkit that provides an actor programming model, a runtime, and required support tools for building scalable applications. Inside: Getting concurrency right Testing and performance tuning Clustered and cloud-based applications Covers Akka version 2.4 This book/course assumes that you're comfortable with Java and Scala. No prior experience with Akka required. A software craftsman and architect, Raymond Roestenburg is an Akka committer. Rob Bakker specializes in concurrent back-end systems and systems integration. Rob Williams has more than 20 years of product development experience. A great way to get started and go beyond the basics with Akka. Andy Hicks, London Scala Users Group A user's guide to Akka in the real world! William E. Wheeler, TEKsystems A really useful book. Every chapter has working, real-world code that illustrates how to get things done using Akka. Iain Starks, Game Account Network NARRATED BY MARK THOMAS Show and hide more

1. Chapter 1. Introducing Akka 00:08:14
2. Chapter 1. What is Akka? 00:08:29
3. Chapter 1. Traditional scaling 00:07:35
4. Chapter 1. Traditional scaling and interactive use: polling 00:05:16
5. Chapter 1. Scaling with Akka 00:05:58
6. Chapter 1. Scaling with Akka and failure: asynchronous decoupling 00:04:59
7. Chapter 1. Actors: one programming model to rule up and out 00:02:57
8. Chapter 1. Actor operations 00:09:39
9. Chapter 1. Akka actors 00:09:22
10. Chapter 2. Up and running 00:06:52
11. Chapter 2. Fast-forward to the GoTicks.com REST server 00:05:08
12. Chapter 2. Structure of the app 00:05:40
13. Chapter 2. The actor that handles the sale: TicketSeller 00:07:36
14. Chapter 2. Into the cloud 00:06:23
15. Chapter 3. Test-driven development with actors 00:08:45
16. Chapter 3. One-way messages 00:08:50
17. Chapter 3. SendingActor example 00:07:19
18. Chapter 3. SideEffectingActor example 00:07:16
19. Chapter 4. Fault tolerance 00:05:29
20. Chapter 4. Plain old objects and exceptions 00:08:18
21. Chapter 4. Let it crash 00:06:43
22. Chapter 4. Actor lifecycle 00:04:04
23. Chapter 4. Restart event 00:08:54
24. Chapter 4. Supervision 00:06:10
25. Chapter 4. Predefined strategies 00:03:35
26. Chapter 4. Custom strategies 00:06:59
27. Chapter 5. Futures 00:11:04
28. Chapter 5. In the future nobody blocks 00:08:14
29. Chapter 5. Promises are promises 00:04:52
30. Chapter 5. Futuristic errors 00:06:41
31. Chapter 5. Combining futures 00:10:27
32. Chapter 5. Combining futures with actors 00:03:37
33. Chapter 6. Your first distributed Akka app 00:06:43
34. Chapter 6. Reasons for a distributed programming model 00:06:08
35. Chapter 6. Making the GoTicks.com app distributed 00:07:58
36. Chapter 6. Remote lookup 00:09:29
37. Chapter 6. Remote deployment 00:07:24
38. Chapter 6. Multi-JVM testing 00:08:12
39. Chapter 6. Summary 00:03:02
40. Chapter 7. Configuration, logging, and deployment 00:06:52
41. Chapter 7. Using defaults 00:05:35
42. Chapter 7. Akka configuration 00:06:21
43. Chapter 7. Logging 00:07:53
44. Chapter 7. Deploying actor-based applications 00:06:27
45. Chapter 8. Structural patterns for actors 00:05:00
46. Chapter 8. Pipes and filters in Akka 00:04:20
47. Chapter 8. Enterprise integration pattern: scatter-gather 00:08:22
48. Chapter 8. Implementing the gather component with the aggregator pattern 00:08:39
49. Chapter 8. Enterprise integration pattern: routing slip 00:07:06
50. Chapter 9. Routing messages 00:04:37
51. Chapter 9. Balance load using Akka routers 00:04:15
52. Chapter 9. Akka pool router 00:07:13
53. Chapter 9. Akka pool router 00:07:57
54. Chapter 9. Akka group router 00:10:34
55. Chapter 9. ConsistentHashing router 00:07:17
56. Chapter 9. Implementing the router pattern using actors 00:08:15
57. Chapter 10. Message channels 00:05:22
58. Chapter 10. Publish-subscribe 00:07:55
59. Chapter 10. Publish-subscribe 00:08:39
60. Chapter 10. Specialized channels 00:05:00
61. Chapter 10. Guaranteed delivery 00:08:31
62. Chapter 10. Summary 00:01:53
63. Chapter 11. Finite-state machines and agents 00:09:01
64. Chapter 11. Implementation of an FSM model 00:07:29
65. Chapter 11. Implementing the entry actions 00:04:54
66. Chapter 11. Timers within FSM 00:05:37
67. Chapter 11. Implement shared state using agents 00:05:45
68. Chapter 11. Waiting for the state update 00:03:49
69. Chapter 12. System integration 00:04:50
70. Chapter 12. Normalizer 00:07:39
71. Chapter 12. Implementing endpoints using Apache Camel 00:04:06
72. Chapter 12. Implement a consumer endpoint receiving messages from an external system 00:09:27
73. Chapter 12. Implement a producer endpoint sending messages to an external system 00:04:56
74. Chapter 12. Implementing an HTTP interface 00:04:44
75. Chapter 12. Implementing a REST endpoint with akka-http 00:07:14
76. Chapter 13. Streaming 00:07:38
77. Chapter 13. Copying files with sources and sinks 00:06:47
78. Chapter 13. Materializing runnable graphs 00:10:36
79. Chapter 13. Processing events with flows 00:05:56
80. Chapter 13. Handling errors in streams 00:06:40
81. Chapter 13. Streaming HTTP 00:06:55
82. Chapter 13. Custom marshallers and unmarshallers for content type and negotiation 00:06:12
83. Chapter 13. Fan in and fan out with the graph DSL 00:04:52
84. Chapter 13. Merging flows 00:04:12
85. Chapter 13. Mediating between producers and consumers 00:05:28
86. Chapter 13. Rate-detaching parts of a graph 00:06:39
87. Chapter 14. Clustering 00:04:29
88. Chapter 14. Cluster membership 00:11:36
89. Chapter 14. Leaving the cluster 00:07:51
90. Chapter 14. Clustered job processing 00:06:31
91. Chapter 14. Work distribution using routers 00:05:00
92. Chapter 14. Resilient jobs 00:05:54
93. Chapter 14. Testing the cluster 00:03:59
94. Chapter 14. Summary 00:02:23
95. Chapter 15. Actor persistence 00:06:25
96. Chapter 15. Persisting state without updates 00:06:55
97. Chapter 15. Persistent actors 00:07:08
98. Chapter 15. Testing 00:06:59
99. Chapter 15. Persistence query 00:04:44
100. Chapter 15. Serialization 00:07:01
101. Chapter 15. Clustered persistence 00:08:02
102. Chapter 15. Cluster sharding 00:06:29
103. Chapter 16. Performance tips 00:08:11
104. Chapter 16. Performance parameters 00:04:25
105. Chapter 16. Performance measurement of actors 00:02:59
106. Chapter 16. Performance measurement of actors 00:08:52
107. Chapter 16. Collecting processing data 00:02:10
108. Chapter 16. Improving performance by addressing bottlenecks 00:04:46
109. Chapter 16. Configure dispatcher 00:06:10
110. Chapter 16. Changing thread pool size statically 00:05:07
111. Chapter 16. Using a dynamic thread pool size 00:03:38
112. Chapter 16. Changing thread releasing 00:07:37
113. Chapter 17. Looking ahead 00:06:26
114. Chapter 17. Akka Distributed Data 00:03:33
Show and hide more