It's hard to believe a world existed before multi-core. Developers today use concurrency in all aspects of their software, every day, as though it is second nature: concurrency to accomplish many tasks at once; parallelism to complete one task faster; and asynchrony to improve a program's overall efficiency by overlapping multiple I/O operations (which, it turns out, dates back to the 1960s). And many supporting tools and abstractions. These days every programming language has embraced concurrency, an interesting evolution that has only recently become true.

This mainstream transformation happened over the past 15 years and borrowed aggressively from prior art in academia, most of it dating back to decades before. Another mainstream transformation is underway right now that is similar in many regards. The shift to the cloud, increasingly smaller services, and proliferation of connected devices ("things") means that distributed programming is something that every software developer will now need to similarly think about.

Thank goodness that distributed and concurrent programming share so much in common. Indeed, if we go back to the same literature that influenced concurrency over the past 15 years, we will see something interesting: the early pioneers and deep thinkers didn't draw such a hard distinction between concurrent and distributed as we do today. Furthermore, by shining a "distributed" light on classical concurrency problems, we are often forced to think about architecture, scaling, and safety in new and interesting ways. Similarly, by examining how we solved some of concurrency's hardest problems, we can discover some fascinating paths forward for solving some of distributed programming's hardest ones.

In this talk, we will first take a journey through concurrency's explosion onto the mainstream over the past 15 years. That in hand, we will then look at some of today's hottest trends (cloud, IoT, microservices) and attempt to predict what lies ahead not only for concurrent programming, but also distributed, from now to 15 years into the future.

Types, testability, tooling, paradigms, productivity, managed, native, concurrency, parallelism, performance, asynchrony, integrations, memory management, security, resilience, or, maybe, simple readability? What are the important things crossing the minds of language designers today as they build new languages or evolve the tried and trusted ones?

QCon convenes a panel of four language designers. These are people at the heart of questions like these. The computer science language panel is led by Martin Thompson and participants include:

• Brian Goetz (Java)
• Joe Duffy (Midori, C# Fork)
• Felix Klock (Rust)
• Sylvan Clebsch (Pony)

Come hear Martin ask the hard questions on choices made (past and future) and hear the discussion from the people behind some of the largest and most innovative languages in use by developers today.