25 Years of Coding Wisdom in 30 Seconds
This is your cheat sheet if you’re looking for quick, actionable advice from the trenches. 1: Debugger = Your Secret…
Recent Posts
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…
OpenAI Structured Outputs: Transforming Data Interpretation
As artificial intelligence continues to evolve, the demand for more efficient and accurate data processing solutions is higher than ever.…
The Role of Technical Management and Mentorship in Your Career
The role of your manager, particularly in software engineering, can significantly affect your career trajectory. A manager with a technical…
Kolmogorov Complexity: Practical Examples for Simplifying Code
Kolmogorov complexity measures the shortest possible description of an object, like a string or a piece of code. In programming,…
A Guide to Building Better Blog Posts with AI
Can AI help us craft better blog posts without falling into the trap of producing generic “content”? Absolutely. In this…
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…
Agile Failure – What Drives “268% Higher Failure Rates?”
TL;DR; – Agile, as a management philosophy, requires a whole organization commitment and the right leadership to be successful. Bad…
Breaking Free from Zero-Sum Thinking
Zero-sum thinking (sometimes called the Zero-Sum Fallacy) is a mindset where resources are viewed as finite and fixed, meaning one…
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…
Harnessing Data-Driven Decision-Making in Software Development
The use of data to make decisions as a software developer is a core skill. It transcends mere operational enhancement,…
Generative AI Acceleration in the Air Force
To achieve Generative AI Acceleration, the Department of the Air Force Chief Information Officer has proposed revamping the approval process…
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…
An Inescapable Trap: Everyone Can Be Socially Engineered
Social engineering represents one of the most insidious forms of cyberattack, exploiting the most vulnerable link in the security chain:…
Projects vs. Products: Perspectives on DoD Software Execution
At first glance, defining a software project vs. a product seems like a difference in semantics. Looking deeper, however, understanding…
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…
Build One to Throw Away: Embracing Iteration
The principle of “Build One to Throw Away” from Frederick Brooks’ “The Mythical Man-Month” is an important yet often misunderstood…
The “No Silver Bullet” Principle in Modern Software Development
Our industry is often (always) captivated by the latest technological advancements. Rightfully so. It is what drives us personally and…
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.
The Second-System Effect: Balancing Ambition and Pragmatism
The Second-System Effect can lead to overcomplicated and bloated systems due to a misunderstanding of the first project’s constraints and an overzealous desire to rectify its limitations.
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.
Navigating the Man-Month Myth: Understanding Team Dynamics in Software Projects
Understanding how team size impacts project progress is crucial. The Man-Month Myth, a concept popularized by Frederick Brooks, challenges the…
The Impact of FedRAMP Equivalency on Defense Contractors
A recent memo on FedRAMP Equivalency from the DoD has set a new course for defense contractors working with CUI in cloud environments. This pivotal memo outlines the stringent requirements for FedRAMP equivalency, but what are the implications of this memo on the defense industry and the second-order consequences for innovation, development time, and overall cost of compliance?
Winning at Game Theory with “The Price is Right”
“The Price is Right” can serve as an engaging and unconventional guide to understanding game theory and its application in software engineering. From the bidding strategies in the “One Bid” round to the risk assessment in “Plinko,” the show offers a treasure trove of lessons relevant to the challenges and decisions we face in the tech world.
Dancing on a Knife Edge: Goodhart’s Law in Action
Metrics and measurements are vital tools. They guide decisions, shape strategies, and can provide a clear picture of progress and productivity. However, a fundamental principle, often overlooked, governs the use and impact of these metrics: Goodhart’s Law.
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.
Navigating the Pitfalls of ‘Hero Culture’ in Team Management
For many managers, the allure of fostering a ‘Hero Culture’ can be tempting. However, it carries with it the seeds of potential crises.
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.
Talent Rotation: Stop the Downward Spiral
Some organizations have adopted a policy of frequently rotating staff through different projects. While this approach aims to broaden experience, it’s worth taking a closer look at the implications.
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.
Dissecting the Mind of the Optimistic Programmer
Programmers are optimists. For software engineers, optimism is not just a personality trait but a necessary mindset. As Frederick P.…
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!
Active Career Management for Technical Professionals
Career management is hard. When managing your career in an evolving professional landscape, it’s not uncommon to find oneself at a career crossroads, wondering whether it’s time to seek new horizons or stay the course. But often, this introspection isn’t just about analyzing the company’s role in our professional growth but also self-reflecting on our contributions and responsibilities.
Push/Pull Communication Development in Agile Teams
Introduction Push/Pull communication is a fundamental concept in communication, dictating how information flows within an organization. This article discusses various…
“Tech Stacks” are fast Becoming “Tech Piles”
In the early days of software development, the simplicity of tools like VI and a compiler sufficed for building enterprise-scale applications. Today, we find ourselves wading through an ever-expanding array of tools and technologies that have caused us to wander off the path of value creation.
The Ghostbuster Interview and Hiring Process
Can we look to the Ghostbusters for inspiration on interviewing and hiring? Let’s explore their process and see how they managed (without using Workday.)
Naming Things – A Comprehensive Guide
Naming Things is hard. The guidance provided here is derived from years of making mistakes, wishing I had done things better, and finding ways to get tools to do my work for me (and get on with the interesting problems).
How Pair Programming For Engineers Builds Quality
Establishing pair programming between a software engineer (in the driver role) and a domain expert (in the navigator role) can significantly enhance the quality and accuracy of domain-specific software.
How to Build Technical Capital
Balancing software development requires managing technical debt and capital. While debt can fast-track projects, building robust technical capital ensures long-term software resilience and quality.
SemVer is Broken! Introducing Algorithmic SemVer
The promise of Semantic Versioning (SemVer) is tantalizing. However, as is often the case in software engineering, the real world is messier than our theoretical models. Introducing Algorithmic SemVer as an alternative software versioning scheme.
Use Reasonable Defaults To Build Better Teams
Start with the default settings and see if you can live with them and tweak your process to accommodate before going off and making everything custom. The more custom something is, the harder it is to maintain.
The Win-Win-Win Principle for Stronger Businesses and Careers
The Win-Win-Win Principle is a holistic approach to business that ensures value is created for the client, business, and employees. Derived from experiences in software engineering companies, it advises looking for opportunities that bring mutual benefits, such as strategic alignment, operational efficiency, and personal growth.
Now leave before I am forced to taunt you
Sir Galahad: Is there someone else up there we can talk to? Frenchman: No, now go away or I shall…