Writing concurrent programs in Java is hard and writing correct concurrent programs is even harder. What should be noted is that the main problem is not concurrency itself but the use of mutable shared state. Reasoning about concurrent updates to, and guarding of, mutable shared state is extremely difficult. It imposes problems like dealing with race conditions, deadlocks, live locks, thread starvation etc.

It might come as a surprise to some people but there are alternatives to the so-called 'Shared-State Concurrency' (that has been adopted by C, C++, Java and become the default industry standard way of dealing with concurrency problems).

In this talk we will discuss the importance of immutability and explore alternative paradigms such as Dataflow Concurrency, Message-Passing Concurrency and Software Transactional Memory (STM). We will have a pragmatic discussion on the drawbacks and benefits with each paradigm and through hands-on examples show you how each one, in its own way, can raise the abstraction level and give you a model that is much easier to reason about and use. We will show you how, by choosing the right abstractions and technologies, you can make hard concurrency problems close to trivial. All discussions are driven by examples using state-of-the-art implementations available for the JVM.