During software development we have to deal with findings every day. Compilation errors, feedback from code reviews, a code coverage report, etc.
The C++ programming language has a vast ecosystem of open source libraries. However, many of these libraries are not well-known, and even experienced developers may be missing out on them. I will share six hidden gems of open source C++ libraries. These libraries cover a wide range of topics, including error handling, backwards compatibility, networking, and databases, and much more.I will discuss the features and benefits of each library, and I will show how they can be used to improve the development of C++ applications. I will also discuss some of the challenges of using open source libraries, and I will provide tips on how to find and use the right libraries for your project. Whether you are a beginner or an experienced developer, you will learn about some great open source libraries that you may not have known about, and you could either use them or be inspired by them in the future....
Come to this talk to understand the C++ memory model and learn about shared data synchronization challenges and their solutions. You will find out how to use mutexes and atomics in illustrative examples.
Dependency Injection Patterns: Efficiency and Usability
Decomposition and decoupling are crucial for development of
maintainable, reusable and testable software. The fundamental concept
enabling decomposition is dependency injection. Various dependency
injection techniques available for C++ programs differ in
applicability and efficiency. The talk will review dependency
injection patterns and C++ language features that facilitate them to
elaborate recommendations for efficient usage and potential tradeoffs.
Microsoft Office is a huge C++ codebase with nearly 100 million lines of native code. This size provides a constant challenge to build the product as quickly as possible. C++20 header units are a way to receive many of the benefits of modules, while still working with a codebase that was designed for classic header inclusion.
Entity Component System (ECS) is an architecture paradigm used in several games to achieve performance by nudging programmers towards data oriented paradigms. But your project doesn't necessarily need to use ECS to benefit from the tech behind it!
No, this is not an "ABI - Now or Never" talk. What happens in Prague, stays in Prague :) But wg21.link/P1863 will probably come up in the discussions, so we might as well prepare for it.
C++ is a powerful language with a rich history and a wide range of applications. However, working with C++ can be challenging due to its complexity. Fortunately, modern tooling and build systems have made it easier to develop and maintain C++ code.
In 2023, there are many essential tools that every C++ developer should be familiar with when starting a new project from scratch.
These including popular C++ IDEs like Visual Studio, CLion, as well as code analysis tools like PVS-Studio, Clang-Tidy, and Cppcheck, which can help catch errors and improve code quality.
Build systems like CMake simplify the process of managing dependencies and building complex projects across multiple platforms.
Additionally, package managers like Conan and vcpkg can make it easier to download and install external libraries.
By understanding and using these essential tools, developers can streamline the development process and focus on writing efficient, high-quality C++ code.
Let's try to write a new c++ project from scratch together and see how these tools help us.
A few years ago, a draft C++ Technical Specification for Reflection was published. Reflection would allow developers to get information about classes, variables, enumerations and more at compile-time, paving the way for more declarative and less repetitive code.
Classical C++ linear algebra libraries usually provide dense matrices and sparse matrices where the sparseness is only known at run-time. At compile-time, there is either no information on sparseness at all or only information whether a matrix is (upper/lower) triangular, diagonal or symmetric.
However, due to run-time considerations (due to the wish to use SIMD operations), even this limited set of sparse matrix types is usually stored as full dense matrices. This means that even the up to 50% of entries which are 0 are stored. While this can be beneficial for run-time, it also introduces a memory overhead that can be significant, especially in resource-constrained environment.
In this talk, we will see how it is indeed possible to get a free lunch by combining memory efficiency with run-time efficiency.
We'll learn how any kind of sparseness information can be incorporated into a matrix class *at compile time*. This means that only the necessary (non-zero, non-one, non-symmetric) entries have to be stored making such matrices very memory efficient.
Furthermore, this enables the compiler to automatically remove all unnecessary operations, yielding a performance that is at least on par with hand-written sparse-matrix code (but automatically generated) and in some cases even significantly faster.
From HPC to mobile development, the prevalence of accelerators and other performance-driven architectures is a fact you can't argue with anymore. What if you want to tap into those source of performances but you don't really want to sacrifice the elegance of your C++20 ? What if you may want to explore some of those architectures now but change your mind later without dropping all the code you already wrote ?
“If I could go back in time and had the power to change C++, rather than adding virtual function, I would add language support for Type Erasure …” (Eric Niebler, June 19, 2020, Twitter).
Let's face it, you can get by just fine in C++ without knowing what
std::launder does or how to use parameter packs with
std::index_sequence. However, if you consider yourself a well-rounded C++ programmer, you can't escape being familiar with the one-definition rule or understanding the deterministic object destruction guarantees. That's just C++ common knowledge. Yet, such foundational items are often overlooked and their details are glossed over. Unfortunately so. Let us take a step back and talk about the basics, digging deep into the core language. Let's start making the catalogue of the C++ common knowledge. Besides the topics already mentioned, we'll talk about the lookup rules, friends, initialization, member functions and others!
Taking you through the results and tooling of the Meeting C++ community survey.
A talk reflecting on the experience of handling CSV files with C++.