https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Many Clang AST matcher use cases revolve around refactoring code. We utilized them in a new way, to ensure compliance in our codebase. In this presentation, we will explore Clang's LibASTMatcher library, go over the basics of setting up a project, and walk through our approach to creating matchers for simple to complex cases.
Developers who must comply with industry or product regulations will find this use case helpful. Join me as we take what we've learned and apply it.
---
Jonah Jolley
Jonah Jolley is a staff engineer at Devetry where he helps clients and engineers navigate the complex world of tech. He is passionate about embedded systems and optimizing developer’s workflows. In his spare time he likes to play disc golf and go sailing.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains: http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
In this talk we will overview one of the most fundamental and useful abilities of C++: Resource Acquisition Is Initialization. We'll start with an overview of "what is a resource" and understand the difficulties of managing resources in modern programming. Next, we will overview a few solutions suggested in the software development world, and analyze their pros and cons.
We will then deep dive into C++'s suggested solutions, including smart pointers, and learn how to combine them in our code. Finally, we will discuss RAII from a design perspective, and how to apply a user-defined RAII solution to your code.
At the end of the talk you'll be familiar with resource management in software applications in general, and have the toolbox for applying it to your C++ project.
This talk will assume knowledge of topics presented in: "Back to Basics: Pointers", "Back To Basics: Special Member Functions"
---
Inbal Levi
Inbal Levi is an embedded software engineer with a passion for high performance.
She is a director at ISO C++ foundation, co chair of Library Evolution, the chair of SG9 (Ranges group) of ISO/IEC JTC1/SC22/WG21 (the C++ Standards Committee) and of the ISO C++ Israeli NB, and one of the organizers of CoreCpp conference and user group.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
The `noexcept` operator, in concert with the `noexcept` specifier, allows generic code to choose a more efficient algorithm for types that have nonthrowing move and swap operations. These two C++11 features --- which have continued to evolve with every release of the language since C++11 --- are useful to high-performance computing yet, when overused, can profoundly jeopardize the maintainability of a large code base.
In this talk we will explore what the `noexcept` keyword means, what it offers, how it can be used effectively, the potential pitfalls one can encounter (and how to avoid them), and finally some excruciating annoyances regarding `noexcept` that exist in the C++ standard today. We intend to propose a fix for C++23 that will address those pitfalls and annoyances.
Background: Modern C++ offers a cornucopia of new features, not all of which are equally safe, especially when introduced into a large organization comprising legacy software and seasoned engineers proficient in early versions of the language. Over the past 18 months, I -- along with my coauthors -- have been privileged to work with some of the best minds on the planet to create a compendium of engineering wisdom from which virtually any C++ software engineer might benefit. The material presented in this talk derives directly from our about-to-be-published book, Embracing Modern C++ Safely.
---
John Lakos
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). His next book, entitled Large-Scale C++—Volume I: Process and Architecture, is anticipated in 2019.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Code size of embedded application has been a concern for a very long time. While storage becomes cheaper and smaller, developers find creative ways to increase code size by adding features or unnecessary software engineering. Compilers have come a long way in optimizing applications for code size. While most compiler optimization work were focused on application performance, we have seen increase in the code size optimizations in recent years.
In this presentation I'll talk about classical as well as recent compiler optimizations for code size, a few of which I implemented in the LLVM compiler. Some optimizations (hot cold splitting, function entry instrumentation) require collecting data from the field while the application is running. I'll provide an overview of how those compiler techniques help reduce code size. I'll also talk about some tips and techniques (compiler flags to reduce code size, tuning of compiler options like inline threshold), that help reduce binary size. Having knowledge of the code generated by the compiler and the instruction set architecture can help engineers chose appropriate programming abstractions and idioms.
Key takeaways:
- Compiler optimization flags and tunings for code size optimizations
- Selecting code-size friendly data structures and algorithms from the C++ standard library
- Source code level optimization and annotation techniques to reduce binary size
- Compiler instrumentation techniques to get insights into the source code
- Software re-organization techniques to reduce working set during program startup
---
Aditya Kumar
I've been working on LLVM since 2012. I've contributed to modern compiler optimizations like GVNHoist, Hot Cold Splitting, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
In this session, you’ll learn how to take advantage of VS Code’s new debugging capabilities and discover easy ways to boost your C++ development productivity along the way.
We’ll get a simple embedded project up and running on a Raspberry Pi using the CMake Tools extension for Visual Studio Code. Then, we’ll dive deep into a debugging session, digging into both source code and assembly language. Next, we’ll debug GPU kernels in VS Code using NVIDIA’s Nsight Visual Studio Code Edition extension.
You’ll walk away from this talk with the knowledge and tools to take advantage of all VS Code’s debugger has to offer, along with bonus tips about optimizing productivity in C++ development regardless of which editor or IDE you’re using.
---
Julia Reid
Julia is a program manager on the Visual C++ team at Microsoft, focusing specifically on Visual Studio Code. Because Julia comes from a background of C++ development, she has a passion for enhancing and simplifying C++ development experiences for programmers of all levels. Within Visual Studio Code, Julia focuses specifically on the C++ extension.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
C++20's views are an exciting and powerful new feature, and while the standard includes several views to get you started, there is plenty of room for improvement. Third-party libraries such as range-v3 can help, but how hard would it be to write one for your own application?
This talk will provide an introduction to how views work, along with solutions to common problems that you may encounter when trying to implement your own views. It will also go into some depth on a few of the shortcomings in the C++20 implementation of views and how they can be improved in future versions, as well as some possible workarounds that you can use in the meantime.
---
Jacob Rice
Jacob is a software engineer for Keysight Technologies in Colorado Springs, CO. He specializes in legacy code modernization, template library utility design, and system architecture. While he is a proponent of clean code in the workplace, he's also a big fan of esoteric and overly complex template metaprogramming code in his free time.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
The ＜chrono＞ header has existed since C++11, but C++20 dramatically increased its capabilities. MSVC has completed this C++20 feature and this session will focus on the development of our implementation and Windows-specific considerations that we encountered. For instance, how do we know if a given point in time is during a leap second insertion? Where do we get the data for time zones? If you are excited by these new chrono features and want to support a Windows platform, come and learn about its developments and caveats for a Windows implementation!
We will also touch on how STL maintainers and our valued external contributors developed the new features collaboratively. If you’re interested in participating in our open-source repo by reporting issues, contributing to discussions, or submitting pull requests, we hope that hearing about an example of collaboration will encourage you to visit our repo in the future.
---
Miya Natsuhara
Software Engineer, Microsoft
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Testing in C++ is not easy, it often requires a lot of boilerplate code, macro usage, and/or understanding of complicated testing frameworks.
But it doesn't have to be like that. C++20 will enable us to reinvent the way we write tests!
In this case study, we will address the difficulty of testing with C++ by implementing a new, fully functional, macro-free testing framework 1 from scratch with modern C++20 features to make the following snippet compile and run:
At the end of this session, the audience will have a better understanding of C++20 features such as:
- Modules
- Concepts
- Source Location
- New additions to lambdas
- User-Defined Literals
Additionally, attendees will get familiar with an expressive way of testing with modern C++ based on UT - Unit Testing Framework [2].
Let's get ready to follow the Beyonce rule - 'If you liked it then you "should put a"_test on it' and test all the things at CppCon 2021!
Kris is a Software Architect passionate about programming and who has worked in different industries over the years including telecommunications, games and most recently finance for Quantlab Financial, LLC. He has an interest in modern C++ development with a focus on performance and quality. He is an open-source enthusiast with multiple open-source libraries where he uses template meta-programming techniques to support the C++ rule - "Don't pay for what you don't use" whilst trying to be as declarative as possible with a help of domain-specific languages. Kris is also a keen advocate of extreme programming techniques, Test/Behavior Driven Development and truly believes that 'the only way to go fast is to go well!'.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Finding and correcting defects in our code (aka bugs) is often a time-consuming, tedious, and challenging task. As the size and complexity of our code bases grows, it can feel like the corresponding difficulty in finding and understanding defects is growing exponentially. And yet, defects continue to arise, and we must continue to fix them.
This talk will look at what debugging is, the role of debugging in our development processes, and some of the many challenges associated with debugging. We'll look at the kinds of defects that debugging can address, and examine a number of strategies, tools, and tips for tracking them down. Finally, we'll provide some guidance for what to do after you've found the problem.
If you've ever faced a challenging bug, and wished for a more complete set of tools for finding it, then this session is for you. Attendees will leave this session with a basic set of debugging tips, tools, and tricks that they can immediately apply to their own daily work.
---
Bob Steagall
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Designing and implementing a variant type (such as `std::variant` itself) in C++, at first, seems a rather inane topic. It turns out, however, that a variant type's performance or lack thereof, can have an inordinately large impact on software that directly impacts the bottom-line performance of important applications, such as interpreters. database clients, and communication protocols.
In this talk we will delve into the gory details of designing and implementing variant types, with an emphasis on layout, construction, and destruction. Along the way we'll figure out how to optimize not only the run time of the produced program, but also the time and memory consumed during compilation. These aspects, although seldom discussed, are important for provisioning and deploying continuous integration systems.
---
Andrei Alexandrescu
Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design to Machine Learning to Natural Language Processing. Andrei holds a PhD in Computer Science from the University of Washington and a BSc in Electrical Engineering from University "Politehnica" Bucharest. He is the Vice President of the D Language Foundation.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/
