tipi.build a New C++ Package Manager - Damien Buhl - CppCon 2022
https://github.com/CppCon/CppCon2022
The considerable versatility of C++ paired to it's ever evolving nature has produced an incredibly powerful dynamic but highly fragmented tools and library ecosystem.
Build systems and new build scripting languages are flourishing, massive community efforts and developer time is invested in maintaining build and packages scripts.
In this talk we show how we build and dogfood a radically different approach to C++ builds and dependency management.
We show how this approach is promising to defragment the C++ ecosystem and tell about the crazy challenges and terrible bugs we encountered on real life projects.
---
Damien Buhl
Damien (aka daminetreg), co-founder and CEO from tipi.build is an enthusiast C++ developer. He is Opensource entrepreneur, CppCon Speaker, GameMaker.fr community founder, Qt for Android contributor and Boost.Fusion maintainer since 2014
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Well yes, this is actual working C++17 code! And yes, we can use this tool to produce a logger with vanishing strings!
As part of this talk we will go behind the scenes of the DO_ON_INIT utility, the process involved in developing the idea and its surprisingly simple implementation details (under 20 lines of C++17 code, and even less in C++20).
We shall also see how this utility is instrumental in making possible the no-strings-attached logger and its associated automatically-generated decoding facility. We will implement a simple obfuscation technique which replaces logged strings with hashes at compile-time, to avoid shipping binaries containing sensitive textual giveaways. To decode such logs (in a separate decoder utility) we shall use DO_ON_INIT to automatically collect and register all the logged strings system-wide, along with their hashes, without requiring any additional tool (such as an in-house pre-processor).
This is yet another example of emergent behavior in C++, consisting of unrelated language features being put to use together in a novel and unexpected way. Could your idea be next?
---
Andrei Zissu
Andrei Zissu is an experienced cross-industry C++ developer, notably having worked on low-level reverse engineering systems employing API hooking, DLL injection and other advanced techniques. In early 2022 he joined the WG21 standards committee as a member of the Israeli NB, and is planning to explore the exciting realm of reflection.
Andrei is currently employed at Binah.ai, an Israeli startup developing ground breaking AI-based remote health monitoring technology. The feature presented in this talk has been developed by him in recent months for the Binah.ai C++17 codebase, and is being gradually staged into production code.
Andrei loves the occasional opportunity to explore the rough edges of C++. The latest such opportunity along with its discoveries will be presented in this talk.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Using Modern C++ to Revive an Old Design - Jody Hagins - CppCon 2022
https://github.com/CppCon/CppCon2022
In 1984, Dennis Ritchie introduced what would become the Unix System V STREAMS framework, which was designed to provide a way to implement most of the OSI stack with small, testable, modular, protocol independent, reusable, loosely coupled, components. These are great ideals for writing complicated data processing software systems. Unfortunately, the official STREAMS framework itself is limited to kernel modules, and the design itself has fallen out of favor due to perceived performance (and legal) issues. Still, the aforementioned characteristics of the STREAMS design are highly desirable.
This talk leverages features of modern C++ to offer a slightly different take on this relatively old, but very useful, design. We will present the design goals in detail, and show how to build small, testable components that can be easily plugged together.
Furthermore, we will discuss, and then use, several metacppcon.digital-medium.co.uk/tag/programming/">programming techniques to demonstrate how these design goals can be implemented, while also providing optimal runtime performance. For example, one point of performance problems with the traditional design is based on passing messages that contain opaque data. Each module must inspect each message to determine if it will be processed, or ignored and passed to the next module. This design provides an incredible amount of flexibility, but with it comes some amount of runtime cost to possibly perform inspection of every message at every module. One goal will be to utilize modern C++ techniques to reduce or eliminate this runtime cost.
---
Jody Hagins
Jody has been cppcon.digital-medium.co.uk/tag/programming/">programming in C++ since the 1980s. His formal education was in artificial intelligence, using LisP and Smalltalk. His professional experience began as a unix kernel developer, then telecoms, then automated trading, which is where he has been since the 1990s. He added enough C++ support to be able to write kernel modules in C++. Currently, he uses C++ in the domain of financial data feeds.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Overcoming C++ Embedded Development Tooling Challenges - Marc Goodner - CppCon 2022
https://github.com/CppCon/CppCon2022
There are more challenges in embedded than convincing your boss to let you use C++ on your next project. To start with, every silicon vendor seems to have their own IDE. They often have desirable diagnostic capabilities but are lacking in terms of a modern editing experience and are tightly coupled with specialized compilers.
How can you use these compilers with your IDE of choice? If you can already, are you able to also get the diagnostic capabilities you need? How do you manage versions of the compilers you are using for your project generally, even if you can acquire them independently of a vendor IDE? This is a difficult challenge for teams that set versions of compilers and tools at the beginning of a project, but work on multiple projects requiring different tools at the right time. Now, if you can navigate these challenges for your team's local development how do you extend this to your CI system? Is it even possible to connect the outputs of CI to CD?
There is currently a lot of energy within the embedded tools ecosystem to solve these problems. This session will explore these problem areas and how participants in the ecosystem are addressing them. You will leave this session with a better understanding of this landscape and ideas you can bring back to address challenges you are having with managing your embedded tooling.
---
Marc Goodner
Marc Goodner is a product manager on the C++ team focused on improving the experience for embedded developers using Visual Studio, Visual Studio Code, and GitHub.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
What's New for You in Visual Studio Code - Clang-Tidy, makefile, CMake, GitHub, & More - Marian Luparu and Sinem Akinci - CppCon 2022
https://github.com/CppCon/CppCon2022
The C++ industry is accelerating its growth year over year and more developers are entering the work force, learning the expectations of production quality C++. We've been working to make Visual Studio Code the go-to editor for all these C++ developers and their teams, no matter the platform they're on.
In this session, we will learn how Visual Studio Code’s recent advances in makefile, CMake and vcpkg integrations can swiftly unleash its C++ editor, IntelliSense, Code Analysis and code navigation capabilities for any C++ codebase in minutes.
Join us to learn how you can also set up and connect to new dev environments remotely, in containers, in the browser, in the cloud, and how to manage complex local configurations that embedded developers must contend with daily.
You'll walk away from this talk with knowledge and tools to take advantage of all that Visual Studio Code's editor and debugger has to offer, along with tips about boosting your productivity in C++ development regardless of which editor or IDE you're using.
---
Marian Luparu
Marian is the Group Product Manager for the C++ team at Microsoft, leading the team responsible for making Visual Studio, Visual Studio Code, MSVC compiler toolset and Vcpkg more productive for C++ developers.
---
Sinem Akinci
Sinem is a Product Manager for the C++ team at Microsoft working on cross-platform development.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
Fast C++ by using SIMD Types with Generic Lambdas and Filters - Andrew Drakeford - CppCon 2022
https://github.com/CppCon/CppCon2022
We show that very high-performance code can be generated when generic lambdas are instantiated with vectorized numeric types ( SIMD wrappers ). Trivial lambdas can be used to create STL-like functionality but with a performance as high as 10-20 G Flops which is competitive with the standard libraries and some commercial libraries. A small framework that supports memory management, alignment and padding of vectors is used to support this style of cppcon.digital-medium.co.uk/tag/programming/">programming. It applies users’ lambdas and filters over vector-like objects.
The performance of trivial implementations of some STL-like functions, memcopy , inner_product , sum of squared values, max_element, and accumulate ( with error correction) is investigated. In some cases, the STL generates scalar instructions and performs quite poorly when compared with the lambda generated code which is branchless and makes full use of the SIMD instructions.
Branching can be a problem for vectorized code. We explore cases where the branches have light, medium, and heavy calculation loads and different frequencies of being traversed. With frequent branching, we find that select operations are useful for handling conditional constants. This is also true for conditionals with lightweight and middleweight expressions in their branches. Our compound operation, transformSelect computes both branches and conditionally blends the in-register results appears to be quite a useful tool.
When heavy branches are traversed infrequently, we can filter to a value-based contiguous view and then perform a transform efficiently using vectorized instructions (filterTransform). In the limiting case where all branches have very heavy compute when compared to the cost of filtering, it is best to filter the cases to separate contiguous regions of memory and then apply the vectorized algorithms so that all the registers lanes can be used in the calculation.
We illustrate this with an example of writing a vectorized version of the inverse cumulative normal distribution function. We use VC++, Intel 2022, and clang compilers and compare the performance of different implementation approaches on silver and gold/W Xeons with the same function in Intel’s short vector math library (SVML).
---
Andrew Drakeford
A Physics PhD who started developing C++ applications in the early 90's at British Telecom labs. For the last two decades he has worked in finance developing calculation libraries and trading systems in C++.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
Observability Tools C++: Beyond GDB and printf - Quickly Gather Insight into the Behaviour of Your Program Using Observability Tools - Ivica Bogosavljevic - CppCon 2022
https://github.com/CppCon/CppCon2022
Going beyond GDB and printf! We present a few observability tools to help you understand what your program is doing and where it is spending time.
A must hear for all developers working with Linux and Open Source!
---
Ivica Bogosavljevic
Senior Software Engineer with 10 years of experience active in the domain of Linux and bare-metal embedded systems. His professional focus is application performance improvement - techniques used to make your C/C++ program run faster by using better algorithms, better exploiting the underlying hardware, and better usage of the standard library, cppcon.digital-medium.co.uk/tag/programming/">programming language, and the operating system. Writer for a performance-related tech blog: https://johnysswlab.com]
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
Reviewing Beginners' C++ Code - Patrice Roy - CppCon 2022
https://github.com/CppCon/CppCon2022
Beginner programmers require feedback. This includes both junior programmers and students who program, be they students in computer science, software engineering or other fields involving cppcon.digital-medium.co.uk/tag/programming/">programming.
Providing this feedback can be tedious: it requires time and attention, and is difficult to do... but it's essential, and too often neglected.
This talk aims to examine the problem of reviewing code produced by beginners, particularly C++ code, including how to evaluate this code, ensuring fairness, and managing to do it within reasonable time constraints.
---
Patrice Roy
Patrice Roy has been playing with C++ either professionally, for pleasure or (most of the time) both for almost 30 years. After a few years doing R&D and working on military flight simulators, he has moved on to academics and has been teaching computer science since 1998. Since 2005, he has been involved more specifically in helping graduate students and professionals from the fields of real-time systems and game cppcon.digital-medium.co.uk/tag/programming/">programming develop the skills they need to face today’s challenges.
Patrice been a participating member in the ISO C++ Standards Committee since late 2014 and has been involved with the ISO Programming Language Vulnerabilities working group since late 2015. He has five kids, and his wife ensures their house is home to a continuously changing numbers of cats, dogs and other animals.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
"It's A Bug Hunt" - Armor Plate Your Unit Tests in Cpp - Dave Steffen - CppCon 2022
https://github.com/CppCon/CppCon2022
Unit Testing serves many purposes, but fundamentally it's about bugs: finding them, fixing them, keeping them out of your code base.
This talk is a detailed discussion of how to write unit tests that are good *tests*; that is, unit test cases that are complete, accurate, and thorough. We can think of unit tests as our laboratory equipment for carefully examining our code and measuring a particular property (existence of bugs) with care and precision; or we can think of them as bug-hunting gear that that keeps us safe when we have to venture into the dark and dangerous parts of our code base.
Over the past several decades, the software community has learned, usually the hard way, many principles and best practices for unit testing, but these are documented across a wide variety of books, blogs, and talks. This talk will discuss, summarize, and try to simplify what we have learned about making our unit tests effective at finding bugs, describing them, and removing the little critters from our code base.
We will look at examples, consider test organization, and get into the nitty-gritty of edge and corner cases. We will also look at a case study of a famously ill-fated debugging expedition, with the goal of learning from their mistakes -- better than learning from your own! -- and, incidentally, (re)introducing some important cultural memes that no bug-hunters should be without.
---
Dave Steffen
Dave Steffen completed his Ph.D. in theoretical physics at Colorado State University in 2003, and promptly changed course for a career in software engineering. He has worked primarily in defense and aerospace, and is currently a Principal Engineer at SciTec Inc.'s Boulder office. For reasons unknown, he has turned out to be the expert, champion, and occasional street-corner evangelist for unit testing at most of the companies he has ever worked at.
__
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Back to Basics - Object-Oriented Programming in Cpp - Amir Kirsh - CppCon 2022
https://github.com/CppCon/CppCon2022
C++ is not just an Object-Oriented Programming Language, it supports many paradigms. But in this session we would focus on the object oriented aspects of C++, from encapsulation to inheritance and polymorphism.
The session aims to cover the basic syntax together with best practices, tips, pitfalls to avoid and more. We would discuss design considerations, the advantages and disadvantages of different approaches and other alternatives that the language provides. Some relevant design patterns may also pop-by.
This session is part of the Back to Basics track and is aimed for novice and intermediate C++ developers (up to about 2-3 years of C++ coding experience). More experienced developers are of course welcomed to join and enrich the discussion with their knowledge and experience.
---
Amir Kirsh
C++ lecturer at the Academic College of Tel-Aviv-Yaffo and Dev Advocate at Incredibuild. Previously the Chief Programmer at Comverse. Co-organizer of Core C++ conference and a member of the Israeli ISO C++ NB. Currently a visiting researcher at Stony Brook University, New-York.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
