Seven Concurrency Models in Seven Weeks (2014)

Foreword

This book tells a story.

That sentence may seem like a strange first thought for a book, but the idea is important to me. You see, we turn away dozens of proposals for Seven in Seven books from authors who think they can throw together seven disjointed essays and call it a book. That’s not what we’re about.

The original Seven Languages in Seven Weeks: A Pragmatic Guide to Learning Programming Languages [Tat10] story was that object-oriented programming languages were good for their time, but as pressures built around software complexity and concurrency driven by multicore architectures, functional programming languages would begin to emerge and would shape the way we program. Paul Butcher was one of the most effective reviewers of that book. After a growing four-year relationship, I’ve come to understand why.

Paul has been right on the front lines of bringing highly scalable concurrency to real business applications. In the Seven Languages book, he saw hints of some of the language-level answers to an increasingly important and complicated problem space. A couple of years later, Paul approached us to write a book of his own. He argued that languages play an important part of the overall story, but they just scratch the surface. He wanted to tell a much more complete story to our readers and map out in layman’s terms the most critical tools that modern applications use to solve big parallel problems in a scalable way.

At first we were skeptical. These books are hard to write—they take much longer than most other books and have a high failure rate—and Paul chose a huge dragon to slay. As a team, we fought and worked, eventually coaxing a good story out of the original table of contents. As the pages came together, it became increasingly clear that Paul had not only the technical ability but also the passion to attack this topic. We have come to understand that this is a special book, one that arrives at the right time. As you dig in, you’ll see what I mean.

You’ll cringe with us as we show threading and locking, the most widely used concurrency solution today. You’ll see where that solution comes up short, and then you’ll go to work. Paul will walk you through vastly different approaches, from the Lambda Architecture used in some of busiest social platforms to the actor-based model that powers many of the world’s largest and most reliable telecoms. You will see the languages that the pros use, from Java to Clojure to the exciting, emerging Erlang-based Elixir language. Every step of the way, Paul will walk you through the complexities from an insider’s perspective.

I am excited to present Seven Concurrency Models in Seven Weeks. I hope you will treasure it as much as I do.

Bruce A. Tate

CTO, icanmakeitbetter.com
Series editor of the Seven in Seven books
Austin, Texas