Fluent C++ - Jonathan Boccara’s blog

Usage First, Implementation After: A Principle of Software Development
▻https://www.fluentcpp.com/2022/06/25/usage-first-implementation-after-a-principle-of-software-development

You know when you work on various projects, and you use various tricks and techniques, and they all seem independent from one another, until the big picture jumps at you and you realize it’s all connected? I experienced this kind of aha moment, that emerged from several (apparently) independent topics I wrote about, a guest […]

Design Patterns VS Design Principles: Factory method
▻https://www.fluentcpp.com/2022/06/05/design-patterns-vs-design-principles-factory-method

Let’s examine another design pattern in our “Design Patterns VS Design Principles” series, where we relate design patterns to design principles. Today, we focus on the Factory method design pattern. We’ll see the various forms the Factory method design pattern can take, the differences with the Abstract Factory method, and to which design principle the […]

How to Store an lvalue or an rvalue in the Same Object
▻https://www.fluentcpp.com/2022/05/16/how-to-store-an-lvalue-or-an-rvalue-in-the-same-object

There seems to be a problem coming up every so often C++ code: how can an object keep track of a value, given that this value can come from either an lvalue or an rvalue? In short, if we keep the value as a reference then we can’t bind to temporary objects. And if we […]

Copy-Paste Developments
▻https://www.fluentcpp.com/2022/04/26/copy-paste-developments

Amongst the many tasks a programmer does, one of them is to add a new feature in a location of the application where there are already many similar exising features. The temptation is then to warm up very specific muscles of our left hand: the pinky muscles that will press on the Ctrl key, the […]

Design Patterns VS Design Principles: Abstract Factory
▻https://www.fluentcpp.com/2022/04/06/design-patterns-vs-design-principles-abstract-factory

In the “Design Pattens VS Design Principles” series, we look at design patterns and relate them to design principles. In this episode, we examine the Abstract Factory pattern. Let’s see how Abstract Factory works and what it is useful for, then relate it to a design principle. We will also see a C++ technique to […]

How to Generate All the Combinations from Several Collections
▻https://www.fluentcpp.com/2022/03/18/how-to-generate-all-the-combinations-from-several-collections

Generating all the possible combinations from a set of collections and applying a function to each combination is a need that comes up often in programming. This is called a “Cartesian product”. For example, this kind of operation is necessary in the cartesian_product range adaptor, in the cartesian_product pipe, and in the killer feature of […]

The Interesting Evolution of std::equal_range
▻https://www.fluentcpp.com/2022/01/10/the-interesting-evolution-of-stdequal_range

The good old std::equal_range STL algorithm, which has been in the STL since C++98, has evolved along with the versions of C++. Starting from a poor interface and now a much better one, its story is an interesting example of how to improve the abstraction of an interface. (Good?) old C++98 equal_range The first version of […]

Which Programming Paradigm Gives the Most Expressive Code?
▻https://www.fluentcpp.com/2022/01/24/programming-paradigm-gives-expressive-code

Warning: this post gets into a very opinionated subject. You may agree with some points, you may disagree with others, it may trigger controversy, and you may be tempted to seize your keyboard to tell how you have a completely different view on programming. This is exactly what I want you to do. Rather than […]

Design Patterns VS Design Principles: Visitor
▻https://www.fluentcpp.com/2022/02/09/design-patterns-vs-design-principles-visitor

In today’s episode of the series “Design Pattens VS Design Principles”, we’re focusing on the last behavioural design pattern: Visitor, and see how it relates to the High Cohesion design principle. The GoF meets the GRASP If you’re just joining the series, The GoF meets the GRASP is about relating each of the GoF design […]

A Good Way to Handle Errors Is To Prevent Them from Happening in the First Place
▻https://www.fluentcpp.com/2022/02/25/a-good-way-to-handle-errors-is-to-prevent-them-from-happening-in-the-firs

Error handling is a tricky part of software programming. It’s tricky in several aspects: it’s difficult to get right, and it can make code less expressive. But it doesn’t always have to be that way. Sometimes asking the question “how can we prevent the error from happening in the first place?” can avoid the need […]

Code It Yourself: Generate All the Combinations from Several Collections
▻https://www.fluentcpp.com/2022/03/14/code-it-yourself-generate-all-the-combinations-from-several-collections

A Cartesian product consists in applying a function to all the possible combinations of the elements of several collections. For example, consider the three following collections: auto const inputs1 = std::vector<int> 1, 2, 3; auto const inputs2 = std::vector<std::string>"up", “down”; auto const inputs3 = std::vector<std::string>"blue", “red”; Then (2, up, blue) and (3, up, red) are two of […]

Design Patterns VS Design Principles: Template Method
▻https://www.fluentcpp.com/2021/11/17/design-patterns-vs-design-principles-template-method

In today’s episode of “Design Pattens VS Design Principles” series, we relate the Template Method design patterns to more general design principles. We’re showing how it relates to the Polymorphism design principle. The GoF Meets the GRASP If you’re just joining us in the series, here is what it’s about: we’re going over each of the […]

CPPP – An international C++ Conference with a hint of French accent
▻https://www.fluentcpp.com/2021/11/10/cppp-an-international-c-conference-with-a-hint-of-french-accent

Here is a quick update on a conference that I like. It has a very attractive program, a very reasonable ticket price, and is held in Paris. A nice reason to come around and visit the city and improve your C++ skills at the same time! The CPPP conference will hold its second edition fully […]

Strong Types for Safe Indexing in Collections – Part 2
▻https://www.fluentcpp.com/2021/11/04/strong-types-for-safe-indexing-in-collections-part-2

In the previous article on strong types, we set out to find how to use strong types for safe indexing in collections. More precisely, if we have two vectors with two indices to access them, how can we use strong types to make sure we use the right index for the right vector, and that […]

Strong Types for Safe Indexing in Collections – Part 1
▻https://www.fluentcpp.com/2021/10/31/strong-types-for-safe-indexing-in-collections-part-1

Strong types make code safer and more expressive by using the type system to identify individual objects. For example, to instantiate a class Rectangle with a certain width and height, we could write this: Rectangle myRectangle4, 5; But then it isn’t clear for a reader of the code which of the two parameters is the […]

Design Patterns VS Design Principles: Observer, State and Strategy
▻https://www.fluentcpp.com/2021/10/19/design-patterns-vs-design-principles-observer-state-and-strategy

In this series of articles on design patterns and design principles, we analyse how the 23 GoF design patterns relate to the 9 GRASP design principles. In a previous article, we classified the GRASP patterns like this (excluding “Managing complexity”): The study we perform in this series is helpful to understand better both the GoF […]

A Recap on User Defined Literals
▻https://www.fluentcpp.com/2021/10/08/a-recap-on-user-defined-literals

User defined literals were introduced in C++11, evolved in C++14 and C++17, and are a nice way to write more expressive code. The general idea behind user defined literals is that they allow to write a value and tack on a term describing what this value represents. For example: auto const quantity = 42_bottles_of_water; In […]

A Case Study for the Quickest Way to Find the Source of a Bug
▻https://www.fluentcpp.com/2021/09/27/a-case-study-for-the-quickest-way-to-find-the-source-of-a-bug

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 […]

3 Steps to Find the Source of a Bug Quickly
▻https://www.fluentcpp.com/2021/09/22/3-steps-to-find-the-source-of-a-bug-quickly

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 […]

Design Patterns VS Design Principles: Iterator, Mediator and Memento
▻https://www.fluentcpp.com/2021/09/12/design-patterns-vs-design-principles-iterator-mediator-and-memento

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 […]