with Sy Brand Dynamic polymorphism in C++ has historically meant virtual functions and inheritance. However, these form only one possible design for solving this problem, and they bring several implications on performance, ergonomics and flexibility. Type erasure is another way to implement dynamic polymorphism, as demonstrated in several talks by Sean Parent and adopted in other languages, such as Rust’s trait objects. But implementing type erasing objects which provide ergonomic interfaces in C++ is cumbersome and error-prone, leading to a large family of types and libraries with subtly different semantics and lower adoption rates compared to inheritance. This talk will present a possible future design for interface-based type erasure in C++ that marries the convenience of inheritance to the benefits which it otherwise lacks. It will introduce the code injection and metaclasses facilities which are proposed for inclusion in C++ along with a prototype implementation of the design based on the experimental metaclasses Clang fork.
with Nick Uhlenhuth The rise of remote work and the growth of team sizes can make it challenging to stay productive. This presentation will show you how Visual Studio Online environments can address this problem for you and your team. Visual Studio Online gives you the ability to create a managed online environment specific to your project. Whether you’re working from home, or on the go, you can access this environment from anywhere. Only brought your laptop with you? No worries. The online environment powers your development and lets you easily scale up your CPU and memory to get a boost when you need it. Lastly, because this environment is online, you can easily share it with teammates for instant onboarding. Come see these productivity boosts in-action and learn how you can get started.
with Erika Sweet Are you a Windows developer interested in leveraging the power of Visual Studio to build and debug natively in WSL? Come learn about Visual Studio’s WSL support for C++ development. This demo-heavy session will show you how to configure a CMake project in Visual Studio to target both Windows and WSL. We will cover a few of the ways Visual Studio makes WSL development easier, including streamlined WSL configuration, integrated debugging support, platform-specific IntelliSense to check if your code will compile in a Linux environment before checking in, and cross-platform vcpkg integration. All C++ developers can leverage Visual Studio’s WSL integration (even if you’re not using CMake!) so come join this session to learn more.
with JeanHeyd Meneide Text handling in the C and C++ Standards is a tale of legacy encodings and a demonstration of decisions made that work at the moment don’t scale up to the needs of tomorrow. With Unicode on the horizon, C++20 prepared fundamental changes such as char8_t and polishing a things to make it easier to catch bad conversions and logical program errors when working with encoded text. Still, the landscape has poor support for transcoding from one encoding to the other, let alone talking about higher level algorithms such as how to compare two text forms which render identical to the user but have different bit patterns. This talk explores the fundamental design space behind Encoding, Decoding and Transcoding text. It describes the benefits of the API under active consideration of text, potential speed gains from such an API, and how it enables better handling of complex tasks such as normalization.
with Julia Reid If you’re looking for a fast and lightweight open-source code editor, Visual Studio Code has you covered. Come for a deep dive into the features of Visual Studio Code which provide a rich, productive environment for C++ development. This session will cover the C++ extension, CMake Tools extension, and Remote Development extensions for VS Code.
with Cameron DaCamara In this talk I will cover some specific strategies for migrating existing projects gradually to use more of the C++20 Modules machinery. We will explore header units, module interfaces, module partitions, and module implementation units. With all of the C++20 Modules tools it is important to acknowledge what can be integrated now and what can be integrated later along with what problems a project might face along the way. In addition to talking about how to integrate C++ Modules into C++ projects I will touch on the implications of generating rich semantic information about your program through our IFC format. As discussed in “C++ Modules Are a Tooling Opportunity” I will show some real world applications of our IFC format such as generating a FFI wrapper from a module.