4-Day Workshop on Concurrent Programming Fundamentals for AI Era
With over eight years of research and teaching experience in concurrent programming, I designed this workshop for the AI era — where code is generated faster than ever, but subtle concurrency bugs remain hard to spot.
The course helps developers build the intuition and practical skills needed to understand, test, and debug concurrent code, including code produced or modified with AI tools. Your team will learn classic and modern concurrent data structures, apply practical testing and debugging techniques, and develop an eye for concurrency issues that AI may confidently miss.
Workshop Format
The workshop spans 4 days and is designed for 8 hours of focused work per day:
- 09:00 – 12:30: Guided workshop with hands-on coding (we will use Java or Kotlin)
- 12:30 – 13:30: Lunch break
- 13:30 – 18:00: Practical implementation with instructor support
Workshop Curriculum
Curriculum is customizable based on participants’ experience and specific interests.
Day 1: Foundations and Basic Algorithms
We begin with essential locking strategies and progress to classic non-blocking data structures like Treiber stack and Michael-Scott queue. Your team will also learn effective testing approaches for concurrent code on JVM.
Day 2: Advanced Queue Implementations
Your developers will implement a Fetch-and-Add-based queue and tackle the challenge of removing elements from the middle, scaling up both performance and their understanding of complex concurrency patterns.
Day 3: Powerful Concurrency Patterns
These two powerful concepts — flat combining and descriptors — allow your team to build concurrent versions of any sequential algorithm and perform atomic updates across multiple memory locations.
Day 4: Practical Applications and Testing
We conclude with the design and implementation of a concurrent hash table using open addressing, and master writing tests for concurrent code on JVM — including AI-generated code — ensuring your team can verify the correctness of their implementations.
By the end, your team will be able to:
- Design and implement correct concurrent data structures with confidence
- Quickly spot and debug subtle concurrency bugs — including in AI-generated code
- Write reliable tests for concurrent code on the JVM with Lincheck
- Share a lasting, team-wide intuition for reasoning about concurrency
Pricing & Booking
Corporate Workshop Package
for 10 participants
Each additional participant: 500 EUR
(up to 30 participants)
+ Travel costs
- 4-day intensive workshop
- Comprehensive course materials
- Hands-on exercises with instructor support
- Certificate of completion
Your Instructor
Nikita Koval is a Tech Lead at JetBrains specializing in concurrency and program analysis. He created Lincheck, the JVM framework for testing concurrent code, and authored several synchronization and communication primitives in Kotlin Coroutines, including channels, mutexes, semaphores, and select. With over eight years of research and teaching in concurrent programming — and talks at conferences such as KotlinConf and PPoPP — he combines deep expertise with hands-on teaching experience.
What Past Participants Say
The course covers concurrent data structures in depth, from atomic counters to full-fledged concurrent hashmaps. Nikita explains the material clearly and with expertise. The practical assignments are challenging but manageable, and with Lincheck, you can quickly spot missed corner cases in your code and keep moving forward.
The workshop paired clear theory with engaging, hands-on tasks that doubled as cross-team building. My only regret is that it ended so quickly!
FAQ
Q: What will I get as a participant?
- Practical Skills & Intuition. Turn theory into practical skills and intuition with hands-on labs.
- Real-World Bug Analysis. Analyze real bugs and get to know what can go wrong in the world of concurrency.
- Team Building. Meet your colleagues from other teams and bond with them by solving problems together.
Q: Will this course be useful for my daily work?
Yes. Concurrency is everywhere, and its basic principles matter even if you rarely write concurrent code yourself. Instead of chasing constantly changing frameworks and libraries, we focus on the most fundamental algorithms and techniques — building a lasting skillset and intuition.
Q: Does concurrency still matter now that AI writes code?
More than ever. AI tools generate and modify code faster than ever, but subtle concurrency bugs remain hard to spot — and AI may confidently miss them. This course builds the intuition to understand, test, and debug concurrent code, including code produced or modified with AI.