Jonathan Boccara's blog

All posts in "Expressive code"

The Interface Principle in C++

Published June 20, 2017 - 7 Comments

The Interface Principle in C++ encompasses a specific combination of features and ways of considering what an interface is, that allows to write expressive C++ code that preserves encapsulation. It has been around for a while, is still currently used, and may be enriched in the future versions of the language. So it’s worth being aware of. Note that […]

The real difference between struct and class

Published June 13, 2017 - 4 Comments

“Should I use a struct or a class?” Such is the question many C++ programmers ask themselves, or ask around to more experienced co-workers, when designing their code. There is sometimes a cloud of misconception about what the difference between struct and class technically is, particularly amongst the youngest developers. And once we get to understand the technical difference, […]

Using toString on Custom Types in C++

Published June 6, 2017 - 10 Comments

“Give me a string representation of this object.” This is a fairly ubiquitous sentence in programming, that many languages express in one brief statement: Java has .toString(), Python has str and Haskell has show, to cite just a few. My goal here is to propose a concise way to also express this in C++. Note: after I wrote […]

Expressive C++ Template Metaprogramming

Published June 2, 2017 - 3 Comments
Expressive template metaprogramming tmp

There is a part of C++ developers that appreciate template metaprogramming. And there are all the other C++ developers. While I consider myself falling rather in the camp of the aficionados, I’ve met a lot more people that don’t have a strong interest for it, or that even find it downright disgusting, than TMP enthusiasts. Which camp do you […]

Strong types: inheriting the underlying type’s functionalities

Published May 23, 2017 - 4 Comments

This post is part of the series on strong types: Strongly typed constructors Strong types for strong interfaces Passing strong types by reference Strong lambdas: strong typing over generic types Good news: strong types are (mostly) free in C++ Inheriting functionalities from the underlying type Making strong types hashable Converting strong types to one another Until recently, […]

Good news: strong types are (mostly) free in C++

Published May 5, 2017 - 3 Comments

Strong types are a simple and efficient tool for improving code expressiveness, by letting you express your intentions better to both the compiler and to your fellow human companions. This post is part of the series about strong types, that keeps growing because it is such a rich topic: Strongly typed constructors Strong types for strong […]

To comment or not to comment? // that is the question

Published May 2, 2017 - 4 Comments

Comments are one of these places where religion meets technology. On one side there are the firm believers that good code is commented code, and on the other side stand the devout to the scarcest commenting chapel. We can’t discuss expressive code and not talk about comments at some point. Is code expressiveness an alternative to comments, or are the […]

Restricting an interface in C++

Published April 7, 2017 - 6 Comments

My colleague and friend Jonathan came up to me the other day with this request: “Jonathan”, he said – you won’t have too many names to remember to follow this story – “Jonathan, how would you go about restricting the methods of an interface? We’ve got a class which we use in a broader context, […]

How typed C++ is, and why it matters

Published March 31, 2017 - 0 Comments

For the third time I attended the meetup of Software Craftmanship in Paris. And like the first time and the second one, it was superb experience again. This meetup lets the participants collectively choose the topics to be discussed. There I proposed to confront, as a group, the various languages that the people in the room knew (the […]