DDD Weekly: Issue #39

July 10, 2017

You are also opting in for interesting, DDD-related emails from buildplease.com

The Foundations of Functional Concurrency [blog] Riccardo Terrell. In this article, we discuss the need for concurrency, common issues specific to developing concurrent applications in either imperative or object-oriented programming (OOP) and functional programming, and why the functional programming paradigm is ideal for solving common concurrency issues.

Messages over Structure [video] Mathias Varraes.

Application-Level Concensus [article] Olivier Deheurles. This article explores the benefits of using a consensus algorithm, such as Raft, to build clustered services. The core of this type of system is deterministic execution, replicated consensus log, and snapshotting of state to avoid replay from the beginning of time. Such a consensus approach offers simplicity, debug-ability, fault tolerance and scalability.

Effective Microservices Architecture with Event-Driven Design [blog] Jennifer Riggins. Yes, microservices allow for different team members to work on different parts of the code at different speeds. But this wonderful autonomy often finds folks even more siloed, not knowing what the other is doing before throwing it over the wall to the testing and documentation teams.

Exploring CQRS within the Brighter .NET open source project [blog] Scott Hanselman. There’s a ton of cool new .NET Core open source projects lately, and I’ve very much enjoyed exploring this rapidly growing space. Today at lunch I was checking out a project called “Brighter.” It’s actually been around in the .NET space for many years and is in the process of moving to .NET Core for greater portability and performance.

F# .NET Core Template added to Serverless Framework [code].

The evolution of scalable microservices [blog] Jonas Bonér. Today’s enterprise applications are deployed to everything from mobile devices to cloud-based clusters running thousands of multi-core processors. Users have come to expect millisecond response times and close to 100% uptime. And by “user” I mean both humans and machines. Traditional architectures, tools and products simply won’t cut it anymore. To paraphrase Henry Ford’s classic quote: we can’t make the horse any faster, we need cars for where we are going.

Asynchronously unload the dishwasher [blog] Daniel Marbach. Like in the real world, when unloading the dishwasher, message handling needs to be truly asynchronous to avoid locking resources (such as threads) longer than needed. The asynchronous chain of responsibility achieves that by returning a Task instead of void. Message handling almost always requires a concurrency level greater than one. The higher the concurrency, the more important it is to free up threads. All freed-up threads can efficiently participate in handling messages, thus optimizing the system resource usage while minimizing the thread context switches.

Practical Parallelization in C# with MapReduce, ProducerConsumer and ActorModel [blog] Nima Ara. Despite this low barrier of entry, many developers fail to achieve the best performance out of their multi-threaded solutions. This is sometimes due to frequent or unnecessary locking/synchronization or at other times due to incorrectly partitioning their data or using an inappropriate pattern. In this article we are going to look at how we can squeeze the best performance out of an easily parallelizable problem by rewriting the same basic implementation using some of the most widely used multi-threading tools available in .NET.

All the Functional Track talks from NDC Oslo 2017 are now up. Here’s the list: https://gist.github.com/swlaschin/7bf9e8df8854ff964d9f85b6923c02b8 … #fsharp #elmlang #elixir and more… [tweet] Scott Wlaschin.

Composing high performance process workflows with Akka Streams [video] Vagif Abilov. This talk presents an example of a process workflow implemented using traditional actors and then demonstrates how to replace a set of manually defined actors with a workflow definitions based on Akka Streams. We will show how to integrate in streams message queues and Web services and how to define process workflows in C#, F# and even Scala.

Compositional UIs - the Microservices Last Mile [video] Jimmy Bogard. In this session, we’ll look at the common reasons why we need to build composite applications, and some of the ways we can avoid doing so. As we continue, we’ll look at integration patterns from a number of tiers, from the database up to the UI, examining patterns, techniques, and frameworks that close the last mile of microservices to build a maintainable, autotonomy-embracing compositional UI.

Thinking in Events [video] Mathew McLoughlin. In this talk I’ll discuss the advantages of looking at your system as a distinct series of events and how doing so can help you better model your domain. I’ll also talk about how this will change the way you write the software, how it changes the way your users will use the software and how it can ultimately lead to a better experience all around.