Concurrent Podcast 02: Why Async

In Dream and MindTouch 09, we try to follow an async pattern using our own Coroutine framework throughout all systems. This is necessitated by an architectural decision that components of the system are decoupled to use the Http Request/Response pattern between each other. While we optimize for calls within the system to never hit the wire, it is fundamentally constructed so that any component could live across a wire boundary. This means that calls between components could leave the current process. Traditionally that kind of call would block the calling thread. Since this is central to our pipeline, that blocking would drastically reduce the capacity of any install. By using asynchronous calls, we never block, but instead yield the current thread to do some other work while we wait for a response.

Clearly, we’re highly invested in async, but we started having discussion internally why should other programmers care about this pattern. It does add complexity, so is it really a case of YAGNI?

Episode 2 is a product of this debate. We try to cover the use cases developers presently encounter and the ones that are on the horizon, becoming central to future development. We also talk about the complexities and pain involved given the present tooling and infrastructure. We hope that our discussion will give you useful information as you venture into asynchronous programming.

As a sidenote, for Episode 2, we also tried out a different recording setup which did not work out all that well. Apologies for the sound quality this week; we’re still learning the best way of doing this and hope to have significant improvements in place for Episode 3.

As usual, you can find future topic listed here, and we always welcome suggestions on what should take precedence or what other topics to cover. If you want to subscribe to just the podcasts, you can find the feed here.