In the previous post, I went through the most efficient method I know to find the source of a bug. Here it is, summed up: 0) Don’t start by looking at the code 1) Reproduce the bug 2) Do differential testing __2a) Start with a tiny difference __2b) Continue with larger differences 3) Formulate hypotheses […]
Do you like doing maintenance as a software activity? Most people don’t. Maintenance is often associated with trudging through lines of code with the debugger in a desperate search for bugs, in software that someone else wrote. All in all, maintenance gets the reputation of being an unrewarding activity, with low intellectual stimulation and not […]
In our objective to understand how the GoF design patterns relate to the GRASP design principles, we’re going to analyse 3 more Behavioural patterns today: Iterator, Mediator and Memento. Summary of the previous episodes As a reminder, the GRASP principles are a set of 9 design principles that help take design decisions about where to […]
Today we have a question from Fluent C++ reader Nithin: Hi Jonathan, Thank you for the very useful Fluent C++ site. I am learning a lot from the site and applying things that I learn from there to write more expressive code. I have several classes in my code base as below. Let’s say I […]
Implementing comparison operators in C++ is easier said than done. Indeed, for most types, if we could talk to the compiler we would say something like: “to order them, use a lexicographical order on their members”. But when it comes to writing the corresponding code, things get more complicated. However, a classical technique using std::tuple makes […]
Fluent C++ reader Sam wrote to me asking how to make a template expression simpler. This is an interesting question and I’m grateful to Sam for bringing it up. We’re going to examine this case where template parameters became unwieldy, and see how to simplify them by using template template parameters. The case Let’s have a […]
Feeling like the codebase you’re working on is poorly designed? Wish you could focus on writing good code, rather than trudging through mud code all day long? Would life be easier if only the legacy codebase had a clearer structure? If you answered Yes to any of those questions, be aware that you’re not alone. […]
More than an exact science, designing our code is a craft (there is even a branch of software development that is called software craftsmanship). To guide us through this craft of designing our code we have guidelines that have been accumulated over the ages (or rather, decades) by software developers. 23 of them have been […]
By upgrading a compiler to C++17, a certain piece of code that looked reasonable stopped compiling. This code doesn’t use any deprecated feature such as std::auto_ptr or std::bind1st that were removed in C++ 17, but it stopped compiling nonetheless. Understanding this compile error will let us better understand a new feature of C++17: extended aggregate initialisation. The […]
Functions should take their inputs as parameters and produce outputs with their return types. This is the basics of functions interface design. This makes functions easier to understand just by looking at their prototype. It makes functions functional. But C++ only allows to return one value out of a function. What if we’d like to […]
