A code::dive conference is an annual event taking place in Wroclaw, Poland. It’s probably one of the most popular conferences for C++ lovers in the region. It’s sponsored by Nokia and surprisingly, it’s still free! So if you haven’t participated in it yet, you definitely should think about this next year. There are even people as determined as Lukas (see his post from the last year here) who drove 300 km to join the conference! It’s also a nice offer to see a beautiful city of Wroclaw if you haven’t visited it yet.
This year there was a three person team from Milo at the conference - me, Mariusz and Michał (he’s almost as determined as Lukas, because he lives in Cracow which is about 275 km from Wroclaw). Each of the two days had 5 sessions with 4 simultaneous lectures. As Mariusz noted: it’s not possible to attend all of them unless you want to clone yourself and then merge back together, but it may result in conflicts ;) However, each of us had slightly different plans for the agenda so I’ll try to present you a diverse summary of our experiences.
The very first lecture of the conference for us was John Lakos’s “Value semantics: It ain't about the syntax!”. The talk tried to answer the question: what is a value? Though the question seems to be simple, the answer is not. John Lakos went into a more philosophical analysis what we mean by value and what it means that something is identical. He also presented a big and complicated graph of different abstraction types (such as values, mechanism or interface). The talk was demanding but it was definitely worth seeing. There was also a 66.66% chance of a headache (2 out of 3 of us were overloaded with the data ;) ).
I said previously that it’s a conference for C++ lovers but it’s obviously not only about C++. For Michał the rest of the day was a journey with concurrency and coroutines in various languages.
There was Łukasz Langa’s “Thinking in coroutines” which was an introduction to Python coroutines. It showed that using async/await keywords on top of regular function syntax makes coroutines in Python easy to work with.
Another lecture was Alex Crichton’s “Concurrency in Rust” which showed that Rust safety guarantees enable developers to write multithreading code without fear. He also presented a new Tokio library that uses futures for implementing concurrency and talked about plans for adding coroutines to the language. The latter will allow us to use high-level syntax without sacrificing efficiency.
If you are still not satisfied with a languages variety, don’t worry as there was also William Kennedy’s “Go: Concurrency Design”, where he presented a different approach to the topic. Mr. Kennedy showed that Goroutines when used together with channels acts both as coroutines and threads. It seems an efficient and ergonomic solution for server-side software.
As for me and Mariusz, we decided to stick with C++ for some time. To be specific, two lectures. The first of those was Mark Isaacson’s “Exploring C++17 and Beyond” where… well he presented C++17 and beyond ;) A few of concepts were explained in more details, such as a dot operator (interesting stuff, so google it if you haven’t heard about this yet), a string view and using regular “if” branching in template specialization.
Then we had to face the truth that even big conference rooms can be overcrowded and we ended up at Miłosz Warzecha’s “An inspiring introduction to template metaprogramming”. The talk was actually quite nice and well done but (as the title suggested) it was rather an introduction with basic knowledge.
At the end of the day we decided to participate in a more technology related lecture which was Rafał Legiędź’s “A thorough look into spatial mapping with HoloLens”. Earlier during the day I had (like all the conference participants who wanted to) an opportunity to test the device and it was quite an interesting experience. The lecture itself was entertaining, however, it lacked technical details (especially as for a thorough look), so we were a little bit disappointed.
(It’s me playing with my imaginary friends)
The second day was also starting with John Lakos’, this time: “Local (<<arena>>) memory allocator”. The talk was about his extensive research on C++ custom allocators. The results showed that using local allocators can greatly improve performance of an application (you can start using those with a new C++17 standard). The content of the lecture was indeed interesting, however, Mr. Lakos’ attitude made me feel like I was back at school again with a nervous teacher everyone was afraid of ;)
Mariusz was very satisfied with his first lecture and he easily convinced us to take another Douglas Crockford’s lecture with a vague title: “Numbers”. The lecture was indeed very interesting. The lecturer focused on programing mistakes related to numbers (overflow, floating point inaccuracy) and presented his solution: a new number standard DEC64 that should be sufficient in most usages.
Later that day Michał continued his journey with different programing languages and found William Kennedy’s "Go: Optimizing For Correctness" a valuable lecture. Impressive built-in tools for debugging and profiling were shown there and the presenter taught us how to use them for fast identification of bugs and performance bottlenecks in our applications.
As for C++, another worth remembering lecture was Mateusz Pusz’s “Pointless Pointers – How to make our interfaces efficient?”. He showed that in modern C++, there is mostly no place for raw pointers in interfaces as they're creating ambiguity. The content of a lecture was nothing too surprising (I hope!), but Mateusz stated that in his experience such changes reduced time needed for maintenance dramatically and we too often do not pay enough attention to it. Highlighly recommended if you like raw pointers “too much” :)
At the lunch break that day Michał finally intrigued us with Rust and we all decided to take Alex Crichton’s “Intro to Rust”. Those not familiar with the language (like I was) could learn how it merges C++'s zero-cost abstraction with Java's memory safety. Alex described concepts of mutability and aliasing in multi-threaded context and how Rust deals with it. The Firefox browser already uses Rust in some parts along with C++ code and there are plans to incrementally change C++ to Rust in many code parts. I must admit that I definitely would like to learn more!
The code::dive conference is a nice event on the software development landscape. It is mostly dedicated to C++ developers but there are also many lectures for people who want to broaden their perspective on general software development and new technology advancements. So - see you next year?
Thanks Mariusz and Michał for nice time at the conference and for help with the article.