In this talk I will present an advancement on the Compile Time Regular Expression (CTRE) Library. The library was designed with new C++20 features, and it uses novel techniques. This presentation independently sums up the work since my previous CppCon talk about the library. The primary topic of this talk will be an explanation of the new Deterministic Finite Automaton (DFA) engine in the library and how it's built and optimised during compilation. I will explain the differences and limitations of the new engine in comparison to the previous Back Tracking engine. I will address these differences with a benchmark and I will discuss the generated assembly. Even if you are not interested in regular expressions, you will learn new techniques in compile-time meta-programming and see new C++20 features in action....
With Moore’s law declared dead, multi-threading is becoming even more important. To extract the last bit of performance out of recent CPUs, developers need full and thorough understanding of the used concurrency primitives. In this talk, I’ll explain and build the most used threading primitives from scratch.
As a community we've tried many different ways to express, propagate and handle error conditions in our code over the years. Each seem to have different trade-offs, with none being perfect in all cases.
Lambda expressions have been in the language since C++11. Over the years they evolved, gaining the hidden generic powers in C++14 or having some details, like the ability to capture a copy of the enclosing object, polished in C++17. C++20 brings a handful of additions to their extensive feature set, including explicit lambda templates with concepts, default-constructible stateless lambdas or the ability to use lambdas in unevaluated context (e.g. template parameter). Those changes not only simplify the use of lambda expressions but also open doors to applications that were not possible before.
In this talk, I will briefly go through the evolution of closures, describing the limitations of the previous specifications and covering the main caveats and traps that await(ed) their users. I will move onto the new features of lambda's in C++20, discussing how they remove those limitations and what new usage scenarios they enable. The talk will conclude with the outlook on what's still not possible with lambda's and how this might change in the future.
At first look, Clang-Tidy looks like a convenient static analysis tool. But it is actually the emerged part of an incredible iceberg that can change the way software developers work on big projects.
Using the extension API provided by clang tooling, you can design custom tools that will allow you to get rid of bad patterns or API mistakes in your code that were historically considered "too deep-rooted to fix". Through concrete examples we will see what these custom tools can do and how this could impact your everyday job as software maintainers.
But wielding such powerful tools can be hard! And working on big projects also means you are likely working in an ecosystem with a lot of other developers. What happens when each time these colleagues try to sync their repository they find out one of your refactorings completely changed the API they were calling in their local work? We will see the difficulties and pitfalls one can encounter when developing and using clang based refactoring tools and how to avoid or reduce them.
The key idea of generic programming with templates is it to define functions and classes which
can be used with various types. Often it happens that you instantiate a template with the wrong
type. The result is typically a few pages of cryptic error messages. This sad story ends with
concepts. Concepts empower you to write requirements for your templates which can be
checked by the compiler. Concepts revolutionise the way, we think about and write generic
code. Here is why:
With the linear algebra proposal working its way through the committee, the co-authors are considering the first succession paper: adding analytic geometry to the standard library.
Since C++11, the standard includes primitives for asynchronous tasks. Pavel will tell about capabilities that the standard library offers now and that are slated to be added in the future. He will also tell about concurrency::task from PPL as an illustration for possible implementation. He will also cover how using coroutines can make writing and understanding of code much easier (as Gor Nishanov describes it in his proposal, which was voted in C++20) with reference to aforementioned primitives....
Code smells are subtle or not so subtle hints that there may be problems within our code. Some code smells are universal and independent of the language we use, others are C++ specific. Usually, a code smell represents violations of basic design principles or negligence of idioms and patterns that would make the code easier to grasp and maintain.
C++ is very powerful language allowing to efficiently access and process data. This comes at cost of missing built-in checks that may protect against data access errors, but would add extra overhead, thus requires programmer to be extra careful. Eventually, every software need to be verified against data access errors, and, sometimes, such errors need to be debugged.
C++17 is a remarkable collection of many features both in the core language and the library.
But the real power comes by using them together. And after 2 years of experience, we know enough to give good examples and advice.
One of the reasons why a lot of us work in C++ is because there is a huge amount of existing projects written in C++.
C++20 comes with some big new language features: modules, coroutines, concepts, spaceship, and many new libraries. But apart from all those, C++20 also offers many small language improvements, making C++ more powerful and expressive, but also safer and more consistent.
The performance benefits of supplying local allocators are well-known and substantial [Lakos, CppCon’17]. Still, the real-world costs associated with orchestrating the integration of allocators throughout a code base, including training, supporting tools, enlarged interfaces (and contracts), and a heightened potential for inadvertent misuse cannot be ignored. Despite substantial upfront costs, when one considers collateral benefits for clients – such as rapid prototyping of alternative allocation strategies – the case for investing in a fully allocator-aware (AA) software infrastructure (SI) becomes even more compelling. Yet there remain many “concerns” based on hearsay or specious conjecture that is either overstated or incorrect.
By now the term "Modern CMake" should not be anything completely new to a C++ developer. Several sources about what Modern CMake is can be found on the Internet and the Meeting C++ conference itself had some pretty good talks about this topic in former years.