Reactive Messaging Patterns with the Actor Model

Author: Vaughn Vernon
Publisher: Addison-Wesley Professional
ISBN: 9780133846874
Release Date: 2015-07-13
Genre: Computers

USE THE ACTOR MODEL TO BUILD SIMPLER SYSTEMS WITH BETTER PERFORMANCE AND SCALABILITY Enterprise software development has been much more difficult and failure-prone than it needs to be. Now, veteran software engineer and author Vaughn Vernon offers an easier and more rewarding method to succeeding with Actor model. Reactive Messaging Patterns with the Actor Model shows how the reactive enterprise approach, Actor model, Scala, and Akka can help you overcome previous limits of performance and scalability, and skillfully address even the most challenging non-functional requirements. Reflecting his own cutting-edge work, Vernon shows architects and developers how to translate the longtime promises of Actor model into practical reality. First, he introduces the tenets of reactive software, and shows how the message-driven Actor model addresses all of them–making it possible to build systems that are more responsive, resilient, and elastic. Next, he presents a practical Scala bootstrap tutorial, a thorough introduction to Akka and Akka Cluster, and a full chapter on maximizing performance and scalability with Scala and Akka. Building on this foundation, you’ll learn to apply enterprise application and integration patterns to establish message channels and endpoints; efficiently construct, route, and transform messages; and build robust systems that are simpler and far more successful. Coverage Includes How reactive architecture replaces complexity with simplicity throughout the core, middle, and edges The characteristics of actors and actor systems, and how Akka makes them more powerful Building systems that perform at scale on one or many computing nodes Establishing channel mechanisms, and choosing appropriate channels for each application and integration challenge Constructing messages to clearly convey a sender’s intent in communicating with a receiver Implementing a Process Manager for your Domain-Driven Designs Decoupling a message’s source and destination, and integrating appropriate business logic into its router Understanding the transformations a message may experience in applications and integrations Implementing persistent actors using Event Sourcing and reactive views using CQRS Find unique online training on Domain-Driven Design, Scala, Akka, and other software craftsmanship topics using the for{comprehension} website at forcomprehension.com.

Reactive Enterprise with Actor Model

Author: Vaughn Vernon
Publisher: Addison-Wesley Professional
ISBN: 0133846830
Release Date: 2015-05-07
Genre: Computers

Use Actor Model to Build Simpler Systems with Better Performance and Scalability Enterprise software development has been much more difficult and failure-prone than it needs to be. Now, veteran software engineer Vaughn Vernon offers an easier and more rewarding means to succeeding with Actor model. Vernon shows how the reactive enterprise approach, Actor model, Scala, and Akka can help you overcome previous limits of performance and scalability, and skillfully address even the most challenging non-functional requirements. Reflecting his own cutting-edge work, Vernon shows architects and developers how to translate the longtime promises of Actor model into practical reality. First, he introduces the tenets of reactive software, and shows how the message-driven Actor model addresses all of them-making it possible to build systems that are more responsive, resilient, and elastic. Next, he presents a practical Scala bootstrap tutorial, a thorough introduction to Akka and Akka Cluster, and a full chapter on maximizing performance and scalability with Scala and Akka. Building on this foundation, you'll learn to apply enterprise application and integration patterns to establish message channels and endpoints; efficiently construct, route, and transform messages; and build robust systems that are simpler and far more successful. Coverage includes How reactive architecture replaces complexity with simplicity throughout the core, middle, and edges The characteristics of actors and actor systems, and how Akka makes them more powerful Building systems that perform at scale on one or many computing nodes Establishing channel mechanisms, and choosing appropriate channels for each application and integration challenge Constructing messages to clearly convey a sender's intent in communicating with a receiver Implementing a Process Manager for your domain-driven designs Decoupling a message's source and destination, and integrating appropriate business logic into its router Understanding the transformations a message may experience in applications and integrations Implementing advanced system management and infrastructure tools for reactive environments

Akka Cookbook

Author: Hector Veiga Ortiz
Publisher: Packt Publishing Ltd
ISBN: 9781785288364
Release Date: 2017-05-26
Genre: Computers

Learn how to use the Akka framework to build effective applications in Scala About This Book Covers a discussion on Lagom—the newest launched Akka framework that is built to create complex microservices easily The recipe approach of the book allows the reader to know important and independent concepts of Scala and Akka in a seamless manner Provides a comprehensive understanding of the Akka actor model and implementing it to create reactive web applications Who This Book Is For If you are a Scala developer who wants to build scalable and concurrent applications, then this book is for you. Basic knowledge of Akka will help you take advantage of this book. What You Will Learn Control an actor using the ContolAware mailbox Test a fault-tolerant application using the Akka test kit Create a parallel application using futures and agents Package and deploy Akka application inside Docker Deploy remote actors programmatically on different nodes Integrate Streams with Akka actors Install Lagom and create a Lagom project In Detail Akka is an open source toolkit that simplifies the construction of distributed and concurrent applications on the JVM. This book will teach you how to develop reactive applications in Scala using the Akka framework. This book will show you how to build concurrent, scalable, and reactive applications in Akka. You will see how to create high performance applications, extend applications, build microservices with Lagom, and more. We will explore Akka's actor model and show you how to incorporate concurrency into your applications. The book puts a special emphasis on performance improvement and how to make an application available for users. We also make a special mention of message routing and construction. By the end of this book, you will be able to create a high-performing Scala application using the Akka framework. Style and approach This highly practical recipe-based approach will allow you to build scalable, robust, and reactive applications using the Akka framework.

Reactive Design Patterns

Author: Roland Kuhn
Publisher:
ISBN: 1617291803
Release Date: 2016-09
Genre: Computers

Modern distributed applications must deliver near-realtime performance while simultaneously managing big data and high user loads spread across environments ranging from cloud systems to mobile devices. Unlike traditional enterprise applications which focus on decoupling their internal components by defining programming interfaces, reactive applications go one step further and decouple their components also at runtime. This makes it possible to react effectively and efficiently to failures, varying user demands, and changes in the application's execution environment. The resulting systems are highly concurrent and fault-tolerant, with minimal dependencies among individual system components. Reactive Design Patterns is a clearly-written guide for building message-driven distributed systems that are resilient, responsive, and elastic. It contains patterns for messaging, flow control, resource management, and concurrency, along with practical issues like test-friendly designs. All patterns include concrete examples using Scala and Akka—in some cases, Java, JavaScript, and Erlang. Software engineers and architects will learn patterns that address day-to-day distributed development problems in a fault-tolerant and scalable way. Project leaders and CTOs will gain a deeper understanding of the reactive design philosophy. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

Learning Akka

Author: Jason Goodwin
Publisher: Packt Publishing Ltd
ISBN: 9781784393540
Release Date: 2015-12-30
Genre: Computers

Build fault tolerant concurrent and distributed applications with Akka About This Book Build networked applications that self-heal Scale out your applications to handle more traffic faster An easy-to-follow guide with a number of examples to ensure you get the best start with Akka Who This Book Is For This book is intended for beginner to intermediate Java or Scala developers who want to build applications to serve the high-scale user demands in computing today. If you need your applications to handle the ever-growing user bases and datasets with high performance demands, then this book is for you. Learning Akka will let you do more for your users with less code and less complexity, by building and scaling your networked applications with ease. What You Will Learn Use Akka to overcome the challenges of concurrent programming Resolve the issues faced in distributed computing with the help of Akka Scale applications to serve a high number of concurrent users Make your system fault-tolerant with self-healing applications Provide a timely response to users with easy concurrency Reduce hardware costs by building more efficient multi-user applications Maximise network efficiency by scaling it In Detail Software today has to work with more data, more users, more cores, and more servers than ever. Akka is a distributed computing toolkit that enables developers to build correct concurrent and distributed applications using Java and Scala with ease, applications that scale across servers and respond to failure by self-healing. As well as simplifying development, Akka enables multiple concurrency development patterns with particular support and architecture derived from Erlang's concept of actors (lightweight concurrent entities). Akka is written in Scala, which has become the programming language of choice for development on the Akka platform. Learning Akka aims to be a comprehensive walkthrough of Akka. This book will take you on a journey through all the concepts of Akka that you need in order to get started with concurrent and distributed applications and even build your own. Beginning with the concept of Actors, the book will take you through concurrency in Akka. Moving on to networked applications, this book will explain the common pitfalls in these difficult problem areas while teaching you how to use Akka to overcome these problems with ease. The book is an easy to follow example-based guide that will strengthen your basic knowledge of Akka and aid you in applying the same to real-world scenarios. Style and approach An easy-to-follow, example-based guide that will take you through building several networked-applications that work together while you are learning concurrent and distributed computing concepts. Each topic is explained while showing you how to design with Akka and how it is used to overcome common problems in applications. By showing Akka in context to the problems, it will help you understand what the common problems are in distributed applications and how to overcome them.

Domain Driven Design Distilled

Author: Vaughn Vernon
Publisher: Addison-Wesley Professional
ISBN: 9780134434995
Release Date: 2016-06-01
Genre: Computers

Domain-Driven Design (DDD) software modeling delivers powerful results in practice, not just in theory, which is why developers worldwide are rapidly moving to adopt it. Now, for the first time, there’s an accessible guide to the basics of DDD: What it is, what problems it solves, how it works, and how to quickly gain value from it. Concise, readable, and actionable, Domain-Driven Design Distilled never buries you in detail–it focuses on what you need to know to get results. Vaughn Vernon, author of the best-selling Implementing Domain-Driven Design, draws on his twenty years of experience applying DDD principles to real-world situations. He is uniquely well-qualified to demystify its complexities, illuminate its subtleties, and help you solve the problems you might encounter. Vernon guides you through each core DDD technique for building better software. You’ll learn how to segregate domain models using the powerful Bounded Contexts pattern, to develop a Ubiquitous Language within an explicitly bounded context, and to help domain experts and developers work together to create that language. Vernon shows how to use Subdomains to handle legacy systems and to integrate multiple Bounded Contexts to define both team relationships and technical mechanisms. Domain-Driven Design Distilled brings DDD to life. Whether you’re a developer, architect, analyst, consultant, or customer, Vernon helps you truly understand it so you can benefit from its remarkable power. Coverage includes What DDD can do for you and your organization–and why it’s so important The cornerstones of strategic design with DDD: Bounded Contexts and Ubiquitous Language Strategic design with Subdomains Context Mapping: helping teams work together and integrate software more strategically Tactical design with Aggregates and Domain Events Using project acceleration and management tools to establish and maintain team cadence

Implementing Domain driven Design

Author: Vaughn Vernon
Publisher: Pearson Education
ISBN: 9780321834577
Release Date: 2013
Genre: Computers

Vaughn Vernon presents concrete and realistic domain-driven design (DDD) techniques through examples from familiar domains, such as a Scrum-based project management application that integrates with a collaboration suite and security provider. Each principle is backed up by realistic Java examples, and all content is tied together by a single case study of a company charged with delivering a set of advanced software systems with DDD.

Akka in Action

Author: Raymond Roestenburg
Publisher: Manning Publications
ISBN: 1617291013
Release Date: 2016-06-28
Genre: Computers

Summary Akka in Action is a comprehensive tutorial on building message-oriented systems using Akka. The book takes a hands-on approach, where each new concept is followed by an example that shows you how it works, how to implement the code, and how to (unit) test it. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the Technology 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. About the Book 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'l also find a tutorial on building streaming applications using akka-stream and akka-http. Finally, you'l get practical advice on how to customize and extend your Akka system. What's Inside Getting concurrency right Testing and performance tuning Clustered and cloud-based applications Covers Akka version 2.4 About the Reader This book assumes that you're comfortable with Java and Scala. No prior experience with Akka required. About the Authors 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. Table of Contents Introducing Akka Up and running Test-driven development with actors Fault tolerance Futures Your first distributed Akka app Configuration, logging, and deployment Structural patterns for actors Routing messages Message channels Finite-state machines and agents System integration Streaming Clustering Actor persistence Performance tips Looking ahead

Applied Akka Patterns

Author: Michael Nash
Publisher: "O'Reilly Media, Inc."
ISBN: 9781491934838
Release Date: 2016-12-12
Genre: Computers

When it comes to big data processing, we can no longer ignore concurrency or try to add it in after the fact. Fortunately, the solution is not a new paradigm of development, but rather an old one. With this hands-on guide, Java and Scala developers will learn how to embrace concurrent and distributed applications with the open source Akka toolkit. You’ll learn how to put the actor model and its associated patterns to immediate and practical use. Throughout the book, you’ll deal with an analogous workforce problem: how to schedule a group of people across a variety of projects while optimizing their time and skillsets. This example will help you understand how Akka uses actors, streams, and other tools to stitch your application together. Model software that reflects the real world with domain-driven design Learn principles and practices for implementing individual actors Unlock the real potential of Akka with patterns for combining multiple actors Understand the consistency tradeoffs in a distributed system Use several Akka methods for isolating and dealing with failures Explore ways to build systems that support availability and scalability Tune your Akka application for performance with JVM tools and dispatchers

Effective Akka

Author: Jamie Allen
Publisher: "O'Reilly Media, Inc."
ISBN: 9781449360030
Release Date: 2013-08-15
Genre: Computers

Avoid common mistakes when building distributed, asynchronous, high-performance software with the Akka toolkit and runtime. With this concise guide, author Jamie Allen provides a collection of best practices based on several years of using the actor model. The book also includes examples of actor application types and two primary patterns of actor usage, the Extra Pattern and Cameo Pattern. Allen, the Director of Consulting for Typesafe—creator of Akka and the Scala programming language—examines actors with a banking-service use case throughout the book, using examples shown in Akka and Scala. If you have any experience with Akka, this guide is essential. Delve into domain-driven and work-distribution actor applications Understand why it’s important to have actors do only one job Avoid thread blocking by allowing logic to be delegated to a Future Model interactions as simply as possible to avoid premature optimization Create well-defined interactions, and know exactly what failures can occur Learn why you should never treat actors as you would an ordinary class Keep track of what goes on in production by monitoring everything Tune Akka applications with the Typesafe Console

Mastering Akka

Author: Christian Baxter
Publisher: Packt Publishing Ltd
ISBN: 9781786468833
Release Date: 2016-10-21
Genre: Computers

Master the art of creating scalable, concurrent, and reactive applications using Akka About This Book This book will help you cure anemic models with domain-driven design We cover major Akka programming concepts such as concurrency, scalability, and reactivity You will learn concepts like Event Sourcing and CQRS via Akka Persistence, Akka Streams, Akka Http as well as Akka Clustering Who This Book Is For If you want to use the Lightbend platform to create highly performant reactive applications, then this book is for you. If you are a Scala developer looking for techniques to use all features of the new Akka release and want to incorporate these solutions in your current or new projects, then this book is for you. Expert Java developers who want to build scalable, concurrent, and reactive application will find this book helpful. What You Will Learn Use Akka actors to enable parallel execution Build out domain-driven design based components like entities and aggregates Respond to command requests on that aggregate root that affect the internal state Leverage Akka Persistence, protobuf and Cassandra to save the persistent state of you entities Build out complex processing graphs with the Graph Builder DSL Understand the dynamic push/pull nature of backpressure handling within Akka Streams Route HTTP requests to an actor and return a response Deploy actor instances across a set of nodes via ConductR for high availability In Detail For a programmer, writing multi-threaded applications is critical as it is important to break large tasks into smaller ones and run them simultaneously. Akka is a distributed computing toolkit that uses the abstraction of the Actor model, enabling developers to build correct, concurrent, and distributed applications using Java and Scala with ease. The book begins with a quick introduction that simplifies concurrent programming with actors. We then proceed to master all aspects of domain-driven design. We'll teach you how to scale out with Akka Remoting/Clustering. Finally, we introduce Conductr as a means to deploy to and manage microservices across a cluster. Style and approach This comprehensive, fast-paced guide is packed with several real-world use cases that will help you understand concepts, issues, and resolutions while using Akka to create highly performant, scalable, and concurrency-proof reactive applications.

Scala Microservices

Author: Jatin Puri
Publisher: Packt Publishing Ltd
ISBN: 9781786460134
Release Date: 2017-09-19
Genre: Computers

Design, build, and run Microservices using Scala elegantly About This Book Build robust microservices using Play Framework and Lagom Model your data for highly interactive applications and scale using Event Sourcing & CQRS Build applications that are resilient to failures by using Message Passing for communication Deploy and manage Scala Microservices for scale by using docker containers with Kubernetes for orchestration Who This Book Is For It is assumed that the reader knows Scala or is proficient in a competent programming language such as Java, C#, Ruby, and so on, with some exposure to Scala. Some experience with writing web services would also be ideal but not mandatory. What You Will Learn Learn the essentials behind Microservices, the advantages and perils associated with them Build low latency, high throughput applications using Play and Lagom Dive deeper with being asynchronous and understand the superiority it provides Model your complex domain data for scale and simplicity with CQRS and Event Sourcing Be resilient to failures by using message passing Look at best practices of version control workflow, testing, continuous integration and deployments Understand operating system level virtualization using Linux Containers. Docker is used to explain how containers work Automate your infrastructure with kubernetes In Detail In this book we will learn what it takes to build great applications using Microservices, the pitfalls associated with such a design and the techniques to avoid them. We learn to build highly performant applications using Play Framework. You will understand the importance of writing code that is asynchronous and nonblocking and how Play leverages this paradigm for higher throughput. The book introduces Reactive Manifesto and uses Lagom Framework to implement the suggested paradigms. Lagom teaches us to: build applications that are scalable and resilient to failures, and solves problems faced with microservices like service gateway, service discovery, communication and so on. Message Passing is used as a means to achieve resilience and CQRS with Event Sourcing helps us in modelling data for highly interactive applications. The book also shares effective development processes for large teams by using good version control workflow, continuous integration and deployment strategies. We introduce Docker containers and Kubernetes orchestrator. Finally, we look at end to end deployment of a set of scala microservices in kubernetes with load balancing, service discovery and rolling deployments. Style and approach The book will step through each of the core microservice concepts in Scala, building an overall picture of their capabilities. This book adopts a systematic approach, allowing you to build upon what you've learnt in previous chapters. By the end of this book you'll have an understanding of the complex aspects of building microservices in Scala and will be able to take that knowledge with you into further projects.ng of the complex aspects of building Microservices in Scala and will be able to take that knowledge with you onto whatever project calls for it

Reactive Programming with Scala and Akka

Author: Prasanna Kumar Sathyanarayanan
Publisher: Packt Publishing Ltd
ISBN: 9781783984350
Release Date: 2016-02-29
Genre: Computers

Harness reactive programming to build scalable and fault-tolerant distributed systems using Scala and Akka About This Book Use the concepts of reactive programming to build distributed systems running on multiple nodes Get to grips with the full range of Akka features including the upcoming and cutting edge experimental modules A comprehensive coverage of the principles of FRP with real-world use cases to solve scalability issues Who This Book Is For If you are a developer who is passionate about building fault-tolerant, scalable distributed applications using Scala and Akka, then this book will give you a jump start. You should be familiar with Scala, but no prior knowledge of Akka and reactive programming is required. What You Will Learn Explore functional programming using Scala Design an asynchronous, non-blocking shopping cart application using Futures Understand the Akka actor model and the relationship between actors and threads Use the Actor Supervision feature to build a fault tolerant and resilient application Create your own distributed system framework using an Akka cluster Take a look under the hood to gain perspective on the Akka engine See a comprehensive case study of a key value store with concurrent reads and writes Model a finite state machine using state-driven actors In Detail Today's web-based applications need to scale quickly to tackle the demands of modern users. Reactive programming is the solution developed to ensure the fault tolerant and robust scaling that is essential for professional applications. Reactive programming in Scala and Akka provides a great platform to develop low latency resilient, concurrent Internet scale applications on the Java Virtual Machine. This comprehensive guide will help you get to grips with the concepts of reactive programming in order to build a robust distributed system in Scala and Akka. Written in two parts, you will first take a walkthrough of the reactive, asynchronous, and functional concepts in Scala before focusing on Akka and getting to grips with the details of real-world use cases. Begin with an introduction into functional reactive programming, before moving on to writing asynchronous application with non-blocking constructs in Scala. Get familiar with the concept of actor-based concurrency using Akka, and features such as Akka remoting, routing, and persistence capabilities to build distributed applications. Learn to scale applications using a multi-node Akka cluster and unit test Akka actors and get to grips with state machines and how to implement state-driven actors using Akka. Finally, put your skills to the test with a case study where you will concurrently and asynchronously store and retrieve data from a key value store. By progressively working through the Akka concepts, you will not only be able to write your own distributed system, but also appreciate the hidden complexity within the Akka ecosystem. Style and approach This comprehensive guide walks you through the basics of reactive programming in Scala and Akka, explaining some of the most frequently used constructs to the most advanced features, and taking you through building a full-blown distributed system with the help of real-world examples.

Functional and Reactive Domain Modeling

Author: Debasish Ghosh
Publisher: Manning Publications
ISBN: 1617292249
Release Date: 2016-08-28
Genre: Computers

Functional and Reactive Domain Modeling teaches readers how to think of the domain model in terms of pure functions and how to compose them to build larger abstractions. It begins with the basics of functional programming and gradually progresses to the advanced concepts and patterns needed to implement complex domain models. The book demonstrates how advanced FP patterns like algebraic data types, typeclass based design, and isolation of side-effects can make models compose for readability and verifiability. On the subject of reactive modeling, the book focuses on higher order concurrency patterns like actors and futures. It uses the Akka framework as the reference implementation and demonstrates how advanced architectural patterns like event sourcing and CQRS can be put to great use in implementing scalable models. It offers techniques that are radically different from the standard RDBMS based applications that are based on mutation of records. It also shares important patterns like using asynchronous messaging for interaction based on non blocking concurrency and model persistence, which delivers the speed of in- memory processing along with suitable guarantees of reliability.