www.fluentcpp.com Open in urlscan Pro
50.87.249.231  Public Scan

Form analysis
1 forms found in the DOM

GET https://www.fluentcpp.com/

<form action="https://www.fluentcpp.com/" method="get" class="msh" style="display: none;">
  <div>
    <input type="text" placeholder="Search..." class="search-field" name="s">
    <button type="submit" class="search-button"></button>
    <div class="clear"></div>
  </div>
</form>

Text Content

ABOUT JONATHAN BOCCARA

Hello, my name is Jonathan Boccara, I'm your host on Fluent C++. I have been a
developer for 10 years. My focus is on how to write expressive code. I wrote the
book The Legacy Code Programmer's Toolbox. I'm happy to take your feedback,
don't hesitate to drop a comment on a post, follow me or get in touch directly !

 * 
 * 

Read more

Jonathan Boccara's blog


 * Posts
 * The World Map of C++ STL Algorithms
 * Daily C++
 * Store
 * About



Recent Posts

 * Copy-Paste Developments
 * Design Patterns VS Design Principles: Abstract Factory
 * How to Generate All the Combinations from Several Collections
 * Code It Yourself: Generate All the Combinations from Several Collections
 * A Good Way to Handle Errors Is To Prevent Them from Happening in the First
   Place
 * Design Patterns VS Design Principles: Visitor






COPY-PASTE DEVELOPMENTS

Published April 26, 2022 - 0 Comments

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

Continue reading



DESIGN PATTERNS VS DESIGN PRINCIPLES: ABSTRACT FACTORY

Published April 6, 2022 - 0 Comments

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

Continue reading



HOW TO GENERATE ALL THE COMBINATIONS FROM SEVERAL COLLECTIONS

Published March 18, 2022 - 0 Comments

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

Continue reading



CODE IT YOURSELF: GENERATE ALL THE COMBINATIONS FROM SEVERAL COLLECTIONS

Published March 14, 2022 - 0 Comments

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

Continue reading



A GOOD WAY TO HANDLE ERRORS IS TO PREVENT THEM FROM HAPPENING IN THE FIRST PLACE

Published February 25, 2022 - 0 Comments

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

Continue reading



DESIGN PATTERNS VS DESIGN PRINCIPLES: VISITOR

Published February 9, 2022 - 0 Comments

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

Continue reading



WHICH PROGRAMMING PARADIGM GIVES THE MOST EXPRESSIVE CODE?

Published January 24, 2022 - 0 Comments

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

Continue reading



THE INTERESTING EVOLUTION OF STD::EQUAL_RANGE

Published January 10, 2022 - 0 Comments

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

Continue reading



A SIMPLE HABIT TO AVOID COMPLEX NAMES AND TYPOS IN CODE

Published December 27, 2021 - 0 Comments

Don’t you find it a little unsettling when you encounter a typo in code?
std::unordered_map<int, Value> MyClass::getInedxedValues() const { // … } And
the code looks even more careless when that typo is repeated several times
across the codebase, in code that depends on the butchered symbol: auto const
table1 = x.getInedxedValues(); auto const table2 […]

Continue reading



THE EVOLUTIONS OF LAMBDAS IN C++14, C++17 AND C++20

Published December 13, 2021 - 0 Comments

Lambdas are one of the most popular features of Modern C++. Since their
introduction in C++11, they’ve become ubiquitous in C++ code. But since their
appearance in C++11, they have evolved and gained significant features. Some of
those features help write more expressive code, and since using lambdas is so
common now, it is worth […]

Continue reading


1 2 3 … 44 Next »

 * 

Copyright text 2018 by Fluent C++.   -  Designed by Thrive Themes | Powered by
WordPress