Speakers

Bjarne Stroustrup - Thriving in a crowded and changing world: C++ 2006-2020

By 2006, C++ had been in widespread industrial use for 20 years. It contained parts that had survived unchanged since introduced into C in the early 1970s as well as features that were novel in the early 2000s. From 2006 to 2020, the C++ developer community grew from about 3 million to about 4.5 million. It was a period where new programming models emerged, hardware architectures evolved, new application domains gained massive importance, and quite a few well-financed and professionally-marketed languages fought for dominance. How did C++ -- an older language without serious commercial backing -- manage to thrive in the face of all that? This paper focuses on the major language changes to the ISO C++ standard for the 2011 and 2020 revisions.

Themes include efforts to preserve the essence of C++ through evolutionary changes, to simplify its use, to achieve complete type-and-resource safety, to improve support for generic programming, to better support compile-time programming, to extend support for concurrency and parallel programming, and to maintain stable support for decades’ old code.

The ISO C++ standard evolves through a consensus process. We try (not always successfully) to mitigate the effects of design by committee, bureaucratic paralysis, and excessive enthusiasm for a variety of language fashions.

The talk will be given live online, followed by a live Q&A session.

C++ 20 Overview: The Big Four

C++20 invludes many improvements, with the four big features: concepts, modules, coroutines and ranges. In this talk, we'll see how these fit into the language and libraries, common use cases, and lots of code examples. By the end of this talk, you'll have a firm grasp of the power of C++ 20, and how your coding practices can adapt to leverage these new abilities.

The many faces of Number <--> String conversions

C++ inherited several library functions from C dealing with such conversions and has kept adding more on almost every new standard, the latest examples being to/from_chars from C++17 and C++20’s format library. This didn’t stop non-standard libraries, like Boost, from offering even more ways to do those conversions.

In this talk we will explore

• std::atoi
• std::sprintf
• std::stoi
• std::to_string
• std::from_chars
• boost::lexical_cast
• scn::scan

and more. We will try to understand why the number-string conversion problem is being solved repeatedly, compare the API, implementation and performance of these utilities and if time allows, see how different languages deal with this task.

Argument Passing, Core Guidelines, and Aliasing

Core guidelines recommend passing objects to functions differently based on whether they are 'cheaply copyable'. Last year, Herb Sutter put a spotlight on the importance of simple and correct methodology for such argument passing.

In this talk, I will present the considerations for passing input arguments to functions. I will introduce and examine guidelines, describe their reasoning and present benchmarks that emphasize the importance of this topic. Special attention will be given to the notion of aliasing, which is often overlooked.

Writing a cache-friendly C++ code

Understand how system cache effects your code, Good practices of how to tune your software. Plan and design a Fast, Efficient, Cache-friendly Hash

Ownership model in C++ and beyond

In this talk we will explore the design of memory management in modern C++, and beyond.

We will overview the dynamic memory management model in other languages, and scan what are the possible approaches.

Understanding the alternatives, we will overview the tools for managing dynamic memory in modern C++.

At the end of the talk - you'll have a complete comprehension of dynamic memory management in software applications in general, and the toolbox for using it correctly in C++.

Generators, Coroutines and Other Brain Unrolling Sweetness

C++20 brings us coroutines and with them the power to create generators, iterables and ranges. We'll see how coroutines allow for cleaner code, easier abstraction and genericity, composition and avoiding callbacks and inversion of control.

We'll discuss the pains of writing iterator types with distributed internal state and old-school co-routines. Then we'll look at C++20 coroutines and how easy they are to write clean linear code. Coroutines prevent inversion of control and reduce callback hell. We'll see how they compose and see examples from image processing and data structures.

This is an introductory talk that will focus more on co_yield and less on co_await and async related usages.

Latency Observability

Achieving accurate high precision performance measurements of a distributed low latency solution spanning multiple physical servers.

The presentation will review the evolution of our internal latency measurements and tracing architecture for our high frequency trading platform.

We will cover:

• Microsecond resolution end-to-end latency measurements using proprietary CPP application headers
  • Total logic processing time
  • Internal modules processing time
  • Network stack
• NIC to NIC Applications measurements
• Network propagation time measurements
• HW-based timestamping for RX and TX based on kernel-bypass drivers

Video Rendering on Frontend and Backend

Writing C++ code that works both in the frontend and backend of a web service is easier than ever. Tools like Emscripten make compilation to WebAssembly a simple process, but finding an architecture which integrates optimally with the browser isn't so simple.

In this talk I'll go over a basic overview of working with WebAssembly, and how the architecture of our video render engine was adapted to handle both the requirements of our backend and frontend.

C++17 key features

This talk will discuss the key features and changes that were added in C++17 and will open up to a short discussion about each one.

Obfuscation and beyond: securing your binary

You wrote your code, you complied and deployed it. Now this binary may get exposed to hostile attacks: hackers may try extract your precious secrets from it, or abuse it – for fun or profit. Luckily, you can protect your 'child', and C++ has a lot to do with that. You will learn about some techniques and tools that can help you to deliver a hardened software product that can resist reverse engineering – without reinventing the wheel.

The MLIR Framework: A Brief Introduction to Deep Learning Compilers

Deep learning defines a new programming paradigm. No more coding of predefined algorithmic rules, but rather defining architectures that will allow the data itself to carve the pathways to our desired model.

In addition, Neural Networks train on huge amounts of data that needs to flow through the system as quickly as possible. This demand sets a high bar for hardware performance, and is done by dedicated supercomputers.

This programming paradigm, alongside the dedicated types of hardware creates a new set of problems for compiler engineers. New computing systems require new tools, one of them is MLIR. This talk will introduce MLIR, an open source framework for building compiler infrastructure. There is no need for prior knowledge in compilation or deep learning, just some curiosity and a desire to dive deep.

Don’t do what I did

In over 15 years as a professional programmer, I worked for several companies. I was part of, and led several projects that were big successes, and I am always happy to talk about them in meetups, conferences and job interviews. However, I also had some big failures. As I believe that we can learn a lot more from failures, in this talk I would like to share with you some of my worst failures. This talk is not about misuse of language features, or implementation bugs. It is more about design and architecture errors, and about fix management. How to introduce new features and fixes into the system, in a safe manner.

C++ on the Edge – Machine Learning + Microcontrollers + C++

Microcontrollers are increasingly used to perform complex processing of sensor data, and this enable new applications in which server-based processing is not practical due to network bandwidth, latency or privacy constraints. This means there is a growing need for developing and running complex numerical, DSP and machine learning algorithms on platforms much smaller than a mobile phone. C++ is uniquely suited to this domain, and this should be a growth area in an environment where sensors are distributed everywhere and common microcontrollers have FPUs and DSP instructions.

This talk lies on the intersection between microcontrollers, numerical/Machine Learning algorithms, and modern C++ features. It will follow the implementation of a software-defined radar, which uses a microcontroller to control and process data coming from a radar sensor and to classify objects in real time. I will present the system but focus on how C++ features were applied.

I will try to present a critical view of modern C++ style applied to the microcontroller world, and discuss the benefits as well as hurdles encountered in this setting.

opt-viewer: Inspecting compiler optimizations in high-level code

How can you tell if a function was inlined? How do you know whether a variable was optimized out? A typical developer would say that, regrettably, one must look on disassembly - but for 5 years now, this answer is incorrect. Enter opt-viewer: a little known LLVM tool that generates concise, actionable optimization reports as source code markup. If you care about performance, you should probably know this tool (and if not, you should probably change your programming language to something other than C++).

Design Patterns for Hardware Packet Processing on FPGAs

Field-Programmable Gate Arrays (FPGAs) are hardware devices that can be programmed to run different hardware circuits, balancing the performance of hardware with the flexibility of software. Typically, hardware designers develop circuits for FPGAs in hardware description languages (HDLs), but High-Level Synthesis (HLS) allows development of hardware circuits in high-level languages such as C++. Naturally, HLS tools come with restrictions and limitations: not every C++ construct can be synthesized into efficient hardware.

This talk presents some of these limitations, focusing on the Xilinx Vivado HLS compiler. It then shows design patterns that allow circumventing these limitations, allowing developers to build high performance hardware using HLS in C++, focusing on the ability to develop reusable code. As examples, we will see two networking applications: a stateless UDP firewall, and a key-value store SmartNIC-based cache, both processing packets at 40 Gbps line-rate.

C++ Integer Promotion is Completely Broken

C++ have implicit Integer conversion rules designed to serve the purpose of the C programming language from which C++ inherited them. These rules leave way too much up for the compiler's static analysis (best case) or the programmer (worst case) to detect. While not frequently, misunderstanding those rules may result in serious, hard to spot, bugs.

In this lecture we will go over the way C, C++, Rust and D treat integer promotion, and see how they, essentially, leave the problem unsolved.

We will also look at the way Practical, a language at its infancy, solves this problem. We will also look at some far-reaching implications to areas such as user-defined types and function overloading that those changes made.

Lint Behind the Scenes

We all make mistakes. Mistyping variable names, forgetting a closing bracket, calling a function with the wrong number of arguments or writing buggy code. The list goes on and on. If you are a software engineer you are probably familiar with those problems. Linter is the tool that helps identify those problems in your code.

In this talk we will discover how lint is a part of an everyday IDE usage and how it is used for code analysis of a program. We will go behind the scenes to see how a linter actually works, what it has to do with the phases of a compiler and in comparison, we'll see how it is applicable in hardware.

Let’s discover the power of lint together

Implementing C++ Semantics in Python

Coding in Python, I often find myself reaching for C++ features and techniques.

Deterministic destructors and RAII, for example, are wonderful C++ constructs with no true equivalent in Python (or most any Garbage Collected language, for that matter).

The semantics around object lifetimes are just too different.

But what if we could bring C++’s destructors into Python? What if we could bring more semantics?

In this talk I will present a library that does exactly that. We will bring destructors, function overloading, member access specifiers, and more into Python. You will see the implementation of each feature, and all the dirty tricks used to make them work.

By replicating parts of C++ in Python, we will also gain a better understanding of C++’s semantics and the interactions between different language features.

Existing Python knowledge is not required; we will cover all the relevant syntax and semantics during the talk.

Modern Design Patterns with Modern C++

C++20 enables an elegant implementation of known design patterns.

Understanding and mastering C++'s complexities

You probably write in C++ not because it is the simplest available language. There are other attributes C++ brings: efficiency, low footprint, direct memory access, enhanced control over runtime behavior, and more. In "The Design and Evolution of C++", Bjarne Stroustrup explains the design decisions taken since the language was conceived and during its evolution. What makes C++ powerful? How has C++ survived more than 4 decades, while other languages have disappeared into oblivion? Why do we still use C++ (and will we still be using it in a decade from now)? And most importantly, why it is not so complicated after all, and even becomes easier to use over time! Our goal in this talk is to assure you that mastering C++ is doable, then motivate you to do so.

Understanding and mastering C++'s complexities

You probably write in C++ not because it is the simplest available language. There are other attributes C++ brings: efficiency, low footprint, direct memory access, enhanced control over runtime behavior, and more. In "The Design and Evolution of C++", Bjarne Stroustrup explains the design decisions taken since the language was conceived and during its evolution. What makes C++ powerful? How has C++ survived more than 4 decades, while other languages have disappeared into oblivion? Why do we still use C++ (and will we still be using it in a decade from now)? And most importantly, why it is not so complicated after all, and even becomes easier to use over time! Our goal in this talk is to assure you that mastering C++ is doable, then motivate you to do so.