CppCon, The C++ Conference

CppCon, The C++ Conference 2024 - Gili Kamma: "Boosting Software Efficiency in C++: A Case Study of 100% Performance Improvement in an Embedded C++ System" youtu.be/LE1ocLWiUKQ Ever wrestled with an embedded unit that had a mind of its own? That was my reality a few years ago. This unit, built with Linux, C++, and QT, was designed to be a reliable middleman, handling RF frames from a multitude of endpoints. But it was a bit of a wildcard - unexplained resets, occasional data loss, and all. It was supposed to support 7500 endpoints, but once we hit 5000, it started to show signs of strain. The software was a tough nut to crack - maintaining it was a challenge and it wasn't exactly a developer's favorite. But here's where the plot thickens: after two years of relentless work, we transformed this underdog into a champion. The unit now supports 10,000 endpoints, with zero resets or data loss. Intrigued? Join me as I unravel the journey of this remarkable turnaround. Let's dive into the world of embedded systems and explore how we turned the tide in our favor. It's a tale of performance improvements, overcoming challenges, and making the impossible possible. If you've ever wondered how to boost efficiency in embedded systems, or if you're just a fan of a good tech turnaround story, this talk is for you. --- Gili Kamma has a B.S.c in electrical engineering from Tel-Aviv University, Israel. With almost 20 years of experience developing embedded systems, she has worked across plenty of technical environments, BSP and low-level drivers in C, C++, Python, C#, Java, DB, and Cloud. She is an expert in developing embedded systems, gained a lot of knowledge from changing projects and products every year or two for the past 20 years. She has extensive experience in creating applications from scratch, improving the performance of existing ones, and maintaining products by solving bugs and ensuring quality. She has broad experience in industries such as Automotive, Cyber, IOT, Networking, and Aerospace. These days, she is the R and D manager at Blitz Electric Motors in Israel.

It was so cool getting to investigate C++ design trends with the amazing people at CppCon! I definitely learned some things and hopefully everyone else did too!!

CppCon, The C++ Conference 2024 - Katherine Rocha: "Investigating C++ Legacy Design Trends: Newer Isn’t Always Better!" youtu.be/ffz4oTMGh5E All code is legacy code, or so they say. Software engineers scoff at the idea of new code instantly becoming legacy code, however software is a time capsule holding the design trends of the time the code was written. As new code is written, new design trends are used and potentially overused, just like the legacy patterns. What if these new design trends have more in common with the original design trends than we initially thought. One example we will investigate is object oriented design through polymorphism and how it has been replaced in many cases with template metaprogramming. There are a variety of template metaprogramming strategies that achieve the object oriented design principles, however when overused you can encounter as many templates as there would be virtual functions in object oriented programming. Have we discovered that balance is the solution or are we still overusing the “fancy” new thing? In this talk, we will investigate various legacy design trends including further examining object oriented design, the singleton pattern, as well as other legacy anti-patterns to reveal the updated trends. We will address each legacy anti-pattern and their corresponding modern update to evaluate whether newer is better or if we have recreated the same legacy problem. --- Katherine Rocha is a new-ish software engineer who graduated in 2022. She’s passionate about embedded systems, real-time systems, and understanding as much as possible. She has been an active member of the C++ community for her entire career, starting with lightning talks at CppCon 2022 and C++Now 2023. She’s figuring it out one warning, error, and question at a time.

CppCon, The C++ Conference 2024 - Amandeep Chawla: "Modern C++ Development - Limitations and Problems in std::function and Similar Constructs: Mitigations and Alternatives" youtu.be/clpQVn_LAiM In this talk, we will delve into the limitations and challenges associated with using std::function, std::packaged_task, std::apply, and similar constructs in modern C++ development. Despite their utility, these constructs often introduce performance overheads by invoking copies and moves of captured member variables, leading to increased complexity and unexpected behavior. I will share practical examples and common pitfalls encountered in real-world applications. Finally, I will present an alternative approach I have developed to mitigate these issues, offering a more efficient and reliable solution for developers. --- Amandeep Chawla is a seasoned software engineer with over 20 years of experience in C++. Since graduating in 2002, he has been actively working with C++ throughout his career. In his early years, Amandeep specialized in embedded systems, where he utilized a small subset of C++. This foundational experience provided him with a deep understanding of low-level programming and resource-constrained environments. In 2006, Amandeep joined Adobe, where he has held various roles over the past 17 years. Throughout his tenure at Adobe, he has been extensively involved in projects that heavily rely on C++. As a Senior Computer Scientist - II, Amandeep is currently a valued member of the core team responsible for Adobe CC Libraries. His contributions to the team involve leveraging C++ to develop robust and cross-platform solutions. With his extensive experience in C++, Amandeep has gained valuable insights into the language's strengths, limitations, and best practices. He has a deep appreciation for tackling complex challenges and finding innovative solutions to optimize performance, maintainability, and cross-platform compatibility.

CppCon, The C++ Conference 2024 - Amir Kirsh: "Back to Basics: Rvalues and Move Semantics in C++" youtu.be/i_Z_o9T2fNE Rvalue references and move semantics, introduced in C++11, were an important addition for the way we manage resources and optimize performance in our code. However, mastering these concepts can be challenging, leading to common pitfalls and misunderstandings. In this session, we will demystify rvalue references and move semantics, covering their underlying principles, practical applications, and best practices. We will start with the fundamentals of what rvalues are, how to implement and use move semantics correctly, covering the delicate syntax rules, then discuss design considerations and guidelines. We will cover the rule-of-zero, rule-of-three and rule-of-five, the need for std::move and when to use it, as well as forwarding references and std::forward. By focusing on the applicability of the subject, and with a clear and concise exploration of the fine details, participants would gain a solid understanding of how to master rvalue references and move semantics in their own codebase, with the ability to write more efficient and robust C++ code. --- Amir Kirsh is a C++ lecturer at the Academic College of Tel-Aviv-Yaffo and Tel-Aviv University, previously the Chief Programmer at Comverse, after being CTO and VP R&D at a startup acquired by Comverse. He is also a co-organizer of the annual Core C++ conference and a member of the ISO C++ Israeli National Body.

Check out my presentation ??

CppCon, The C++ Conference 2024 - Marcell Juhász: "Cost of C++ Abstractions in C++ Embedded Systems" youtu.be/7gz98K_hCEM This session will feature detailed case studies that measure the overhead associated with common programming abstractions in the context of embedded systems. By examining both compile-time and run-time implications, attendees will gain valuable insights into how these abstractions impact system resources like memory usage and execution speed. Key areas of exploration will include: o Encapsulation: Assessing the cost of data hiding and interface protection depending on implementation strategies. o Inheritance: Evaluating the costs and benefits of using class hierarchies in environments where memory and processing power are limited. o Polymorphism: Comparing run-time polymorphism via virtual functions to compile-time alternatives like templates and concepts, analyzing their respective impacts on performance and flexibility. Through empirical data and performance metrics, participants will observe how traditional object-oriented techniques affect resource utilization. The discussion will also cover the advantages and trade-offs of these techniques, providing a balanced view of their impact on embedded systems. Designed for developers and system architects working within the constraints of embedded systems, this talk aims to provide valuable insights into making informed decisions about when and how to use specific programming abstractions. Attendees will leave with a clearer perspective on optimizing their code for maximum efficiency, armed with practical knowledge about the trade-offs involved in adopting various software design paradigms. --- Marcell Juhasz is an embedded software developer at Zühlke Engineering, a global innovation service provider that transforms ideas into new business models by developing cutting-edge services and products. At Zühlke, Marcell leverages his expertise in C++ and modern technologies to create advanced embedded systems. Prior to joining Zühlke, he gained valuable experience working at several smaller companies, where he developed new products and maintained existing ones using C++. Marcell recently graduated from the Vienna University of Technology with a specialization in embedded systems. His master's thesis focused on the benefits of using modern C++ in embedded systems, deepening his understanding and proficiency in the language.

CppCon, The C++ Conference 2024 - Kris Jusiak: "Template-less Metaprogramming in C++" youtu.be/yriNqhv-oM0 Meta-programming is one of the most significant C++ superpowers. It enables seemingly impossible feats, but there is a considerable cost associated with it as well. Therefore, its applications have been limited to experts and cases where the benefits greatly outweigh the maintenance burden. But what if that doesn't have to be the case? In this talk, we will explore an alternative approach to template meta-programming that does not require an understanding of the traditional 'angle bracket' technique. We will also make the case that anyone who can write C++ can become a meta-programming guru! But what about compilation times and/or testing/debugging, you may ask? Well, we will cover those as well, and it might be surprising what modern C++ is actually capable of! Additionally, we will cover how the static reflection proposal and C++20 ranges can further improve the ability to write meta-functions and how C++ compares to other languages such as circle. However, we will also show how to apply the technique with C++17 on all major compilers with a ready-to-go solution. Finally, we will benchmark compilation times of different approaches, showcasing their strengths and weaknesses. If you are interested in meta-programming or have always wanted to understand its practical use cases but never really grasped them, this talk is for you! --- Kris is a passionate Software Engineer with experience across various industries, including telecommunications, gaming, and most recently, finance. He specializes in modern C++ development, with a keen focus on performance and quality. Kris is also an active conference speaker and open-source enthusiast, having created multiple open-source libraries.

CppCon, The C++ Conference 2024 - Michael Caisse: "C++ Sender Patterns to Wrangle C++ Concurrency in Embedded Devices" youtu.be/a2gLF9Supic Small embedded devices might only have one processing core but hardware accelerators, peripherals, and external events abound. Asynchronous event handling is the bread and butter of these systems; however, the lack of robust libraries in the bare-metal arena often result in a concurrency nightmare. After a short sender/receiver primer, we will explore some patterns and idioms that have proven useful when employing the design in a high availability, complex embedded device. We will use Intel's open source bare-metal senders and receivers library (https://lnkd.in/gc7gxv5m...) as well as other open source packages to build elegant, declarative solutions around interrupt handling, schedulers, devices drivers, and communication protocols. The patterns will be demonstrated on an STM32 target controlling a simple robot. While this talk is focused on bare-metal implementations and embedded concerns, the shape of a solution is applicable to many domains and environments. Join me as we wrangle concurrency using the sender and receiver design. --- Michael Caisse has been crafting code in C++ for nearly 25-years. He is a regular speaker at various conferences and is passionate about teaching and training. Michael is the owner of Ciere Consulting which provides software consulting and contracting services, C++ training, and Project Recovery for failing multidisciplinary engineering projects. When he isn't fighting with compilers or robots, he enjoys fencing with a sabre.

CppCon, The C++ Conference 2024 - ??Vitaly Fanaskov "Monadic Operations in Modern C++: A Practical Approach" youtu.be/Ely9_5M7sCo In C++23 we have std::optional and std::expected along with the "monadic" operations that can be used on the objects of these types. By chaining the computations, these abstractions allow you to manipulate the underlying values using less boilerplate code. In addition, we have a range library for processing collections of elements in a similar manner. These topics have been quite popular in the C++ community for the last five years or so. However, many of them are focused on theoretical parts, have only small non-related examples, or even use other programming languages to illustrate the ideas. This talk is prepared based on more than one year of using functional programming approaches for developing one of the commercial internal libraries our team is working on. I’m going to share this experience with the audience. We’ll talk about API design in general, spitting between pure and impure context, and the pros and cons of using “optional” and “expected”. There will be real code examples and some useful tips. --- Vitaly Fanaskov is a senior software engineer at reMarkable. He has been designing and developing software using C++ and some other languages for over 10 years. Primary areas of interest are design and development of frameworks and libraries, modern programming languages, and functional programming. Vitaly holds a PhD in Computer Science from the Moscow State Mining University.