CQRS and Event Sourcing provide a clear and concise way to build distributed applications that adhere to the reactive manifesto, Duncan DeVore claimed in a recent presentation sharing his experiences building a distributed application using Akka and Scala.
At the Bacon Conference last May, bitly Lead Application Developer Sean O'Connor explained the most relevant lessons bitly developers learned while building a distributed system that handles 6 billions clicks per month.
Last week at the Microsoft Worldwide Partner Conference, Microsoft took the wraps off of Azure Event Hubs. This service – in preview release until General Availability next month – is for high throughput ingress of data streams generated by devices and services. Event Hubs resembles Amazon Kinesis and uses an identical pricing scheme based on data processing units and transaction volume.
DDD and CQRS are great for building scalable software considering concepts like bounded contexts, transaction boundaries and event based communication and is together with Akka a complete platform for building enterprise applications, Pawel Kaczor starts a three-part series building an reactive application based on these concepts.
Delay of message sending into the future is a very powerful pattern and is often the preferable way of dealing with temporal problems compared to batch job that will run a query on the domain model and update some aggregates, Greg Young explained at the recent DDD Exchange conference in London.
DataTorrent is a real-time streaming and analyzing platform that can process over 1B real-time events/sec.
Using size for defining microservices is useless when determining a service responsibility, Jeppe Cramon states in a series of blog posts explaining his view on microservices and the coupling problems he finds in synchronous two-way communication.
We have to maximize locality of reference and minimize contention to make systems scale, Jonas Bonér, creator of the Akka project, stated in a recent presentation about scalability in reactive systems. By using a share nothing architecture, build on an event-driven foundation and adhering to core principles that have been proven to work for ages we can write really scalable systems.
Typesafe has announced the early preview of Akka Streams, an open source implementation of the Reactive Streams draft specification using an Actor-based implementation. Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure on the JVM. Back pressure in needed to make sure the data producer doesn't overwhelm the data consumer.
We should build systems more loosely coupled to achieve properties like robustness, resilience and scalability, Udi Dahan emphasizes in a recent presentation discussing how we can model our systems using more event-driven and asynchronous patterns and some of the challenges developers face when introducing these principles and patterns into development.
The New York Times R&D Lab has released streamtools, a general purpose, graphical tool for dealing with streams of data, under Apache 2 license.
There are both commonalities and some differences when comparing architectural principles and coding styles in Akka Actors and Java EE 7 Enterprise JavaBeans, specifically stateless session beans and JMS message-driven beans, Dr Gerald Loeffler concludes in a recent introductory talk when explaining and comparing the three approaches from a high-level concurrency view.
Version 2.1 of CQRS framework Axon supports annotations and ordering of event handlers, a new conflict resolution together with performance improvements. The recently released version also adds compatibility with OSGi.
Complex Event Processing, CEP, can be very useful for problems that have to do with time e.g. querying over historical data when you want to correlate things that have happened at different times, Greg Young explained in a recent presentation.
Vaughn Vernon, author of Implementing Domain-Driven Design, recently talked about using Scala and the Actor Model implementation Akka together with Doman-Driven Design as a means to remove some of the architecture overhead typically found in event-driven or hexagonal architectures.