Top 10 C ++ Russia reports and open access conference playlist
This hubpost brings together the top ten reports from speakers such as Nicolai Josuttis, Timur Doumler, Andrey Davydov and many others.
C ++ 17/20/23, concepts, immutable data structures, concurrency, parallelism, metaprogramming - all these are the topics of the C ++ Russia 2019 conference held this spring in Moscow. More than six hundred participants, well-known international speakers, in-depth reports. Please note - the reports are such that they will be outdated very soon, and you can apply the knowledge gained even now.
The format is as follows:
- Mandatory YouTube video
- A detailed description of the report in Russian (with slides, if any)
- Presenter Short Biography
Feel free to write comments! By the way, in the playlist published under the cut, there is not only the top 10. And we turned off ads on YouTube, so that no one will interfere.
All reports go from “junior” to “senior” in rating, but the differences between the places of the top ten are minimal and strongly depend on the assessment methodology. By slightly changing the methodology, you can greatly change places. So watch it all!
The full conference playlist is here .
10. The hitchhiker's guide to faster builds
Viktor Kirilov
C ++ is known for its performance, speed, lack of a standard build system and package manager, and the complexity and duration of compilation. The impossibility of rapid iterative development is one of the greatest killers of developer productivity. This report is intended for everyone who wants to improve the last three points: first, some ideas why compilation and linking take so much time, then a list of techniques and tools to solve the problem, for example:
- tuning and infrastructure - hardware, assembly systems, caching, distributed assemblies, bottleneck diagnostics, code hygiene;
- techniques - unity builds, precompiled headers, static vs shared;
- changes in the sources - PIMPL idiom, more correct use of templates, annotations;
- modules - what is it when they appear in C ++, which will turn out to be more unnecessary because of this.
About Speaker
Six years of professional experience in C ++ in the gaming and VFX industries. Now Victor is developing open source and from time to time - the usual contract work. One of the last interesting tasks is the implementation of hot-swapping code in the Nim runtime. He is also the author of doctest, "the fastest and most powerful single-header test library for C ++." He is interested in developing games and game engines, high-performance code, cryptocurrencies, optimizing the workflow and integrating good development practices, such as modern static analysis and instrumentation tools. Victor lives in Sofia (Bulgaria), and programming is both his profession and hobby. Have your own website: http://onqtam.com/
9. C ++ Templates and Databases
Sergey Fedorov
When we work with databases, we often get raw buffers, while we want to receive data in the form of C ++ structures, classes and containers.
A story about the design and implementation of the PostgreSQL driver with a human interface using almost all currently available C ++ 17 language tools.
The approach described in the report can be adapted to almost any application-level protocol.
About Speaker
Sergey Fedorov, a leading developer at Yandex.Taxi, is developing an asynchronous framework for the Taxi backend. A big fan of metaprogramming and open source.
8. Move-only C ++ design
Ivan Čukić
RAII releases the captured resources. But there is a resource that cannot be returned - this is time.
One of the most time-consuming errors is creating unnecessary copies. The C ++ 11 Move semantics took a step in the right direction. It allows you to give unnecessary data to someone else without a fine to create a copy and without the risk of racing according to the data when the data has many users.
In this talk, we will take part in a discussion of an architecture approach that only allows the use of special uncopyable roaming types called “linear types”. The possibilities of C ++ will be discussed, which will allow us to force the use of just such types.
For this, it is proposed to use concepts from C ++ 20, && - qualified functions, etc.
About Speaker
Ivan Chukich is the author of Functional Programming in C ++, published by Manning. KDE contributor is one of the largest open source open source projects. In addition, he teaches modern programming techniques at the university, transferring to his students his 20 years of experience using C ++. He did research on functional programming in C ++ during and before the post-doc, and used these techniques in real-world projects.
7. Concurrency and parallelism in C ++ 17 and C ++ 20/23
Rainer grimm
What is common between threads, atoms, mutexes, and conditional variables? All these are the basic blocks for building any multi-threaded applications in C ++, and they can cause problems even for experienced C ++ developers.
This situation has seriously changed in C ++ 17, and even more so in C ++ 20/23. Starting with C ++ 17, most standard algorithms are available in serial, parallel and vectorized form. In the latest standards, we expect executors and transactional memory, we can expect big improvements in futures and coroutines. For multithreading and concurrency, this is just the beginning. It is hoped that in the future, only they (executors, transactional memory, futures, coroutines) will be used in abstractions, and threads, atoms, mutexes and conditional variables will become just implementation details.
The purpose of this report is to see what we have already received in C ++ 17 and what we can hope for in C ++ 20/23.
About Speaker
Rainer Grimm has been working as an architect, team leader and instructor for about 20 years. In his free time he likes to write articles about C ++, Python and Haskell and speak at conferences, often writes on his blog “Modern C ++”. He currently leads seminars on modern C ++ and Python. His books C ++ 11 für Programmierer, C ++, C ++ Standardbibliothek and The C ++ Standard Library are published both by O'Reilly and Leanpub.
6. Metaprogramming, gentle compiler
Andrey Davydov
Any programmer who has plunged into the world of C ++ knows that templates are turing-complete, “substitution failure is not an error” and in compile-time you can do amazing, and sometimes even useful things. On the other hand, an experienced C ++ developer understands that “you can” does not mean “you need” and that you have to pay for the abuse of metaprogramming. One of the main constraints is compilation time, which is why the report discusses which operations / techniques are most expensive from the point of view of the compiler and how to avoid them.
In particular, the following issues were highlighted:
- why SFINAE is the last thing to use;
- why std :: conditional_t is defined inefficiently;
- what is the difference between tuple implementations in Microsoft STL and libc ++;
- when to use std :: {conjunction, disjunction}, and when to use fold expressions;
- why you should not use std :: void_t;
- how concepts appearing in C ++ 20 can help.
About Speaker
For the past 3 years, Andrey has been working in the ReSharper C ++ team at JetBrains. In the past he was engaged in industrial programming in areas related to GIS and 3D-visualization systems.
5. Essential C ++
Anton Polukhin
Each new-fangled programming language strives to state that it is faster, more reliable and generally in all respects several times better than C ++.
Let's see where is the truth and where is fiction. Let the battle begin between C ++ and Asm / Rust / Go / Java / C # ...!
About Speaker
Representative of Russia in ISO at international meetings of the working group on standardization C ++. The author of several accepted proposals for the C ++ language standard.
Author of Boost libraries TypeIndex, DLL, Stacktrace and active maintainer Any, Conversion, LexicalCast, Variant.
He is the author of Boost C ++ Application Development Cookbook and Second Edition.
4. Postmodern immutable data structures
Juan Pedro Bolívar Puente
The C ++ Elite has been talking about value semantics, immutability, and sharing by communicating for years. We are waiting for a better world without mutexes, races, observers, “team” patterns and all that jazz. When it comes to practice, there are big problems. One of the main problems is in data structures.
Immutable data structures do not change values in order to work with them - you need to create new values. The old values remain as they are, and therefore you can work with them from multiple threads without blocking. This gives us a structural separation of resources, because new and old values can use the same common data - they can be quickly compared and very compactly stored undo-history. That is why they are so nice to use in multi-threaded and interactive systems: they simplify the architecture of desktop software and allow servers to scale better. This is the secret ingredient that has determined the success of Clojure and Scala, and even JavaScript developers like to use them with something like Facebook’s Immutable.js.
Juan introduces Immer, a C ++ library that implements modern, efficient, immutable data structures.
In this talk, he talked about the architectural benefits of immutability and showed how an extremely efficient and powerful persistent vector can be built on the basis of modern data structures brought to perfection (Relaxed Radix Balanced Trees). We looked at an example program - a text editor designed in such an architectural style. The code is not just super-simple, it also outstrips most similar programs in performance. Do not believe? Open the report and see for yourself!
Technologies used:
- https://github.com/arximboldi/immer
- https://github.com/arximboldi/ewig
- https://github.com/arximboldi/lager
About Speaker
Juan is a freelance consultant and engineer from Berlin specializing in value oriented design, interactive software, modern C ++, functional programming and the strategic use of open source. Prior to that, he worked at Ableton and was involved in various projects related to music. He also participated in the GNU project and co-founded Hacklab in Granada.
3. Concepts: simplifying the implementation of std utility classes
Andrey Davydov
Concepts appearing in C ++ 20 are a long and widely discussed topic. Despite the excess of material accumulated over the years (including the speeches of world-class experts), there is still confusion among applied programmers (who do not fall asleep daily with the standard), what exactly are C ++ 20 concepts and are they we need if there is enable_if checked over the years. Partly the fault is how the concepts evolved over ~ 15 years (Concepts Full + Concept Map -> Concepts Lite), and partly because the concepts turned out to be unlike similar tools in other languages (Java / C # generic bounds, Rust traits, ... )
The report will begin with a brief overview of the concept-related innovations of C ++ 20, after which we will look at the implementation of some classes and functions of STL, comparing C ++ 17 and C ++ 20 solutions. For example:
- to implement std :: optional now you have to use the inheritance hierarchy of depth 7, in C ++ 20 it will not be necessary;
- for the default constructor std :: pair now requires 2 template functions, in C ++ 20 - 1 non-template;
- often, template classes partially specialize, in the case when the template parameters have some special properties, it is more convenient and more correct to do this with concepts.
The audience is supposed to have a general idea of what concepts and SFINAE are. Familiarity with the standard C ++ library will also be useful; knowledge of the intricacies and implementation details is not required.
About Speaker
For the past 3 years, Andrey has been working in the ReSharper C ++ team at JetBrains. In the past he was engaged in industrial programming in areas related to GIS and 3D-visualization systems.
2. Initialization in modern C ++
Timur Doumler
It is well known that initialization semantics are one of the most complex parts of C ++. There are many types of initialization, described by different syntax, and they all interact in a complex and challenging way. C ++ 11 brought the concept of “universal initialization”. Unfortunately, she introduced even more complex rules, and in turn, they were blocked in C ++ 14, C ++ 17 and changed again in C ++ 20.
In this report, Timur first summed up the historical results of the evolution of initialization in C ++. He gave a systematic overview of the current version of the initialization rule, typical problems and surprises. He introduced practical rules on how to use all these rules effectively. Finally, Timur spoke about the latest proposals in the standard, which can make the semantics of C ++ 20 initialization a little more convenient.
About Speaker
Timur is a C ++ developer specializing in sound and music, a member of the ISO C ++ committee, program director of the Audio Developer Conference (ADC). He strives to write clean code, developing good tools, promoting the evolution of the C ++ language, and building inclusive communities.
1. C ++ 17 - the biggest traps
Nicolai josuttis
C ++ 17 is a huge combination of small new features, both in the language and in the library. These capabilities not only allow you to do more new things, but also provide new ways to shoot in the legs - much more often than you expected. This is not a theory. It happens in real life, here and now.
In this report, Nikolai examined all these traps, discussed the reasons behind the ideas and architecture that lay behind them, and gave instructions on how to get around the problems. As a side effect, you can take a deeper look at the new features of C ++ 17.
About Speaker
Nikolay is an independent systems architect, technical manager, author and consultant. He develops mid and large software systems for telecommunications, finance, and manufacturing.
He is widely known in the community for his reports and the fact that he writes books about C ++ ( The C ++ Standard Library and C ++ Templates ), talks about new features of the language.
For 20 years, he is an active member of the C ++ Standardization Committee.
A full playlist with all reports is available here . We remind you that the new C ++ Russia is already on its way and will be held October 31 - November 1, 2019 in St. Petersburg. Tickets for it can be purchased on the official website .
All Articles