C++ gives you enough rope to shoot your leg off. Readable (and thus easy to maintain, easy to support) and error-free code in C++ is often hard to achieve. And while modern C++ standards bring lots of fantastic opportunities and improvements to the language, sometimes they make the task of writing high quality code even harder. Or can’t we just cook them right? Can the tools help?
What do threads, atomic variables, mutexes, and conditional variables have in common? They are the basic building blocks of any concurrent application in C++, which are even for the experienced C++ programmers a big challenge.
Therefore, it's good that we get with C++17 and C++20 to new standards.
You are devoted to minimize coupling and duplication? You are taking care to maximize cohesion, flexibility, extensibility, encapsulation, testability, and even performance in order to achieve the high goals of (object-oriented) programming? Awesome! But wait: You still you favor member functions? Seriously? You have been deceived! You have been praying at the altar of false promises! Shed the shackles of Java philosophy! Free your functions!
Debuggers are one of the most important tools in the belt of any developer, but they are often seen as a magic black box. This is compounded by the lack of available literature, especially when compared to other toolchain components like compilers. This talk aims to demystify debuggers by showing how the utilities you use every day actually work.
Modern compilers provide us with advanced functionality to make us more productive and help us find bugs easily. In this talk, I will do a whirlwind tour of these tools including: formatting, static analysis, dynamic analysis, hardening (for security), coverage, fuzz testing, automated refactoring, and profile guided optimization. The talk will be full of demos. I will also talk about the big picture, how these tools fit into the development process and when they are the most useful and important.
Following on from the very successful ACCU 2017 talk "Mongrel Monads", this talk introduces the very latest post-Toronto edition of the proposed std::expected<T, E> which may make it out of the WG21 Library Evolution Working Group (LEWG) next year in time for the C++ 20 standard.
Deep Learning is a subfield of artificial intelligence that employs deep neural network architectures and novel learning algorithms to achieve state of the art results in image classification, speech recognition, motion planning and other domains. While all machine learning algorithms are initially formulated in mathematical equations (the only programming language where single lettervariable names are encouraged), they must eventually be translated into a computer program. Moreover, because deep neural networks can often be composed of many hundreds of millions of trainable parameters and operate on gigabytes of data, these computer programs have to be fast, lean, often distributed and squeeze every last ounce of performance out of modern CPUs, GPUs and even specialized hardware.
Today, most software systems have the need for some sort of concurrency. This poses problems regarding the software design. In the past few years, Meeting C++ had more than a few talks related to software design in the concurrent environment. From higher-level topics like Functional Reactive Programming to lower level stuff like Coroutines TS.
There seems to be this complacent status quo concerning function delegates. If you know the type, store a lambda, otherwise you'll have to live with the associated overhead of using std::function.
Join us exploring the topic of function delegates whilst using conventional as well as unconventional approaches in our search for better solutions.
constexpr has come a long way since C++11. And we know that it is now possible to implement entire
constexpr parsers allowing for compile-time parsing of things like JSON values. But what does this mean for every day code? Is it practical to apply
constexpr throughout your code base? What cost does this incur or advantage does it provide? We will look at specific examples of applying constexpr throughout the ChaiScript codebase and what impact it had on compile time, runtime and compile size.
Catch has gained popularity over the last six years as a modern, C++-native, test framework. Simple to use, easy to get started with, yet still powerful.
Until recently, though, it has been constrained by pre-C++11 compatibility.
Catch2 rebases on C++11 and takes advantage of this to simplify further, as well as offer new capabilities.
This talk takes a look at what's new in Catch and Catch2 and how to effectively test-drive modern C++ codebases.
Are memory allocators really worth the trouble? What situations merit their use? How are they applied effectively? What’s the performance impact? This practical talk by large-scale C++ expert John Lakos demonstrates that having local memory allocators in your tool box may lead to as much as order-of-magnitude speed improvements.
The runtime implications of the physical location of allocated memory are sometimes overlooked—even in the most performance-critical code. In this talk, we will examine how the performance of long-running systems can degrade when using just one global allocator (e.g., via new/delete). We will contrast the use of global allocators with various kinds of local allocators—allocators that allocate memory for a well-defined subset of objects in the system. We will also demonstrate how local allocators can reduce, if not entirely prevent, degradation seen in systems that rely solely on the global allocator. Six dimensions—fragmentability, allocation density, variation, utilization, locality, and contention—will be introduced to help characterize a given subsystem, assess the potential for accelerating its runtime performance, and—where appropriate—aid in determining the best local allocator to do so. Empirical evidence will be presented to demonstrate that introducing an appropriate local allocator can often result in substantial reductions in run times (compared with a similar system relying solely on just a single, global allocator).
Concepts are finally coming! In this talk, we will go above and beyond to explore the full potential of this haunted by history feature. We will discuss how concepts may revolutionize the way the modern C++ code is written, including how concepts may provide better diagnostics and simplify the SFINAE altogether. We will also take a look at how to emulate concepts in the current standard and discuss the benefits of the design by introspection. Additionally, it will be presented how to write a loosely coupled, well-performing code by default and how to opt out to a dynamic dispatch using type erasure when necessary. Its final focus will be on increasing your testing productivity when applying the concepts driven design.
Reflection in C++ has always been and remains a hot topic for the whole time C++ has been around, but unfortunately there is no a standard solution to retrieve and manipulate compile-time information. There have been several approaches implemented to tackle the lack of reflection, be it macros, pragmas or independent preprocessors. At the talk we will cover 2 similar proposals on reflection in C++, will look at some examples and live code a bit.