Talks at the Meeting C++ 2016 Conference
C++ has a reputation of being hard to learn, compared to other languages. The complexity of the language, which allows for versatility and good performance in a range of different domains, results in a steep learning curve. The long history of C++ can contribute to the problem: over the years, the language and our understanding of it has changed several times.
This talk is an overview of the open source static analysis tools for C++. The emphasis is on Clang based tools. While this talk is not intended to be a tutorial how to develop such tools I will cover the algorithms, methods and interesting heuristics that are utilized by them. Understanding these methods can be really useful as it helps us write more static analysis friendly code and understand the cause of false positive results.
With the new C++11 standard, C ++ is the first time aware of the existence of threads. The foundation for multithreading in C++ is the memory model. The memory model of C++ is based on that of Java and C#, but it goes a few steps further. The memory model provides answers to the questions:
- What are atomic variables and atomic operations?
- Which partial order of operations is guaranteed?
- When are operations visible on the data?
This talk is an overview of the memory model in C++.
SIMD instructions became a mandatory hardware components since the last 10 years. Most chip vendors roadmap features this kind of parallelism source and this trend is not coming to an end soon. Both HPC applications or embedded, mobile applications require such acceleration to be able to meet their requirements of performances.
In its simplest form, reduce turns into summing the contents of a sequence but in functional programming, refers to a family of higher-order functions that can, among others, easily implement mapping and filtering and express the process of stepping through an iterable and apply a combination function.
The C++ Core Guidelines are a proposal of leading C++ figures to limit the degrees of freedom of using C++ to ensure safer C++ code without losing performance or expressibility. For example, the use of naked pointers is limited so that pointer arithmetic and pointer parameters representing arrays are verboten.
static_assert gives us the ability to assert conditions at compile time and provide custom error messages in case the conditions are not met. Cool! But how can you be sure that your precious static_asserts actually fire when you need them? There is only one way to know for sure: You need to test your static_assert! That is easier said than done, though, as static_assert produces a hard, unrecoverable compile-time error.
Although I doubt that Eric Niebler spends a lot of his time programming micro controllers the concepts of his ranges v3 will revolutionize this domain. Using traditional ranges an output range cannot fail and zero cost abstractions of anything that is not actually two pointers is seldom possible. Ranges v3 drop these prohibiting requirements which allows us to abstract almost every peripheral as a range at zero cost, often just adding meta information to already existing hardware registers and thus using no RAM at all.
Most modern systems require writing asynchronous non-blocking code - from the ordinary GUI applications which can perform time-consuming operations, but still be responsive to the user input; to servers that need to be able to process many requests at the same time. Most of the commonly used approaches to solve concurrency (such as event-loop based applications with event callbacks, or multi-threaded and distributed multi-process systems) have a big problem of having to handle and synchronize the state that is shared between different code paths that run concurrently.
An alternative to deep inheritance trees for game and application architecture design is "composition". Separating data from logic allows the code to be more reusable and more efficient, alongside additional benefits.
This tutorial will guide the audience through the design and implementation of an experimental compile-time-based ECS, focusing on showing the train of thought behind solving the challenges faced in the design of the library.
There has always been great interest in imperative compile-time control flow: as an example, consider all the existing `static_if` proposals and the recently accepted `constexpr_if` construct for C++17.
What if you were told that it is actually possible to implement imperative control flow in C++14?
In this tutorial, the implementation and design of a compile-time `static_if` branching construct and of a compile-time `static_for` iteration construct will be shown and analyzed.
During this tutorial we are going to create a web game using C++14. The game will be powered by modern design patterns, ranges (possible STL replacement in C++17), dependency injection and meta state machine libraries. Emscripten will be used as a showcase of deploying C++ code to the web. After this workshop attendee will have more knowledge about writing truly cross-platform code in modern C++ as well as how to apply good coding practises from code design to testing.
Qt is a popular cross platform C++ framework used mainly for GUI. One of it's particularities is the use of a code generator, moc (meta object compiler), which processes the header files and is used to enable things such as signals and slots, scripting languages integration (QML) and more. In this talk we will see what moc does and how it does it.
Judging by the recent amount of talks about the STL Allocator model it is a pretty well-known fact that is has some issues. This is a problem because allocators are essential for many performance demanding applications such as games. The STL model makes it awkward both to write own allocators and to use them in your code.
This talk will cover why engineers looking for performance choose C++. Jon will present an historical perspective of C++ focusing on what's going on in the C++ community right now and where the language and its user base is heading. With a renewed interest in performance for both data centers and mobile devices, and the success of open source software libraries, C++ is back and it is hot.
Convened in June 2015, SG14 is the newest addition to the WG21 Study Group family. It's a little different from its siblings: while they focus on a particular aspect of software development such as numerics, databases, concurrency et cetera, SG14 is the first group to focus on a particular subset of use cases: low latency, real time requirements, and performance/efficiency especially for games, financial/banking, and simulations.
Automated trading involves submitting electronic orders quickly when opportunities arise. But it’s harder than it may seem: either your system is the fastest and you get the trades you are looking for, or you get nothing. This makes systems challenging to develop - the critical path is only a fraction of the total codebase, it is executed infrequently and unpredictably, yet must run with extremely low latency.
C++11 gave us lambdas in the language for the first time (if you ignore boost::lambda) - so it's a functional language now, right? There's a bit more to functional programming than having first class function objects. I'd even argue we still don't quite have that. But does that mean we can't do functional programming in C++? Yes.
This talk introduces the concept of a Concurrency Toolkit that contains the proposed lock-free algorithms on Hazard Pointers and Read-Copy_Update and analyzes their motivation, while showing where they can be useful and their performance differences.
Under optimistic concurrency, threads may use shared resources concurrently with other threads that may make such resources unavailable for further use.
You understand iterators, right? How would you describe them? "Iterators are used to point into sequences of elements." Sounds good? More recently, the concept of ranges has been introduced to mean anything that exposes iterators. In particular, ranges include range adaptors for lazily transforming or filtering sequences of elements, and they, too, have iterators.
With the increase in the available computational power, the Nathan Myhrvold's Laws of Software continue to apply: New opportunities enable new applications with increased needs, which subsequently become constrained by the hardware that used to be "modern" at adoption time. C++ itself opens the access to high-quality optimizing compilers and a wide ecosystem of high-performance tooling and libraries.
Type introspection and reflection are powerful features that help developers to automate the manipulation of user defined types, such as when doing serialization of an object or binding class methods to external scripts. The C++ language always lacked this features, while most modern languages benefit from their capabilities, showing a lack of potential productivity in the C++ language.
In some programming languages, text processing is easy. Unfortunately, C++ is not one of those languages. C++ lacks good, built-in support for Unicode, though the situation is starting to improve. This session will begin with a brief overview of text encodings, and an introduction to Unicode and the various Unicode encodings.
Reactive systems are found everywhere. The temptation to implement them with legions of waiting threads can be strong; however, the result is nearly always disappointing. The Boost.Asio library provides a framework to handle asynchronous resources with specific classes directed toward networking, serial port I/O, timers and more.
The talk will uncover the goals and guidelines of modern APIs in Boost. We will look closely at the evolution of the API in [Boost.]Process - a process management library under development since 2006 (brackets because it's still not yet an official Boost library).
We will examine how the API changed over time, what the underlying reasons were, and what and how C++ language constructs and libraries helped to improve the API.
This talk will preview what's to come on the C++17 and C++20 horizons. We'll explore real, working, code to show how new features will both change the way you handle day-to-day problems and also push the limits of what's possible in C++. We'll talk about how these language features have been put to use in the D community, which has had years of experience with them in production code.
As C++ evolves, it provides us with better and more powerful tools for optimal performance. But often, knowing the language very well is not enough. It is just as important to know your hardware. Modern computer architectures have many properties that can impact the performance of C++ code, such as cache locality, cache associativity, true and false sharing between cores, memory alignment, the branch predictor, the instruction pipeline, denormals, and SIMD.
When innovation-hungry programmers discovered by accident that C++ allows us to calculate and transform programs at compile time, an humongous hype was triggered: gigantic research projects were launched to develop self-optimizing software. Unfortunately, such software also had gigantic compile times of up to several days on parallel machines.
As performance and power-efficiency become the holy grail of modern C++ applications, the hardware solutions that deliver them differ greatly in architecture decisions and designs. The combination of CPUs, GPUs, FPGAs and custom domain specific hardware is gaining a lot of momentum. In view of this, C++ programming techniques and features are changing as well.
Structured binding, tuple-like access, overload sets and pattern matching
Product types were/are everywhere, POD, aggregates, C-arrays, `std::tuple`, `std::pair`, `std::array`. It is just cumbersome to define an access interface. A lot of libraries have provided their own macros to reflect the product parts.
Understanding large code bases is difficult. Large software on average does more, has less coherency, more hacks and more legacy. Creating an overview and understanding for such a project is difficult as it just takes way more time to understand, and many more assumptions will be invalidated along your process to understanding.
Robotics is a rapidly growing industry with many interesting technical problems and not enough engineers to solve them. If you’re interested in pivoting into this exciting field, come to this talk to learn about the C++ robotics toolchain. We will break down the problem of making an autonomous mobile system act on huge data streams in real-time and survey the quality and performance of popular libraries designed to solve these problems, such as ROS, OpenCV, PCL, TensorFlow, and more.
Software is eating the world. From smartphones to smart fridges, or
self-driving cars to voice recognition technology, software development
has never been more exciting.
The dark side to this digital evolution is the prevalence of software