Akka in Action video edition

Video description

"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

Table of contents

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

Product information

  • Title: Akka in Action video edition
  • Author(s): Raymond Roestenburg, Rob Bakker, Rob Williams
  • Release date: September 2016
  • Publisher(s): Manning Publications
  • ISBN: None