Events : Standard C++

Home » Blog » Categories » Events

« Prev Next »

Events

CppCon 2024 Perspectives on Contracts -- Lisa Lippincott

By Blog Staff | Aug 16, 2024 04:45 PM | Tags: None

Registration is now open for CppCon 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2024!

Perspectives on Contracts

Thursday, September 19 14:00 - 15:00 MDT

by Lisa Lippincott

Summary of the talk:

For many years, members of the C++ working group, WG21, have tried to add support for contract assertions — preconditions, postconditions, and assertion statements within a function body — to the C++ language. It’s been a long and difficult road, but we now have a proposal (P2900, “Contracts for C++”) to add significant contract support in, we hope, C++26, with more complete support to follow in C++29.

Looking back, the contracts feature has been unusually difficult and contentious. I contend that the difficulty is inherent in the feature: a contracts facility, by its nature, cannot be understood from any single point of view.

In this lecture, I will explain why understanding contracts requires seeing the feature from a panoply of perspectives, and show how shifting between these perspectives allows one to make effective use of the facility.

This lecture is derived from presentations made to the Language Evolution subgroup of WG21 at the St. Louis meeting in June 2024.

Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic, and wants to make computer-checked proofs of correctness a routine part of programming.

CppCon 2024 Compile-time Validation -- Alon Wolf

By Blog Staff | Aug 15, 2024 04:42 PM | Tags: None

Compile-time Validation

Tuesday, September 17 15:15 - 16:15 MDT

by Alon Wolf

Summary of the talk:

C++ is often criticized for its lack of inherent memory safety, but the spectrum of potential program validations extends far beyond just memory concerns. This talk delves into the necessity of early validation, emphasizing the benefits of compile-time checks in C++. By leveraging compile-time validation, developers can catch errors and enforce constraints before the code is even executed, enhancing both safety and correctness.

A functional programming approach to compile-time validation will be discussed, highlighting its benefits and demonstrating its application in ensuring code correctness.

Moreover, the talk will delve into the realm of compile-time unit tests, showcasing how they enable developers to validate code behavior at compile time, paving the way for more efficient debugging and maintenance.

Exploring advanced features, we'll discuss existing compile-time techniques to implement lifetimes, borrow checker, and other validation rules by leveraging template metaprogramming for memory safety and how they can be improved with the upcoming C++26 reflection proposal.

Additionally, we will review language extensions and compiler-specific features that augment compile-time validation capabilities. Finally, the talk will cover the role of static analysis tools in detecting potential issues early in the development process, thus complementing compile-time techniques. Attendees will gain a comprehensive understanding of the various strategies available for enhancing program reliability through compile-time validation in C++.

Alon is a Senior Software Engineer at Medtronic specializing in 3D and computer graphics with a passion for high performance. He has developed many custom simulation and rendering engines for different platforms using modern C++. He also writes a C++ technical blog and participates in game jams.

A first look at the voting results for Meeting C++ 2024

By Meeting C++ | Aug 15, 2024 02:32 AM | Tags: None

On Sunday the voting for Meeting C++ 2024 ended, now the program is taking shape. The schedule should be available by end of August.

A first look at the voting results for Meeting C++ 2024

by Jens Weller

From the article:

And through this voting, these talks made it into the top 11 - forming the main track:

    Andreas Weis - C++ Modules - Getting Started Today
    Roth Michaels - Templates made easy with C++20: how constexpr/constexpr, fold expressions, and concepts change how we write code
    Bryce Adelstein Lelbach - The C++ Execution Model
    Klaus Iglberger - There is no Silver Bullet
    Boguslaw Cyganek - Pipeline architectures in C++: overloaded pipe operator |, std::expected and its monadic operations
    Nico Josuttis - C++ Concepts: What you should know and how to use them right
    Peter Muldoon - Dependency Injection in C++ : A Practical Guide
    Jonathan Müller - An (In-)Complete Guide to C++ Object Lifetimes
    Sandor Dargo - Clean code! Horrible performance?
    Andreas Fertig - Fast and small C++ - When efficiency matters
    Timur Doumler - Contracts for C++

CppCon 2024 Using Modern C++ to Avoid Vulnerabilities by Design -- Max Hoffmann

By Blog Staff | Aug 14, 2024 04:37 PM | Tags: None

Security Beyond Memory Safety - Using Modern C++ to Avoid Vulnerabilities by Design

Monday, September 16 11:00 - 12:00 MDT

by Max Hoffmann

Summary of the talk:

Nowadays, there is one topic that comes up in virtually all discussions on system programming languages: memory safety.
However, even though memory safety rules out many of the most common sources of vulnerabilities, there are still plenty of ways how a vulnerability may find its way into the codebase.

In this talk, we look beyond memory safety and explore how we can prevent vulnerabilities through simple yet effective C++ constructions and custom static analysis scripts. We analyze multiple examples, from basics like input validation to complex time-of-check vs time-of-use issues when accessing shared resources, all of which are inspired by real-world products, use cases, or vulnerabilities. For each example, we discuss attacker models, threats, and implementation pitfalls, before looking at potential solutions that are not just secure by themselves but also protect developers from accidentally introducing vulnerabilities in the future.

Attendees will leave with a deeper understanding of security engineering and inspirations for leveraging C++ to prevent potential security issues by design.

Max Hoffmann studied cybersecurity and got his Ph.D. in hardware security at the Ruhr University Bochum, Germany, in association with the Max Planck Institute for Security and Privacy at the research group of Professor Christof Paar. With a passion for teaching, he continues to contribute to the university as an external lecturer, shaping the next generation of cybersecurity professionals. As a Security Manager at ETAS, he oversees the Onboard Security portfolio, driving process improvements, supporting in technical discussions, managing vulnerabilities, and enhancing security awareness in the organization.

CppCon 2024 Template-less Meta-programming -- Kris Jusiak

By Blog Staff | Aug 13, 2024 06:34 AM | Tags: None

Template-less Meta-programming

Friday, September 20 09:00 - 10:00 MDT

by Kris Jusiak

Summary of the talk:

Meta-programming is one of the most significant C++ superpowers. It enables seemingly impossible feats, but there is a considerable cost associated with it as well. Therefore, its applications have been limited to experts and cases where the benefits greatly outweigh the maintenance burden.

But what if that doesn't have to be the case? In this talk, we will explore an alternative approach to template meta-programming that does not require an understanding of the traditional 'angle bracket' technique.

We will also make the case that anyone who can write C++ can become a meta-programming guru! But what about compilation times and/or testing/debugging, you may ask? Well, we will cover those as well, and it might be surprising what modern C++ is actually capable of!

Additionally, we will cover how the static reflection proposal and C++20 ranges can further improve the ability to write meta-functions and how C++ compares to other languages such as circle. However, we will also show how to apply the technique with C++17 on all major compilers with a ready-to-go solution.

Finally, we will benchmark compilation times of different approaches, showcasing their strengths and weaknesses.

If you are interested in meta-programming or have always wanted to understand its practical use cases but never really grasped them, this talk is for you!

Kris is a passionate Software Engineer with experience across various industries, including telecommunications, gaming, and most recently, finance. He specializes in modern C++ development, with a keen focus on performance and quality. Kris is also an active conference speaker and open-source enthusiast, having created multiple open-source libraries.

CppCon 2024 Deciphering C++ Coroutines - Mastering Asynchronous Control Flow -- Andreas Weis

By Blog Staff | Aug 12, 2024 04:30 PM | Tags: None

Deciphering C++ Coroutines - Mastering Asynchronous Control Flow

Thursday, September 19 09:00 - 10:00 MDT

by Andreas Weis

Summary of the talk:

One of the most powerful applications of coroutines is in the context of asynchronous operations, where their use allows for significant simplifactions of application code. Unfortunately, building an asynchronous library interface to enable such benefits for applications is not exactly straightforward in C++.

In this talk we will explore the essentials of managing asynchronous control flow with coroutines. We will discover how to reconstruct the call stack of nested asynchronous calls and thus bridge a significant gap between C++'s stackless coroutines and the stackful coroutines from other languages. We will learn how to build a mechanism similar to the async/await from languages like Python or Javascript for our own libraries. And we will explore how we can perform arbitrary manipulations of the call stack in such an environment to unleash the full power of C++'s coroutine mechanism.

At the end of this talk we will have a proper understanding of how the Task<> type found in many coroutine libraries works and how it can be used to manage asynchronous operations. This will serve as an important building block for understanding more advanced mechanisms, like the sender/receiver mechanism proposed for C++26.

This talk assumes basic familiarity with the components of the C++ coroutines language feature: promises, awaitables, coroutine handles, and passing data in and out of coroutines.

This is the second part in an ongoing series of talks about C++20 coroutines.

Andreas Weis has been writing C++ code in many different domains, from real-time graphics, to distributed applications, to embedded systems. As a library writer by nature, he enjoys writing portable code and exposing complex functionalities through simple, richly-typed interfaces. Both of which C++ allows him to do extensively.Andreas is also one of the co-organizers of the Munich C++ User Group, which allows him to share this passion with others on a regular basis.

CppCon 2024 Designing a Slimmer Vector of Variants -- Christopher Fretz

By Blog Staff | Aug 11, 2024 04:23 PM | Tags: None

Designing a Slimmer Vector of Variants

Wednesday, September 18 14:00 - 15:00 MDT

by Christopher Fretz

Summary of the talk:

Heterogeneous containers ("vectors of variants") are an extremely flexible and useful abstraction across many data domains, but std::vector<std::variant<...>> can exhibit extremely bad memory characteristics for mixed types of disparate size, especially if the largest types are relatively uncommon in practice. Variants always have to be at least as large as their largest contained type, and vector implicitly requires all of its members to be the same size, leading to significant bloat in such cases. Motivated by real-world use-cases, this talk explores the design of a bit-packed replacement data structure that can achieve massive improvements in memory usage, and the impacts that these optimizations have on its API.

CppCon 2024 Shared Libraries and Where to Find Them -- Luis Caro Campos

By Blog Staff | Aug 10, 2024 04:19 PM | Tags: None

Shared Libraries and Where to Find Them

Tuesday, September 17 • 14:00 - 15:00 MDT

by Luis Caro Campos

Summary of the talk:

Most C++ developers are familiar with the type of errors that arise when a shared library is not found. If they are really unlucky, they are have also faced a situation where the the wrong version of a library is loaded. However, a lot of us resort to suboptimal solutions just to get going, without fully addressing the root causes.

A lot of the time, we focus on the “build” process, that is, producing our binaries and executables. But getting the runtime linker/loader to locate the right libraries (and the right versions!) has a unique set of challenges that should not be overlooked - after all, running the executables is critical for running tests, continuous integration, and obviously end-users running our apps and services.

Managing dependencies continues to be one of the top frustrations of C++ developers as per the most recents ISO C++ Developer Surveys. When it comes to shared libraries - different applications try to locate them at different times: the build system (e.g. CMake or Autotools) when configuring the build, the linker at build time, and the dynamic linker/loader at runtime.

This talk will cover in detail the different scenarios in which shared libraries need to be located, and how this is handled by package managers, build systems, and the the OS level. Emphasis will be placed on familiarizing the developer with the relevant tooling across multiple platforms, as well as associated concepts (e.g. RPATHs).

An often overlooked aspect will also be covered: how to create a self-contained, relocatable bundle for our user-facing applications, decoupled from the developer environment, as opposed to “works on my machine”.

Luis is a Electronics and Computer Engineer based in the UK, with previous experience as a C++ engineer in the field of Computer Vision and Robotics. With a passion to enable C++ engineers to develop at scale following modern DevOps practices. He is currently part of the Conan team at JFrog, focused on the problems of the C++ community at large.

CppCon 2024 Bridging the Gap: Writing Portable Programs for CPU and GPU -- Thomas Mejstrik

By Blog Staff | Aug 9, 2024 04:19 PM | Tags: None

Bridging the Gap: Writing Portable Programs for CPU and GPU

Monday, September 16 • 15:15 - 16:15 MDT

by Thomas Mejstrik

Summary of the talk:

This talk presents a series of effective patterns to address challenges arising when
code is developed that shall operate seamlessly on both GPU (Cuda) and CPU environments.
This scenario is a common oversight among Cuda developers, given the substantial architectural differences between CPUs and GPUs.

The patterns presented cover a range of scenarios, from handling stray function calls, strategies for conditional compilation, exploiting constexpr functions, leveraging undefined behaviour, usage of Cuda specific macros,
conditional instantiation of templates, and managing compiler warnings and errors.

Key patterns include: "Host device everything", "Conditional function body", "Constexpr everything", "Disable the warnings", "Defensive Programming", "Conditional Host Device Template", and "Function dispatching".

We evaluate each pattern based on ease of use, maintenance overhead, applicability and known usages. Additionally, pitfalls to avoid and considerations for implementations are provided to guide developers in adopting these patterns effectively.

Thomas Mejstrik earned his doctoral degree in Mathematics from the University of Vienna, Austria, specializing in numerical linear algebra and high-performance computing. Additionally, he obtained a Master's degree in Piano Education from the University of Music and Performing Arts Vienna, Austria. He also pursued studies in Chinese at the Central China Normal University, Wuhan, China, and the University of Vienna, Austria. With prior experience as a CUDA/C++ Senior Software Developer at Dimetor, Vienna, Austria, Thomas Mejstrik currently serves as a Postdoctoral Researcher at the University of Vienna, leading a research project on linear subdivision schemes, particularly relevant in animation. Beyond his academic and professional pursuits in mathematics, programming, and music, Thomas Mejstrik is actively involved in various women's political initiatives.

CppCon 2024 Reflection Based Libraries to Look Forward To -- Saksham Sharma

By Blog Staff | Aug 8, 2024 04:12 PM | Tags: None

Reflection Based Libraries to Look Forward To

Tuesday, September 17 • 09:00 - 10:00 MDT

by Saksham Sharma

Summary of the talk:

The primary reason for your code to get bored is fatigue from repetitive instructions. You write down enums, but then you also have to write their stringified version, and you also have to write a function to map the strings to the enums. You write down a class, but you have to expose every method / member in the class separately to be able to bind your class to a Python program (for example).
Reflection is (potentially / hopefully) showing up for C++26, having already been forwarded from the SG7 subgroup on reflection / compile time programming to the LEWG and EWG. This talk will discuss everything there is so far on reflection, and we will lead up to three library ideas based on reflection:

Python bindings
ABI hashing (hashing a type for efficient compatibility checking)
A better std::any variant type with duck typing ��
Come attend this talk if you'd like to hear about cool new library possibilities that have opened up with reflection!

For background, we will look at a little bit of context and how reflection works in some other languages, and will explore how the P2996R1 paper’s proposed version of reflection looks in practice, with some real use-case inspired code.

Saksham Sharma is a Director of Quantitative Research Technology at Tower Research Capital LLC, a high frequency trading firm based out of New York. He develops low latency and high throughput trading systems and strategies used for the firm's global quantitative trading. In addition, he also helps design and improve big data research infrastructure used for trading research using a combination of C++ and Python. Thanks to an urge to optimize his daily workflow, he also owns the build systems, tooling, and package managers for C++ within his team.In the past, he has worked in the fields of program analysis research, functional programming, and systems security. He is a reformed geek (exemplified by a switch to VSCode after almost a decade with Emacs), and now enjoys driving, guitar, badminton, and snowboarding.