Deciding which conferences to attend is difficult, and we can’t go to them all. Svitlana Lubenska, Hans Vredeveld and Benedikt Mandelkow give us a flavour of what we may have missed.
From Svitlana Lubenska
It was my 4th Meeting C++ [Meeting C++] conference and I liked it the most. In this report, I will try to explain why and encourage you to watch the videos once they are available and, of course, to go to this conference next year!
As always, the conference takes place in Berlin, in the beautiful Vienna House Andels Hotel, and lasts 3 days.
During these days, I literally did not leave the hotel, because every day was filled with so many interesting things!
The first day had so many interesting speakers so that it was really hard for me to decide where to go. I will list the talks I finally attended, but I am going to watch the recordings [ MeetingC++ ] of others too.
- The opening keynote by Howard Hinnant about <chrono> [ chrono ] was just great! As I have recently worked with this library, I have now learned better ways of using it and tomorrow am going to refactor my code ☺. Howard not only listed the existing and new (coming in C++20) features but also explained the philosophy of design, making it clear why they implemented certain features. He also gave cool advice to people who want to design their own library (although not necessarily: I think I can apply them even if I write just one class ☺). Howard kindly shared his slides [ Hinnant19 ].
- The first talk was the one I was really looking forward to attending – ‘10 Techniques to Understand Existing Code’ by Jonathan Boccara. Let me first talk about the speaker. I first heard his name while I was on maternity leave. Although it was year when I had a break from my profession so I could focus on my family, I did want to follow what was happening in the C++ world, so I was listening to cppcast [ CppCast ] where I heard an interview with Jonathan which was super interesting. I started to read his blog fluentcpp.com and also watched videos on youtube. When I got back to work, I continued following his posts, used a lot of his tips while coding and still think his explanation of tag dispatching technique is the best ☺. I was also super happy when Jonathan published his book and so, of course, I could not miss his talk at conference!
- Daniela Engert talked about the famous modules: once they are there, go to see how to use them ☺.
- I went to listen to Hana Dusíková with her ‘Compile Time Regular Expressions with Deterministic Finite Automaton’ talk because I had heard so much about her and missed the talk about Hana’s library last year. I am a big fan of regular expressions (in Perl mostly, as I am in love with scripting languages), so… what can I say, I was really impressed! You will also be impressed if you check the slides [ Dusíková19 ].
- I could not miss the talk ‘C++20: The small things’ by Timur Doumler because I just love the examples he usually gives. I was not disappointed ☺.
The talk was interesting and helpful; I especially liked the tip about using call stacks ☺.
As always, the first day was finished with the Quiz! It was the first time I participated; of course, failing to solve a lot of tasks… but it was SO MUCH FUN! Please always try it out when you at a conference; the best part is that you are with people you have never worked with but after the quiz it is like you have known them for ages ☺. Last year, I was so inspired that I created a similar event for my colleagues, not as evil but still… 15 minutes that felt like the best team building ever ☺.
The second day was even better! Because:
- It started with an inspiring keynote by Frances Buontempo. You have to watch it! So many questions to think about. I recently read a book by Andreas Weigend [ Weigend17 ] (not exactly about AI) which raised similar ideas in my head, so this talk was really important to me.
- Arne Mertz talked about code smells. I liked that the talk was built on real code examples where he asked the auditorium to find the smells. I think you should show this talk to junior programmers straight away when they join your team. You know, just in case ☺.
- Pavel Novikov talked about asynchronous C++ programming, on a pretty advanced level. I particularly liked his examples on tasks (and puppies ☺).
Phil Nash is still obsessed with error handling in C++. I recommend watching his previous talk first [
]. Basically, this time he was considering different proposals related to this and showing how the code would look. I personally am quite happy with
system_erroreven with the problems Phil listed, but it was interesting to see what can be improved and why.
- Guy Davidson gave his talk ‘Teaching Analytic Geometry to C++’, as always with so much positive energy. Now with a geometry library, I am sure C++ will shine ☺.
The last-but-not-least part was Lightning Talks. There were so many that I cannot list them all but just mention my favourite – by Tina Ulbrich, ‘The Life-Changing Magic of Tidying Up’ [ Ulbrich19 ]. The idea was so simple and brilliant so that I could not help laughing. She applied ideas from a home-cleaning philosophy to code writing. I read everything written by Marie Kondo and I try to follow her advice at home, but it would never have occurred to me to use these ideas in code. I think my mindset is different now, and this simple move will bring even more joy to my work ☺.
The third day opened with a talk by Jon Kalb where he talked about ‘Modern Template Techniques’. I found policy classes very interesting, not being sure if I had heard of this technique before. So, I learned something again ☺.
- Fabio Fracassi talked about C++20 new features. The talk intersected a bit with Timur’s talk but, in this case, the more examples the better. I liked the talk a lot!
- The ‘Testing Legacy Code – Fuzzing for Better Input Data’ talk by Tina Ulbrich and Niel Waldren was sooo good! I am going to check libFuzzer as soon as I get to my computer!
- There were also secret Lightning Talks, my favourite was the one done by Peter Sommerlad just because I loved the idea of having ‘The Rule of DesDeMovA’.
- Jens talked about burnout, which is supposed to be a sad topic… but those beautiful photos… I don’t know what to say, you should see them ☺.
- It was time for the closing keynote by Walter E. Brown who actually started the talk in German ☺. He made us laugh but also think about the cost of the mistakes programmers sometimes make. For me, it was also important topic as I write medical software, so…
Yes, these three days were awesome! I still have a lot to catch up (talks I did not attend), but I have already learned so much from people who are so kind to share their knowledge and thoughts.
See you next year!
From Hans Vredeveld
We have a great C++ community that gives a lot, at least to me. Some time ago, I was thinking about how I could give back something. I concluded that writing for Overload would be a good way to start. But, what to write about? An easy answer to this question is, write trip reports for events I went to. So I wrote a trip report for Italian C++ earlier this year [ Vredeveld19 ]. Now it’s time for my second trip report. This time about Meeting Embedded and Meeting C++ , the second time I have visited these conferences. It’s also the second time Meeting Embedded has been held.
Meeting Embedded [ MeetingEmbedded ] is a one-day single-track conference that is held the day before Meeting C++ . This year it was on November 13th. The day started with a short welcome by Jens Weller, followed by a one-hour keynote, after which nine 30-minute talks followed. After the keynote and after each third talk, there was a longer break in which we could get some refreshments or have lunch. Between the other talks, there was a 5-minute break to allow for one speaker to leave the stage and the next to set up.
The keynote was delivered by Peter Sommerlad. In his talk he argued that we should stop using C and start using modern C++ for embedded development. Part of the problem is that vendors give examples predominately in C and that these examples often constitute bad code. The development cycle usually consists of quickly writing your code, so that you get to the real thing: debugging. Peter then argued that a lot of the problems found during debugging (or worse: only found in production) can be circumvented by making proper use of modern C++. C++ gives us a type system with deterministic object lifetime, compile time programming, and a standard library, amongst others, that make many of the problems with C go away like snow before the sun. Next, he went into what it means to properly make use of modern C++, how many of the problems that in C can be only found at runtime can be found at compile time in C++. If you want to convince your colleagues to start using C++ instead of C for embedded, watch the keynote on YouTube for some inspiration when it becomes available.
Many of the talks that followed were also on the subject of writing better code. Maciek Gajdzica looked at different design and development methods, also touching on the subject of better languages than C for embedded development. In particular, he went into the C4 model for visualizing software architecture [
]. Paul Targosz taught us how we could make our code more robust by using
, by putting configuration in files instead of littering it throughout our code, and by using a policy-based class design. Nikola Jelić told about how he created a library for physical units modelled after the chrono library and how this improved his code. Frank Mertens went into different ways of doing heap management and the impact they have on fragmentation. Pawel Wisniewski compared different ways of implementing call backs and listed the pros and cons of each way. Daniel Penning explained that generic programming allows us to reuse more code. In particular, he explained that a lot is already available through the algorithms in the standard library and that it will even get better with concepts in C++20. A lot of the things that these speakers talked about were things I already knew, but forgot about. Sometimes they also presented a fresh point of view that I hadn’t thought of before.
In my professional life I have to deal with people that think that the only viable language for low level programming is C. Although I’m not a low level developer, I try to convince them that C++ is a better alternative. Now I learned that there is even another alternative: Rust. Jonathan Pallant went into how he used Rust on Nordic Semiconductor’s nRF9160 [ Nordic ] and made the system more secure and use less power. James Munns presented a Rust library for serialization and deserialization: Serde [ Serde ], and how Serde makes serialization and deserialization easy.
A real gem for me was Diego Rodriguez-Losada and Brennan Ashton’s talk about Yocto [ Yocto ]. Yocto is a system for creating your own embedded Linux distribution. Diego and Brennan first gave an introduction of what Yocto is. Then they went into using Conan [ Conan ] with Yocto, and into uploading images to your embedded device. One of the things I run into regularly is that building a new Linux image with Yocto takes several hours. Using Conan makes it possible to build the applications beforehand and store them in a location from where they can be retrieved during integration. This will reduce the build time significantly and make it feasible to create an image multiple times a day.
Meeting C++ Day 1
The first day of Meeting C++ [
], November 14th, started with the welcome message by Jens Weller, soon to be followed by Howard Hinnant’s keynote. Howard described the new things that <chrono> [
] gets with C++20, calendars and formatting. An important part of the keynote was explaining why <chrono> was designed as it is. Of course, that was to be expected when the keynote’s title is ‘Design Rationale for <chrono>’. Some old and many new types were reviewed;
and different kinds of clocks (and I still missed some). A recurring theme in the presentation was what operations and implicit conversions are allowed. E.g. converting from
is implicit as no information is lost, while the reverse conversion is only possible with an explicit
as precision is lost (4000 seconds is 1 hour, losing 400 seconds in the process). Also, many of the usual operations on integral and floating point values don’t make sense for types in <chrono>. For example, subtracting two
s results in a duration, but adding two
s results in a compile error as it doesn’t make sense and isn’t implemented. I could go on describing what Howard said. Instead I advise you to watch the presentation on YouTube as soon as it becomes available. Not only will you learn a lot about <chrono>, but also about designing a library in general.
After the keynote, we had a lunch break with plenty of excellent food for everybody. In the afternoon, there were four sessions of one-hour talks, with a 30-minute coffee break between the second and third session and 15-minute breaks between the others. I went to Jonathan Boccara’s ‘10 Techniques to Understand Existing Code’, Dawid Zalewski’s ‘Lambdas – the old, the new and the tricky’, Bryce Adelstein Lelbach’s ‘The C++20 Synchronization Library’ and Ivan Cukic’s ‘Compile-time type transformation’. Four interesting talks worth going to.
The day ended with the evening program that consisted of the pizza-pasta buffet, the Conan C++ quiz and socializing. The Conan C++ quiz, very well presented by Diego, is a quiz where the participants work together in groups of six, and they have to guess/deduce what the output is of small C++ programs. The code presented varies between crazy and psychopathic, and stands for a lot of “what the...” and fun. I only hope to never see such code in production. I would fire the person that wrote that (or find myself another place to work if that’s impossible).
Meeting C++ Day 2
The day started with Frances Buontempo’s keynote ‘Can AI replace programmers?’ Frances explained what AI is, went back and forth between yes and no in answering the question. She concluded that AI can replace programmers using genetic programming, but that it takes an awful lot of time. Finally, she also noted the AI effect: as soon as AI solves a problem, the problem is no longer part of AI.
In the afternoon, there were again four sessions of one-hour talks. I went to John Lakos’s ‘Value Propositon: Allocator-Aware Software’, Jonathan Müller’s ‘Using C++20’s Three-way Comparison <=>’, Phil Nash’s ‘The Dawn of a New Error’ and Arvid Gerstmann’s ‘Multithreading 101: Concurrency Primitives From Scratch’. In his talk, John went from the past to the present to the possible future. He described how memory management with the C++11 allocators is difficult to use, how C++17’s polymorphic allocators and associated types make this much easier and how it could even be made more easy with the BB20V library that is currently under development at Bloomberg. Jonathan discussed that when you overload one of the operators
for a custom type, you should also overload the other, and that when you overload one of the operators
for a custom type, you should overload all of them. Next, he explained what C++20’s
is and that it is enough to overload this operator and
. The other operators are implicitly implemented. Phil discussed new types, and a related extension of the language, for error handling that hopefully will make it into C++23. The main motivation for these types is to have better error handling than the C-style return values, including in situations where exceptions cannot be used. Arvid started with the low-level building blocks of multithreading. He described what a spinlock is and how it can be written. Next he taught us what a futex is. He implemented it first for Linux (with the system call ‘futex’) and for Windows. Then he went on to implement it with code that would work on any platform that has modern C++. For this implementation he used
s. To the end of his talk he took just a few minutes to implement a condition variable using a futex (that was implemented with a condition variable; yes, he was aware of that).
In the evening there was food again in the form of a pizza-pasta buffet, and there was time for socializing. And, most importantly, there were the lightning talks. As always, it is fun to see what people come up with to talk about for only five minutes. With 19 lightning talks, the second half of the evening was well packed.
Meeting C++ Day 3
On the third day, the schedule was reversed. First we had the sessions with the talks and then the keynote. This time there were only three sessions of one-hour talks, not four. In Jon Kalb’s ‘Modern Template Techniques’, I learned some things about type traits, tag dispatch, policy classes, perfect forwarding, and that infinity == 12. Deniz Bahadir’s ‘Oh No! More Modern Cmake’ left off where his 2018 talk ‘More Modern CMake –Working with CMake 3.12 and later’ ended. He clearly described the difference between
. He explained what object libraries are and how to use them, and he gave several recommendations for using Cmake. The last regular talk I went to was Bart Verhagen’s ‘Designing costless abstractions’. He compared a few
-types from modern C++ to their old (C-style) counterparts (e.g.
to raw pointers) and how these C++ types are an abstraction without any cost. I had expected that he would go a bit more into how to design those abstractions, or why they were designed as they are. Unfortunately for me that meant that this was the least interesting talk of the conference.
Instead of the fourth session, Jens gave an update about Meeting C++ , both the platform and the conference. He also gave some indication when the videos will be uploaded to YouTube [ MeetingC++ ]. Expect the lightning talks first, then the keynotes and, after Christmas and New Year, the regular talks. Then he went on to something for which there was time planned, but that was not on the schedule: the secret lightning talks. They will be on YouTube too, so you may wonder what is so secret about them? (Answer: that you don’t know about them when you read the schedule.)
Finally it was time for the closing keynote by Walter E. Brown. I had seen a couple of Walter’s talks on YouTube and one live at C++ on Sea , so I know that he is a good speaker and I had high expectations for his keynote. He exceeded my expectations by a large margin. He managed to put a lot of humour (I had to wipe away tears on more than one occasion) in his presentation, while keeping it serious at the same time. Watch it when Jens uploads it to YouTube!
From Benedikt Mandelkow
I’m Benedikt Mandelkow, a CS student from Germany.
During my time as a Bachelor student, I had the opportunity of meeting Jonathan Müller [ Müller ], which in turn meant that I got interested in cpp.
In a casual conversation with him, the idea came up that I could apply for a student ticket for meetingcpp and, as you might have guessed, that is exactly what happened. I had been to Berlin before and really liked the city, so after I had received the acknowledgment that I was one of the randomly selected students, it was an easy call for me to book my ticket.
On the first evening before the conference, we went to grab some food and even though my trains were very unreliable, I managed to arrive just in time at a restaurant. Coincidentally, I had already spent my time on the train with a group of developers who were also heading to Berlin for different reasons.
My first conversation was with another student who had attended multiple cpp conferences already, and who briefed me to focus on the conversation in between the talks instead of on just the talks themselves, which proved to be really good advice.
After a few minutes, my next surprise was that I was sitting not far from Arvid Gerstmann, someone I had so far only known from twitter [ Gerstmann ]. We exchanged a few words regarding an experimental programming language [ AEXPL ] he is working on and we continued to have very good conversations over the course of the event.
Seeing many people that I had so far only known from videos or blog posts was really nice, but the important thing for me was that the atmosphere I encountered was not elitist but everyone I tried to talk to was very approachable.
I had hoped for this to be the case, but I think without actually attending a conference, it’s hard to believe as it definitely seemed a bit unreal to me as well. Surely there are still ways to improve on this. When I tell people about my experience, they are really surprised, which indicates that there are many people who have reasons that keep them away from possibly joining the community.
The main focus of the conference is, of course, not the well-known people but the vast majority of attendees who work for a wide range of companies. The good news was that it was easy to talk to them as well because when I was standing next to some people I had never seen before, it never took long for one of them to ask me a question or for me to take an opportunity and make a remark. After that, conversations were really easy.
The focus was never on recruitment or testing other people’s knowledge but much more sharing opinions, understanding and stories.
The excellent food surely also contributed to a relaxed atmosphere because this allowed everyone to just focus on the event instead of competing for the last desert.
I will briefly describe some talks I watched but won’t detail everything because the talks will be all available online and it’s more about the personal interactions than the talks themselves.
The first talk was from Howard Hinnant about his work on chrono. While some people I talked to argued that it was unusual in the sense that it was rather specific and not a general design talk, I found it to be helpful as it actually provided direct benefits that one can use in practice to write better code in specific cases.
One benefit of attending talks in person vs watching the videos was that I was more focused, which allowed me to follow the talk about ‘The C++20 Synchronisation Library’ from Bryce Lelbach and the Spaceship operator from Jonathan Müller much more completely, whereas on my own I get distracted more quickly sometimes. (I knew both talks from previous recordings.)
I made the very conscious decision to sit through an hour-long explanation of std::midpoint, which turned out to be a really good one because I liked the problem statement and the approach and care which was taken to address it.
Additionally, I was really interested in seeing the person (Marshall Clow [ Clow ]) who programs the standard library implementation I use most of the time.
The most important talk for me was ‘Modern Template Techniques’, which was in a perfect spot in the morning where I was still able to actually digest the content. I also had talked to Jon Kalb the evening before, which really made a difference while experiencing the talk, much more personal.
By accident I now know about SFINAE, which was something I had previously explicitly excluded from ever learning because it just seemed way too complicated to spend time on.
But then Jon Kalb tricked me because he explained it on one slide without mentioning the name and when I then realized what I had just learned I was both embarrassed because I had learned something I never wanted to but also relieved because it was actually not as bad as I had thought (famous last words).
The final talk from Walter Brown was very entertaining and had many interesting arguments and the sentiment that struck with me was that we are a profession and should strive to produce more reliable software and take responsibility for our work.
On the other hand, without some messiness and with too much perfectionism, we would not have the world wide web as it is because things would move that much more slowly but I think it is still very valuable to take a strong stance like Walter Brown at times because it’s just, as always, a trade-off and thus discussion about it is valuable.
Finally, I want to thank meetingcpp for offering student tickets, which made it possible for me to attend, all the attendees for the atmosphere and Jonathan Müller for being very patient with me at all times [ Brown18 ].
[AEXPL] Arvid's EXperimental Programming Language: https://github.com/aexpl/aexpl
[Brown18] Walter E. Brown ‘Thank You (I’m sorry that it’s taken me so long to say it)’ presented at C++ Conference 2018, available at: https://www.youtube.com/watch?v=L5daPjK00bo
[C4] ‘The C4 model for visualising software architecture’: https://c4model.com/
[chrono] The chrono library: https://en.cppreference.com/w/cpp/chrono
[Clow] Marshall Clow: https://cppalliance.org/people/marshall.html
[Conan] Conan: https://conan.io/
[CppCast] A podcast for C++ developers: https://cppcast.com/
[Dusíková19] Hana Dusíková (2019) ‘Compile Time Regular Expressions With Deterministic Finite Automaton’, presented at Meeting C++ 2019 , available at: https://www.compile-time.re/meeting-cpp-2019/slides/#/
[Gerstmann] Arvid Gerstmann, twitter conversations: https://twitter.com/ArvidGerstmann/status/1196002167167029249
[Hinnant19] Howard Hinnant (2019) ‘Design Rationale for the <chrono> Library’, presented at Meeting C++ 2019 , available at: https://meetingcpp.com/mcpp/slides/2019/Hinnant.pdf
[MeetingC++] Meeting C++ website: https://meetingcpp.com/YouTube channel: https://www.youtube.com/user/MeetingCPP/videos
[MeetingEmbedded] Meeting Embedded 2019 website: https://meetingembedded.com/2019/
[Müller] Jonathan Müller (blog): https://www.jonathanmueller.dev/
[Nash18] Phil Nash (2018) ‘Option(al) Is Not a Failure’, presented at C++ Now 2018 , available at: https://www.youtube.com/watch?v=OsRty0KNDZ0
[Nordic] Nordic Semiconductors: nRF9160, available at: https://www.nordicsemi.com/Products/Low-power-cellular-IoT/nRF9160
[Serde] Serde framework: https://serde.rs/
[Ulbrich19] Tina Ulbrich ‘The Life-Changing Magic of Tidying Up’, presented at Meeting C++ 2019, available at: https://meetingcpp.com/mcpp/slides/2019/The%20Life-Changing%20Magic%20of%20Tidying%20Up.pdf
[Vredeveld19] Hans Vredeveld (2019) ‘Trip Report: Italian C++ 2019’ in Overload 152, August 2019, available at: https://accu.org/index.php/journals/2681
[Weigend17] Andreas Weigend (2017) Data for the People: How to Make Our Post-Privacy Economy Work for You , Basic Books, ISBN-13: 978-0465044696
[Yocto] Yocto project: https://www.yoctoproject.org/
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 thing C++.