What makes one C++ API intuitive while another, solving the same problem, feels like a puzzle? Library developers wrestle with this question daily — and the answers often lie in the subtle interplay between language features and user expectations.
I want to walk through two real stories from the development of one of Intel's products — and do it live-coding together with you. Two different problems, same principle: the user's code should be simple even when the library's isn't.
Part 1 is about a single API discussion that spiraled into a deep exploration of templates, parameter packs, type deduction (including CTAD), and metaprogramming — all in service of one goal: making the interface feel more natural to the caller. You'll see our initial prototype, the trade-offs we debated, the dead ends we hit, and how the design evolved into what shipped. It's a story about the kind of thinking that separates a working API from a convenient one. If you've ever argued over whether a better interface is worth the implementation complexity it introduces, this part should resonate.
Part 2 tackles a different problem with the same motivation: you have a class template that takes a callable, and you want CTAD to work by decomposing its signature. How hard can it be? Harder than you might expect — unless you've already been down this road. Writing such deduction guides without peeking at how, say, std::function does it was a genuinely rewarding exercise to me. We'll extract function signatures from callable types, leverage API constraints to cover use cases that std::function cannot handle by design, and compose these techniques into deduction guides that make calling code less verbose. Along the way, I'll share the real amusing story behind this work — a two-day journey where techniques that initially seemed impossible clicked into place one after another.
std::function
Prerequisites: Familiarity with template mechanics (partial specialization, argument deduction, default template arguments, etc.) and working knowledge of CTAD, including basic experience writing deduction guides.
This talk likely covers familiar ground for metaprogramming veterans. But who knows — even they might pick up a trick or two.
View Slides
Ruslan is a Senior Middleware Development Engineer specializing in parallel and threading runtimes. He joined Intel in 2017 and has experience in the autonomous driving domain, where he led the development of two libraries.
Currently, Ruslan is the lead developer of oneAPI DPC++ library (oneDPL) while also contributing to other Intel products, including oneAPI Threading Building Blocks (oneTBB). He is an active member of the C++ Standard Committee (WG21), focusing on the C++ standard library, concurrency, and parallelism, with multiple accepted proposals. His current priorities are standardizing std::simd enhancements, extending C++ parallel algorithms, and contributing to Senders/Receivers.
std::simd
Ruslan is a chair of SG1 (Concurrency and Parallelism) in the C++ Standards Committee since April 2026.