Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 10/10)
GitLab Pipeline Blueprint and a Migration Checklist Parts 1 through 9 were about technical discipline: standard selection, deterministic rules, time…
Tag: c++
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 9/10)
Observability Belongs on the PC, Not in the Production Binary Part 7 covered host-first testing. Part 8 added hardware-in-the-loop testing…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 8/10)
Python and ASCII Protocols for Hardware in the Loop Part 7 pushed as much validation as possible onto the host:…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 7/10)
Test the Firmware Without the Board: Host First Strategy Parts 3 through 6 established the foundation: deterministic rules, time discipline,…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 6/10)
No Allocation in the Loop: Memory Rules That Survive CI Parts 3 through 5 established the core theme: determinism comes…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 5/10)
Concepts for Hardware Platforms, Not Vtables Part 4 was about time discipline. Part 5 is about architecture discipline: separating core…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 4/10)
Modern C++ for Deterministic Firmware, Part 4 Time and Scheduling Without Footguns Part 3 laid down the rules you do…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 3/10)
Deterministic By Construction: The Rules You Do Not Cross Part 1 made the case that modern C++ can belong in…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 2/10)
Choosing C++20 Today, C++23 on a Short Leash Introduction: Choosing a Standard Is an Engineering Decision In Part 1, I…
Modern C++ Firmware: Proven Strategies for Tiny, Critical Systems (Part 1/10)
The Case for Modern C++ on Tiny, Safety Critical Targets Modern C++ Belongs in Firmware. But if you spend time…
AI Coding Shootout: Claude or ChatGPT for Coding Assistance?
AI models like Claude and ChatGPT have changed how we write and review code. Both are useful…just not in the…
60 Second Lesson: C++ Token Pasting Metaprogramming
C++ token pasting metaprogramming provides intermediate developers with a low-friction way to generate near-identical classes without wrestling with heavyweight template…
CMake Optimization: Boost Build Speed with These Expert Tips
If you’ve ever sat through a CMake configuration slower than a Monday morning meeting, you’re not alone. We’ve all stared…
Update: Conditional Moves vs. Branches – What Compilers Really Do
Recently, there’s been a lot of chatter online about compilers “ruining” hand-tuned branchless code. Developers expect a ternary expression or…
Branch Prediction: The Definitive Guide for High-Performance C++
Branch prediction plays a critical role in optimizing modern C++ applications, especially when low latency is a core requirement. Every…
C++ Performance Checklist for Low-Latency Systems
This checklist serves as a practical reference you can apply whenever you’re writing or reviewing performance-critical C++ code — particularly…
7 Interesting (and Powerful) Uses for C++ Iterators
C++ iterators were introduced as part of the Standard Template Library (STL) to provide a uniform way to traverse different…
ZeroMQ’s REQ/REP Pattern Magic: Lightning-Fast C++ & Python Messaging
C++ is known for its speed and efficiency, while Python shines with ease of use and a rich ecosystem. When…
The Definitive Guide to the C++ final Keyword
The C++ final keyword is a powerful tool that prevents class inheritance and virtual function overriding. While primarily used to…
Standardizing the Handling of Non-Source Files in CMake Projects: The Config Target
As C++ projects grow, they often include files that aren’t part of the source code but remain essential—files like README.md,…
12 Ways C++ Developers Increase Cyber Attack Vulnerabilities and How to Prevent Them
Software development requires a careful balance between functionality, performance, and security. C++ developers, with the language’s powerful features and fine-grained…
Exploring C++ std::span – Part 5: Performance and Practicality
Throughout this series, we’ve explored the capabilities and best practices for using std::span. We began by understanding its role as…
Exploring C++ std::span – Part 4: Const-Correctness and Type-Safety
One of the hallmarks of modern C++ is its emphasis on type safety and const-correctness. These principles help developers write…
Exploring C++ std::span – Part 3: Subviews and Slices
One of the most powerful features of std::span is its ability to create “subviews,” or smaller views over specific portions…
Exploring C++ std::span – Part 2: Accessing Elements and Iterating
In C++20, std::span provides a safe, convenient way to access and iterate over contiguous data, offering many of the familiar…
Exploring C++ std::span – Part 1: An Introduction To the Non-Owning View
What is std::span? std::span is a feature introduced in C++20, designed to provide a safe and efficient way to create…
The Humble and Surprising C++ Semicolon; Origins, Use, and Art
In C++, the semicolon is more than a mere syntactical rule—it’s a critical delimiter that signifies the end of a…
Powerful Tips and Techniques for std::mutex in C++
Concurrency and parallelism have become vital aspects of modern C++ programming, demanding robust mechanisms for handling multi-threaded environments. Enter std::mutex, a…
In-Source vs. Out-of-Source Builds
In some software engineering circles, there remains a debate (or needs to be a debate) about using In-Source versus Out-of-Source…
The Definitive Guide to std::expected in C++
std::expected is a powerful feature introduced in C++23 that offers a modern, type-safe alternative to traditional error-handling methods. Throughout my…
C++ Error Handling Strategies – Benchmarks and Performance
Error handling is a critical component of many C++ applications. Even so, there are many strategies we can use to…
Book Review: Modern CMake for C++
Book Review: Modern CMake for C++ (Second Edition) by Rafał Świdziński As a CMake developer and user for over 15…
Custom Allocators in C++: High Performance Memory Management
Custom allocators in C++ can be intimidating to approach in our code. C++ is renowned for its powerful standard library…
Why Mastering std::vector Is Essential for C++ Developers
Mastering std::vector is essential for advanced C++ Development. While many experienced C++ developers are familiar with std::vector, its full potential…
Leveraging the Power of Transparent Comparators in C++
The C++14 standard introduces a compelling feature: Transparent Comparators. C++ programmers often encounter the concept of comparators when working with…
Looking for Pointers: The C++ Memory Safety Debate
The dialogue around C++ and memory safety has intensified following recent evaluations by authoritative bodies. The White House’s Office of…
Data Structures and Algorithms with the C++ STL: A guide for modern C++ practitioners
My new book, Data Structures and Algorithms with the C++ STL: A guide for modern C++ practitioners, will be released…
The Service Locator Pattern: A Robust C++ Implementation
The Service Locator pattern is a powerful design pattern that is used in many types of programs. Design patterns help…
The Decorator Pattern: From Basic to Advanced Concepts in C++
The Decorator Pattern stands out for its unique ability to add new functionalities to objects dynamically without altering their structure. This pattern not only enhances the capabilities of individual objects but also fosters a flexible and extensible design, making it a powerful tool in the arsenal of a C++ programmer.
Engineering Mathematics: A Focus on IEEE Floating Point and the Radar Range Equation in C++
The implementation of mathematical equations demands a keen awareness of the computational environment. This article illustrates the importance of considering IEEE floating point representation in C++ (as well as Python and FORTRAN) for accurate and reliable computations.
Unlocking the Power of std::hash in C++ Programming
Hashing, a cornerstone concept in computer science, plays a pivotal role in efficient data processing and storage. In C++, std::hash emerges as a critical component, deeply ingrained in the language’s Standard Library. This article aims to demystify std::hash, making it accessible and understandable to entry and intermediate-level C++ developers.
Breaking Down C++20 Callable Concepts
C++20 Callable Concepts refer to a powerful feature introduced in the C++20 standard that allows developers to specify and enforce constraints on function objects, lambdas, and other callable entities in a more expressive and type-safe manner.
Demystifying Static vs. Dynamic Linking in C++
What do you consider when choosing static vs. dynamic linking? Choosing the right one for your library requires a nuanced understanding of each.
Writing the Ultimate Guide on Data Structures and Algorithms with the C++ STL
I am currently authoring a new book covering data structures and algorithms using the C++ STL. I am interested to know the community’s thoughts on what would make the book a valuable addition to the C++ community!