RON - One-Way Circular Shortest Routing to Achieve Efficient and Bounded-Waiting Spinlocks
Innovative spinlock method for multi-core processors, minimizing communication costs and achieving bounded waiting time through one-way circular routing, improving performance in both user and kernel spaces.
Project Loom - Modern Scalable Concurrency for the Java Platform
Explore modern scalable concurrency in Java with Project Loom, featuring virtual threads and structured concurrency for enhanced performance and simplified development.
Adaptive Online Cache Capacity Optimization via Lightweight Working Set Size Estimation at Scale
Explore Cuki, an innovative data structure for efficient cache optimization in big data applications, improving accuracy and performance in distributed file caching systems.
Keynote
Explore Spring Framework 5.2, reactive improvements, and Kotlin coroutines with industry experts. Gain insights into cutting-edge developments and future directions in Spring technology.
Spring Boot with Kotlin, Kofu and Coroutines
Live coding demonstration transforming a Java Spring Boot app to Kotlin, leveraging Coroutines, WebFlux, Kofu DSL, and R2DBC for efficient, idiomatic development with explicit configuration.
Hearts of Darkness - A Spring DevOps Apocalypse
Explore real-world Spring application failures in production, learn from others' experiences, and gain practical tips to prevent similar issues in your own deployments.
Declarative Thinking, Declarative Practice
Explore declarative programming approaches, from functional languages to markup, and learn techniques applicable to requirements, code, and tests in mainstream languages.
Improving Performance and Maintainability in Modern C++
Explore techniques to enhance C++ code performance and maintainability through abstraction-based programming, refactoring, and concurrency management, with practical examples and multi-architecture evaluations.
Concurrency, Parallelism and Coroutines
Explore C++17's parallel algorithms, concurrency, and coroutines. Learn how these features interrelate and can be leveraged for efficient, parallel programming in modern C++ applications.
History of Time - Asynchronous C++
Explore the evolution of I/O-centric software development, focusing on asynchronous C++ techniques. Learn about trade-offs, efficiency, and correctness in handling I/O operations across different programming paradigms.
Lock-Free Programming with Modern C++
Comprehensive introduction to lock-free programming using modern C++, covering std::atomic, memory models, and practical implementations of thread-safe data structures for low-latency applications.
Local - Arena Memory Allocators
Explore memory allocation strategies for performance optimization in long-running systems, focusing on local allocators' benefits over global ones and their impact on runtime efficiency.
Coroutines and C++ DSLs for Human Scale Concurrency
Explore C++ coroutines and DSLs for simplified concurrency programming, focusing on practical applications beyond generators and async I/O in Visual Studio 2015.
Thinking Outside the Synchronisation Quadrant
Explore concurrency beyond traditional thread synchronization, covering immutability, actors, and alternative patterns for efficient and safe parallel programming in various languages.
There Is a Better Future
Explore advanced concurrency concepts, including improved futures and CSP channels, for creating efficient parallel task graphs and addressing limitations in std::future.
Finally Executors for C++
Explore C++ executors for asynchronous and parallel programming, covering motivation, requirements, interfaces, and practical examples. Learn about recent proposal developments and interactions with coroutines.
Read and Write Considered Harmful
Explores differences between reading and writing data across various topics, offering alternative approaches for improved system design and architecture.
Going Multiplatform with Kotlin
Explore Kotlin's multiplatform capabilities for code reuse across Android and iOS. Learn about Kotlin/Native, coroutines, and efficient architecture for shared core components.
Here's My Number; Call Me, Maybe - Callbacks in a Multithreaded World
Explore techniques for managing callbacks in multithreaded applications, focusing on clarity, object lifetime management, and preventing dangling references in C++ programming.
An Adventure in Race Conditions
Explore high-level abstractions for concurrent programming, avoiding common traps with locks and atomics. Learn strategies to prevent and detect race conditions in C++ development.
Go Get Better - Go Programming Language
Comprehensive introduction to Go programming, covering basics, concurrency, Docker integration, and common pitfalls. Ideal for beginners and intermediate developers seeking to enhance their Go skills.