Using C++14 in an Embedded “SuperLoop” Firmware - Erik Rainey - CppCon 2022
https://github.com/CppCon/CppCon2022
This presentation covers what the execution environment of an embedded "superloop" firmware is in order to describe later why certain C++14 language and library features are used and others are not. This environment lacks many basic features and capabilities that traditional C++ programmers may think are common place but is able to be programmed in C++14 (and later) with a specific design paradigms and guidelines. Programmers with deeply embedded C experience will be familiar with some of the limitations of the environment but may find the C++ solutions quite refreshing! The talk will conclude with some comments on C++17 / C++20 features which will be quite valuable to embedded environments of all types.
---
Erik Rainey
Erik is a Senior Software Engineer at Amazon working in the Prime Air on low-level/embedded firmware written in C++ for drones. He has got more than 20 years of professional experience making 21st century technologies on embedded devices which can blink LEDs. He's also been a contributor to Khronos's OpenVX 1.0 specification.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Cross-Building Strategies in the Age of Cpp Package Managers - Luis Caro Campos - CppCon 2022
https://github.com/CppCon/CppCon2022
Embedded devices like the Raspberry Pi and NVIDIA Jetson are becoming increasingly popular for both enthusiasts and enterprise-grade applications, in particular for Machine Learning workloads that require a low-power profile. On devices that provide a native build toolchain, developers will typically face two choices: build their applications and their dependencies on the target device, which can take considerably longer than the equivalent workload on a typical PC, or carefully set-up a cross-compilation environment on a more powerful PC where using the correct dependencies (and their versions!) can become more of a challenge.
On the other hand, with macOS and Windows now officially supported on ARM processors, end users will typically expect applications to run natively for the best performance possible, rather than rely on emulation where the performance hit may negatively impact the user experience. The first step before shipping an application is building it, and cross-building existing applications can help vendors get over that first hurdle without having to wait for native hardware, especially given the current supply chain constraints.
But setting up a cross-compilation environment can be challenging and often confusing, and the build scripts for some libraries may not have considered supporting cross-building workflows. C++ package managers have gained a lot of traction in recent years. If we are already using them for our local build workflows, why not leverage their power to support cross-compiling?
This talk focuses on exploring how we leverage the concepts introduced by modern C++ package managers like Conan and vcpkg and apply them to the cross-building workflow, and the technical challenges faced by these tools to enable this. A practical example will be demonstrated where we can cross-build an existing application using familiar tooling, simplifying the workflow and saving considerable time.
---
Luis Caro Campos
Luis is a Electronics and Computer Engineer based in the UK, with previous experience as a C++ engineer in the field of Computer Vision and Robotics. Currently, he is concerned with the problem of enabling Software Development at scale: focused on the tooling and processes to support large teams of engineers in writing code. He is currently part of the Conan team at JFrog, focused on the problems of the C++ community at large.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Simulating Low-Level Hardware Devices in C++ - Ben Saks - CppCon 2022
https://github.com/CppCon/CppCon2022
When developing software that will interact directly with hardware, embedded developers often find it more convenient to use simulated hardware rather than real hardware. Early in the project, the real hardware may still be under development. Later, using simulated hardware lets us avoid potential overhead costs of cross-development (e.g., uploading the program to the real hardware). Moreover, it’s often difficult to test error-recovery code for errors that occur only rarely; using simulated hardware, we can sidestep this problem by cppcon.digital-medium.co.uk/tag/programming/">programming it to emit a failure signal consistently.
A simulator in C++ can mimic actual hardware remarkably well. In this session, we’ll show you how to use operator overloading, user-defined conversions, and other C++ features to simulate not just complete hardware devices, but individual hardware registers. With this approach, the code that interacts with simulated device registers can be nearly identical to the code that interacts with real hardware.
---
Ben Saks
Ben Saks is the chief engineer of Saks & Associates, which offers training and consulting in C and C++ and their use in developing embedded systems. Ben represents Saks & Associates on the ISO C++ Standards committee as well as two of the committee’s study groups: SG14 (low-latency) and SG20 (education). He has spoken at industry conferences, including the C++ and System Software Summit, the Embedded Systems Conference, NDC Techtown, and CppCon, where he’s also chair of the Embedded Track and a member of the program committee. Ben previously worked as a software engineer for Vorne Industries, where he used C++ and JavaScript to develop embedded systems that help improve manufacturing productivity in factories all over the world. He’s also a contributing author on multiple Vorne patents.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Architecting Multithreaded Robotics Applications in C++ - Arian Ajdari - CppCon 2022
https://github.com/CppCon/CppCon2022
Many tasks in robotics are natural candidates for parallelization and concurrent execution, and could potentially benefit greatly from multicore processors. However, non-functional quality requirements in robotics are different than those in information systems, and closely revolve around ensuring proper reaction time and acceptable worst-case
execution time. These quality properties can only be properly addressed on the system level because of the high coupling between concurrent threads (interrupts, limited number of computing cores, preemption, shared cache, synchronization, and communication).
Architecting these types of software presents a significant challenge. It requires robotics engineers to understand multicore processors in low-level detail and requires significant programming skills. As a result, programming multicore processors is a cumbersome process and is error-prone. Therefore, software architects, who understand the needs of robotics engineers and understand the software stack develop solutions, which make it possible for robotics engineers to produce correct multi-threaded code easily and allow them to concentrate more on their specific needs regarding robotics engineering.
For this reason, the problem of utilizing multicores in robotics engineering is identified and a suitable solution targeted to robotics engineers is provided. This process is explained step by step and supported with numerous examples. The attendant gets the chance to experience how a software engineer understands the problem and how a solution is devised. It includes all steps of identifying the requirements, architectural drivers, architectural solution, implementation, and a comprehensive evaluation of the solution. All of this is specifically targeted at the C++ programming language.
---
Arian Ajdari
I am Arian Ajdari and I was born in Pristina, Kosovo. I was lucky enough to be raised surrounded by different languages. Therefore, learning new languages has always been a joy for me. I felt very passionate when I discovered programming languages and immediately knew, that programming languages is something I will learn for the rest of my life.
This lead me to study Computer Science, where I got the chance to learn about different aspects of programming. I grasped as many programming concepts as possible and applied them in real-life. This led me to develop a toy application in form of a Bachelor Thesis titled "Melanoma Cancer Detector" where users could upload a picture and Machine Learning Classification Algorithm would give a score whether in a particular spot cancer could develop. Furthermore, I decided to go for a specialization in domain in Software Engineering and did 2 years of Master, graduating on topic "Framework to facilitate development of multithreaded applications in ROS2"
Experience that I got through education and my full-time employment, lead me to realize that developing software is not just a matter of technical skills. It is a combination of many hard- and soft-skills. Therefore, I developed a talk on topic "Architecting Multithreaded Robotics Applications in C++", where you get to see the complete thinking process of developing a C++ application (and many of my failures as well), implementation, evaluation and finally handing the API to the client. I invite YOU, the attender, to embark on this journey together.
With kind regards,
Arian Ajdari
__
Videos Streamed & Edited by Digital Medium: http://online.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
Taking Static Type-Safety to the Next Level - Physical Units for Matrices - Daniel Withopf - CppCon 2022
https://github.com/CppCon/CppCon2022
If you are interested in achieving the ultimate goal in library interface design: "If it compiles, it works!", this talk is for you!
There are several existing C++ libraries to annotate scalars with their physical units.
This talk will present a full-blown solution for a related problem that has not been solved in C++ before: How can we put distinct physical unit types (e. g. meters, seconds, meter per second...) inside a single vector or matrix type from a linear algebra library?
The presented solution uses C++'s strong type system to provide these physical unit annotations for each matrix element. Furthermore, it also enables coordinate frame and quantity kind annotations (think X- and Y-position in coordinate frame A or B which have identical units but refer to different things).
We will learn what is the best way to represent these annotations, how they propagate through linear algebra operations, how they determine the subset of valid operations on each type and of course and most importantly, how this can be implemented efficiently in C++ (with a special on how C++20 is a game-changer here).
While developing the solution, we will also understand how this leads to code that is more expressive and less likely to contain errors because the majority of bugs can be caught at compile-time.
Applications that benefit from this include robotics, computer graphics, automated driving and any other domain that works with physical units, different coordinate frames and matrix operations.
---
Daniel Withopf
Daniel Withopf has been working on solving real-world problems with C++ in robotics, computer vision and related fields for over 20 years. He is a Staff Software Engineer at the German car supplier Bosch where he wrote and maintains an object tracking framework for self-driving car projects. While doing that he discovered novel ways how to leverage C++'s type system to create linear algebra and tracking code that is more expressive, easier to understand and less likely to contain errors.
__
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
