ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

pinTrip Report: Italian C++ 2019

Overload Journal #152 - August 2019   Author: Hans Vredeveld
Milan held Italy’s largest C++ conference. Hans Vredeveld reports back.

On June 15th I was in Milan, Italy, to attend the Italian C++ conference [ItalianC++Conf19]. It was not the first time the Italian C++ community had held a conference, but it was the first time that I attended.

The day started with registration and the welcome message from Marco Arena, followed by the keynote. This time, the keynote speaker was Andrei Alexandrescu. With the usual Alexandrescu humour, he talked about sorting algorithms. He started by comparing a couple of standard algorithms, looking for the one with best performance. After he found a good one, he started tweaking it, performing all kinds of theoretical optimizations that, when measured, only resulted in worse performance. Finally he made some changes that should result in worse performance (at least theoretically), but that actually improved performance.

After the coffee break, the two tracks with sessions started. The first talk I attended was Rainer Grimm’s talk about concepts in C++20. He started with the motivation for concepts and how they were inspired by Haskell. Next he explained what concepts are and how they can be used. Having run into the problem that I needed something more generic than functions, but that templates left too much open and were too generic, I cannot wait and look forward to using concepts in my code.

The next talk I went to was Vector++17 by Davide Bianchi. The talk was not about std::vector, but about the vector that we all know from mathematics. Although it was not directly relevant for my day-to-day programming, I was intrigued and wanted to know more about it. Davide’s goal was a class Vector that behaves like the mathematical vector and that can be used with the operators on vectors that we all know from mathematics. He made good use of fold expressions and constexpr if to get clean code that supports SIMD like operations and also resulted in better error messages. In the end, I found the 30 minutes for this talk too short and would have preferred a 60 minute talk on the subject.

Next it was time for the lunch break and some more networking. During the lunch break there was a bonus talk that I missed, because I was caught up in a conversation.

After the lunch break, I went to Dmitry Kozhevnikov’s talk about the future of C++ with modules. If you have already delved into the subject of modules, most of what Dmitry talked about is already known to you. I knew that they were coming, but hadn’t spent much time on them yet. For me, this was a nice overview of what they will give us, solving a lot of the problems we have with include files and the current compilation model that we inherited from C and its preprocessor.

Then it was time for ‘Custom Clang Tooling’ with James Turner. He introduced us to Clazy [GitHub], a static analyser based on Clang [Clang-1]. In many ways it is similar to clang-tidy [Clang-2], but Clazy specializes in Qt and enforcing Qt best practices. It can automatically fix issues found, it has support for your own coding conventions, it automates code refactoring and it integrates into CI. It was a good presentation that gave me a decent overview of the tool. As always with this kind of tool, I have to play with it to fully understand its usefulness. I don’t know when that will happen.

Finally we had another break and the last talk of the day. Arne Mertz missed his connecting flight the day before and could not make it. That made the choice simple. Do I or don’t I go to Michele Caini’s talk ‘ECS back and forth’? I did. ECS stands for Entity Component System [Wikipedia] and it is an architectural pattern. It favours composition over inheritance, sacrificing encapsulation. Unfortunately, my attention started wavering, in part because we already had a full day of talks and in part because I had no idea how I could use it in my daily programming practices. But, if I want to play with it, there is an open source library that implements the pattern: EnTT. [Caini]

Marco Arena and Alessandro Vergani concluded the day with the closing message. During the day attendees were encouraged to tweet about the conference, and in the closing message they handed out the prizes for the best tweets. They also invited the other member of the organizing committee and the speakers to come forward. The room thanked both groups with a heart-warming applause.

All in all, it was an excellent day and I look forward to go to Milan again next year.

References

[Caini] Michele Caini (skypjack) EnTT library on GitHub: https://github.com/skypjack/entt

[Clang-1] Clang: http://clang.llvm.org/

[Clang-2] Clang-tidy: https://clang.llvm.org/extra/clang-tidy/

[GitHub] Clazy: https://github.com/KDE/clazy (A mirror of the KDE project.)

[ItalianC++Conf19] Italian C++ Conference 2019: https://www.italiancpp.org/event/itcppcon19/

[Wikipedia] Entity Component System: https://en.wikipedia.org/wiki/Entity_component_system

Hans Vredeveld started working in the software industry 20+ years ago as a system administrator. Via application administration he soon moved into software development, where he was bitten by the C++ virus. Not wanting to be cured, he is always searching for the next cool C++ thing.

Overload Journal #152 - August 2019