Конференция перенесена с 10-11 апреля на 30-31 октября 2020 в связи с неблагоприятной международной обстановкой. Вернуть личные
билеты можно через сервис
bezkassira.by
С любыми вопросами по отмене обращайтесь на conf@corehard.by или по телефону +375296088822
В любой большой кодовой базе можно встретить куски абсолютно непонятного кода. Как правило такой код пишется чтобы немного
выиграть в производительности приложения... и как правило такой код не нужен в принципе, так как оптимизирует не то что нужно,
не в том месте где это нужно и не так как надо.
В ходе мастер класса мы натолкнёмся на особенности аллокаторов, оптимизаторов и имплементаций контейнеров; посмотрим на ассемблерный
код; научимся правильно и понятно писать быстрые однопоточные и многопоточные приложения.
Для курса понадобится всего лишь базовые знания C++ и компилятор с поддержкой C++11 (как минимум Visual Studio 2013, или Clang-3.3,
или GCC-4.8).
В любой большой кодовой базе можно встретить куски абсолютно непонятного кода. Как правило такой код пишется чтобы немного
выиграть в производительности приложения... и как правило такой код не нужен в принципе, так как оптимизирует не то что нужно,
не в том месте где это нужно и не так как надо.
В ходе мастер класса мы натолкнёмся на особенности аллокаторов, оптимизаторов и имплементаций контейнеров; посмотрим на ассемблерный
код; научимся правильно и понятно писать быстрые однопоточные и многопоточные приложения.
Для курса понадобится всего лишь базовые знания C++ и компилятор с поддержкой C++11 (как минимум Visual Studio 2013, или Clang-3.3,
или GCC-4.8).
Course Description
This class gives you a detailed insight into the multithreading facilities of C++11, C++14, and the parallel algorithms which
we got with C++17.
Additionally, we will have a look into the C++ memory model consisting of the atomics and the various memory orders in C++.
This insight will provide you with a better understanding of the general concurrency features of C++.
Prerequisites
Participants should have a basic knowledge of the C++ language and the fundamentals of multithreading.
In the class, I will give you a concise introduction to the topic. This introduction provides the starting point for the exercises;
therefore, you should bring your laptop with you including a C++11 or C++14 compiler.
You will get in return the training material consisting of the presentation, the exercises, and the solutions to the exercises.
Course Topics
- Multithreading
-- Threads
-- Shared Data
-- Mutexes and Locks
-- Thread-safe Initialisation
-- Thread-Local Data
-- Condition Variables
-- Tasks (Promises and Futures)
-- Parallel STL
- Memory Model
Course Description
This class gives you a detailed insight into the multithreading facilities of C++11, C++14, and the parallel algorithms which
we got with C++17.
Additionally, we will have a look into the C++ memory model consisting of the atomics and the various memory orders in C++.
This insight will provide you with a better understanding of the general concurrency features of C++.
Prerequisites
Participants should have a basic knowledge of the C++ language and the fundamentals of multithreading.
In the class, I will give you a concise introduction to the topic. This introduction provides the starting point for the exercises;
therefore, you should bring your laptop with you including a C++11 or C++14 compiler.
You will get in return the training material consisting of the presentation, the exercises, and the solutions to the exercises.
Course Topics
- Multithreading
-- Threads
-- Shared Data
-- Mutexes and Locks
-- Thread-safe Initialisation
-- Thread-Local Data
-- Condition Variables
-- Tasks (Promises and Futures)
-- Parallel STL
- Memory Model
Design patterns have proven to be useful over several decades and knowledge about them is still very useful to design robust,
decoupled systems. Modern C++, however, has profoundly changed the way we use C++, think about design and implement solutions.
This hands-on training explores modern C++ design and the modern forms of the classic design patterns. It provides guidelines,
idioms and best practices for sustainable and maintainable design, which enable programmers to create professional, high-quality
code. Amongst others it will answer the following questions:
- How does good C++ design with a minimum of dependencies look like?
- Why does classical C++ design based on inheritance hierarchies fail so often?
- What advantages does value semantics based design provide?
- How are the classic design patterns realised in modern C++?
- What are alternatives to the classic design patterns?
After this course, participants will ...
... have an impression on the modern alternatives of classic design patterns;
... have gained knowledge about modern design techniques;
... understand how std::function, std::any, and ranges work;
... avoid the usual pitfalls in the context of inheritance;
... know about the importance of value semantics.
Design patterns have proven to be useful over several decades and knowledge about them is still very useful to design robust,
decoupled systems. Modern C++, however, has profoundly changed the way we use C++, think about design and implement solutions.
This hands-on training explores modern C++ design and the modern forms of the classic design patterns. It provides guidelines,
idioms and best practices for sustainable and maintainable design, which enable programmers to create professional, high-quality
code. Amongst others it will answer the following questions:
- How does good C++ design with a minimum of dependencies look like?
- Why does classical C++ design based on inheritance hierarchies fail so often?
- What advantages does value semantics based design provide?
- How are the classic design patterns realised in modern C++?
- What are alternatives to the classic design patterns?
After this course, participants will ...
... have an impression on the modern alternatives of classic design patterns;
... have gained knowledge about modern design techniques;
... understand how std::function, std::any, and ranges work;
... avoid the usual pitfalls in the context of inheritance;
... know about the importance of value semantics.
- Категории выражений: как не запутаться в (g?l|p?r|x)value;
- Семантика перемещения и её альтернативы (RVO, CoW);
- Специализации функций для короткоживущих объектов;
- Вычисления на этапе компиляции с помощью constexpr;
- Параметрический полиморфизм;
- Гибкая настройка с помощью классов свойств;
- SFINAE и сопоставление с образцом;
- Арифметические вычисления на типах;
- Обработка списков на этапе компиляции.
- Категории выражений: как не запутаться в (g?l|p?r|x)value;
- Семантика перемещения и её альтернативы (RVO, CoW);
- Специализации функций для короткоживущих объектов;
- Вычисления на этапе компиляции с помощью constexpr;
- Параметрический полиморфизм;
- Гибкая настройка с помощью классов свойств;
- SFINAE и сопоставление с образцом;
- Арифметические вычисления на типах;
- Обработка списков на этапе компиляции.
What kind of language is C++? Is it a procedural programming language? An object-oriented programming language? A functional
programming language? A generic programming language? All of those? None of those?
In this talk I’ll analyse why it is increasingly hard to answer these questions, especially since the advent of “Modern C++”.
I’ll demonstrate by example that the good solutions, i.e. the solutions that promote loose coupling, ease of use, ease of
maintenance, and performance, are not firmly rooted in either one of the traditional paradigms. The examples will raise doubt
whether it is reasonable to try to assign C++ to any one of the paradigms. Instead, they may be an indication that we should
embrace no-paradigm programming.
I want to start with a question: Why do we need Guidelines such as the C++ Core Guidelines for Modern C++? My answer consists
of three observations: C++ is complicated for the novice, challenging for the professional, and used in safety critical environments.
Guidelines should give us the means to write type safe, bounds safe, and lifetime safe code by design.
My presentation gives you a concise insight into the lifesaving rules of the C++ Core Guidelines to write safe C++ code by
design. I cover in my presentation topics such as interfaces, functions, classes and class hierarchies, resource management,
Expressions and statements, error handling, constants and immutability, templates and generic programming, concurrency and
the standard library.
Copy elision - важная и неотъемлемая языковая оптимизация, которая позволяет нам избавляться от лишних копирований и перемещений,
что благоприятно сказывается на производительности приложений. Ни один разработчик не представляет себе компилятор, который
не умеет NRVO. Но насколько copy elision действительно избавляет нас от лишних конструирований копий объектов? В каких случаях
он способен это делать, а в каких - нет, и почему? А можно ли что-то сделать, чтобы его улучшить, и как это улучшение повлияет
на производительность наших программ и на написание кода?
Данный доклад является ответом на все эти вопросы и не только. Мы расскажем о новом пропозале в Стандарт - ultimate copy elision,
и покажем как он улучшит жизнь разработчиков на C++!
Malware often use different Anti-Analysis approaches to deceive a disassembler, detect a debugger or just make the analysis
unbearable either with a disassembler or a debugger. However these techniques are used not only by the bad guys but also in
some products which owners don't want them to be researched.
This talk is an introduction to anti-debug and obfuscation tricks in C/C++. It will cover the following topics:
- compile time encryption for strings;
- how to make breakpoints on system functions useless;
- how to hide system call from sandboxes and API monitors;
- how to detect an attached debugger.
C++20 is finally here and with it the feature that was long time
coming -- concepts.
This talk will cover what concepts conceptually are (pun intended),
how they fit into the rest of C++, the requires syntax and a few
caveats of using them.
Some people deem concepts a huge and important addition to C++
while some consider them unnecessary because most features they
provide can be simulated with the detection idiom. Let's see
in which group you will be after this talk.
When static vs. dynamic language debates flare up, someone invariably says that static languages are best because the compiler
catches so many potential bugs. To which the dynamic language advocates say, "that doesn't happen very often, and when it
does your tests will catch it - you do have tests, don't you?"
Meanwhile, the debate about how to do error handling is almost as religious - do you do exceptions, error codes, assertions,
contracts or something like optionals or result/ expected types?
Could it be that all these concerns are related - and that understanding _how_ they are related may help us to resolve these
conflicts once and for all. More importantly, can we take the best of all worlds to arrive at the nirvana of understandable,
maintainable, robust, correct, code? These are the questions we will ponder, and hopefully answer.
What kind of language is C++? Is it a procedural programming language? An object-oriented programming language? A functional
programming language? A generic programming language? All of those? None of those?
In this talk I’ll analyse why it is increasingly hard to answer these questions, especially since the advent of “Modern C++”.
I’ll demonstrate by example that the good solutions, i.e. the solutions that promote loose coupling, ease of use, ease of
maintenance, and performance, are not firmly rooted in either one of the traditional paradigms. The examples will raise doubt
whether it is reasonable to try to assign C++ to any one of the paradigms. Instead, they may be an indication that we should
embrace no-paradigm programming.
Вот уже более 10 лет мы разрабатываем статический анализатор кода для языка C и C++. Оглядываясь назад, можно вспомнить множество
интересных событий, точек бифуркации, достижений и ляпов. Этот рассказ затронет широкий спектр проблем, начиная от сосулек
и кончая самостоятельным допиливанием парсера C++ кода. Рассказ будет интересен как просто ценителям истории C++, так и тем,
кто интересуется развитием стартапов в сфере программирования.
Есть в С++ комитете группа людей, которая занимается вопросами представления чисел в различном их виде в C++. Если Вам интересно,
какие именно технические проблемы и как решаются (или предлагаются к решению), зачем их вообще решают и почему об этой подгруппе
Комитета слышно практически ничего - добро пожаловать. Если Вам интересны некоторые особенности работы внутри Комитета (в
том числе с некоторыми внутренними интригами) - добро пожаловать тем более :)
Степень “хардкорности”: низкая. Уровень гнева в сторону С++ комитета: средний.
Предложение P1717 в стандарт C++ предлагает сверхпособности, не имеющие равных тем, что у нас были прежде, даже в сравнении
с наиболее изощрёнными приёмами шаблонного метапрограммирования.
Мы приоткроем завесу над этим и узнаем как обуздать эту мощь на примере реализации сериализации.
Мы увидим какие возможности предлагает рефлексия, грядущая в скором времени, и как метапрограммирование в C++ качественно
значительно изменится в будущем.
When static vs. dynamic language debates flare up, someone invariably says that static languages are best because the compiler
catches so many potential bugs. To which the dynamic language advocates say, "that doesn't happen very often, and when it
does your tests will catch it - you do have tests, don't you?"
Meanwhile, the debate about how to do error handling is almost as religious - do you do exceptions, error codes, assertions,
contracts or something like optionals or result/ expected types?
Could it be that all these concerns are related - and that understanding _how_ they are related may help us to resolve these
conflicts once and for all. More importantly, can we take the best of all worlds to arrive at the nirvana of understandable,
maintainable, robust, correct, code? These are the questions we will ponder, and hopefully answer.
What kind of language is C++? Is it a procedural programming language? An object-oriented programming language? A functional
programming language? A generic programming language? All of those? None of those?
In this talk I’ll analyse why it is increasingly hard to answer these questions, especially since the advent of “Modern C++”.
I’ll demonstrate by example that the good solutions, i.e. the solutions that promote loose coupling, ease of use, ease of
maintenance, and performance, are not firmly rooted in either one of the traditional paradigms. The examples will raise doubt
whether it is reasonable to try to assign C++ to any one of the paradigms. Instead, they may be an indication that we should
embrace no-paradigm programming.
When static vs. dynamic language debates flare up, someone invariably says that static languages are best because the compiler
catches so many potential bugs. To which the dynamic language advocates say, "that doesn't happen very often, and when it
does your tests will catch it - you do have tests, don't you?"
Meanwhile, the debate about how to do error handling is almost as religious - do you do exceptions, error codes, assertions,
contracts or something like optionals or result/ expected types?
Could it be that all these concerns are related - and that understanding _how_ they are related may help us to resolve these
conflicts once and for all. More importantly, can we take the best of all worlds to arrive at the nirvana of understandable,
maintainable, robust, correct, code? These are the questions we will ponder, and hopefully answer.
