х2018 Autumn2018 Spring2017 Autumn2017 Spring2017 Winter2016 Autumn2016 Summer20162015
#CoreHardBy

C++ CoreHard Autumn 2018 Сonference

The C++ CoreHard Autumn 2018 is a conference dedicated to C++ and related hardcore technologies.

The conference is being organized by the CoreHard.by community that unites not only C++ engineers, but also those who are interested in low-level development in C and Assembler, programming of controllers, Internet of Things, highload server solutions and in any kind of “hardcore” development.

The conference will take 2 days: November 2 - workshop day, November 3 - conference day

Official conference languages: Russian, English

Want to present a talk? Submit a proposal


#CoreHardBy
Tickets
Date Workshop (Day 1) Conference (Day 2) Live stream (Day 2)
13.10.2018 - 02.11.2018 350 BYN 220 BYN 50 BYN

«Victoria SPA» hotel offers special prices for our conference participants

Speakers

Master classes, November 2

  • 9:30 - 10:00

    Registration

  • 10:00 - 19:00

    Quick and modern C++ [Russian]

    Antony Polukhin

    In any large codebase you can always find pieces of code which are not totally understandable. Mostly, such kind of code is implemented when the application needs some performance boost... and, mostly, that code is not useful because it optimizes functionality in wrong place, in incorrect way and in not a good way.
    During our masterclass we will get to know to the allocators features, optimizers and implementations of containers; look at assembler code; learn how to correctly and clearly write fast single-threaded and multi-threaded applications.
    You only need a complier with C++ 11 support (at least VS 2013/Clang-3.3/GCC-4.8) and basic C++ knowledge

  • 9:30 - 10:00

    Registration

  • 10:00 - 19:00

    Multithreading with modern C++ [English]

    Rainer Grimm

    Abstract
    This class gives you a detailed insight into the multithreading facilities of C++11 and C++14, and the parallel algorithms which we got with C++17. If possible, we will have a more in-depth look into the C++ memory model consisting of the atomics and the various memory models in C++. This insight will provide you with a better understanding of the general concurrency features of C++.
    Prerequisite
    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.
    Agenda:
    Multithreading
    Threads
    Shared Data
    Mutexes and Locks
    Thread-safe Initialisation
    Thread-Local Data
    Condition Variables
    Tasks (Promises and Futures)
    The Memory Model
    The Contract
    Atomics
    The Synchronisation and Ordering Constraints -- Sequential Consistency -- Acquire-Release Semantic -- Relaxed Semantic
    Parallel Algorithms of the Standard Template Library (C++17) Execution Policies
    Algorithms -- The New Algorithms

  • 9:30 - 10:00

    Registration

  • 10:00 - 19:00

    Advanced C++ techniques and functional programming idioms [English]

    Ivan Čukić

    - Algorithms in the standard library
    - Function objects in C++, callables and std::invoke
    - Lazy evaluation, lazy algorithms and ranges
    - Creating new language constructs on the library level
    - Removing invalid program states with sum types and std::variant
    - Generic programming and template constraints using void_t
    - Handling errors with optional<T> and expected<T, E>
    - Monad composition

  • 9:30 - 10:00

    Registration

  • 10:00 - 19:00

    Continuous integration for C++ developers [Russian]

    Pavel Filonov

    And we will build our own CI with conan and travis
    Introduction
    Developers’ mind has a common opinion, about their work which become completed after they’ve committed the code, and what happens next – not their problem. There is a great quote by Robert Highline for that thesis:
    Each person should know how to change diapers, plan the invasion, harvest a pig, construct buildings, control a ship, write sonnets, make financial reports, build walls, set bones, assist dying, carry out an order, give out orders, cooperate, act alone, solve equations, analyze new problems, fertilize plants, program computers, cook tasty food, fight with dignity, die with dignity.

    Specialization is the destiny of insects.

    And instead of the opinion mentioned above, will put out our own thesis - the fact that code compilates on the developer’s environment and developer’s personal machine is not interesting for anyone! Our goal - Ii to make another step to the continuous integration, automate dependency resolution, assembling and unit testing for all the platforms which are interesting for us.

    Continuous Integration
    Continuous integration is the kind of practice, according to which, developers periodically (you can read it as daily) put out the results of the work into the main code branch. First use of that practice was introduced in the Buch method. Later, at extreme programming methodology, it improved with automatic unit tests run. Next step of current practice development is Continuous Delivery - the process where the distributive is created, after all acceptance tests are successfully completed, the distributive which ready to be published to the customer. And at the very end we can speak about Continuous Deployment during which all the changes that passed the testing phase successfully, automatically deployed to production. If you are already confused, you can imagine the following sequence:
    1. Continuous integration
    2. Continuous delivery
    3. Continuous deployment
    At the course of the current master-class we will speak about CI in the scope of C++ development.

    Preliminary requirements
    What is required from you:
    - experience in using C++ (thanks, Cap!)
    - laptop with any OS installed
    - one of the compilers (Visual Studio >= 2015 / g++ >= 5.4 / clang++ >= 3.9 / Xcode >= 8.0)
    - cmake >= 3.6 (you need to understand the syntax of CMakeLists.txt)
    - git >= 2.10
    - python >= 3.5
    - pip3 >= 9.0
    - github.com account
    - travis-ci.org account (linked to github)
    - appveyor.com account (linked to github)
    - conan.io account
    - digitalocean.com account

    Part One - github
    In the first part, we will assume that you are creating a personal home project, work on Open Source project or can store source files on some external resource, and ready to pay for it. What tasks you will be able to solve:
    - understand how to automate assembling for Linux and Mac OS with Travis-CI
    - understand how to automate assembling for Windows with the help of appveyor
    - understand how to manage dependencies with the help of conan
    - understand how to automate unit tests runs for all the platforms
    - understand how automatically deploy with different configurations different compiler versions
    - understand how to create your own packets for conan (first step towards CD)

    Part Two - self hosted gitlab
    During the second part we’l’ look at the situation when your working project has closed source code, and you don't want to have strong dependency for vendor lock infrastructure. What tasks you will be able to solve:
    - how to deploy gitlab at digitalocean fast(DO)
    - how to configure gitlab CI for your project


    Conclusion

Conference, November 3

  • 10:30 - 11:00

    Registration

  • 11:00 - 11:10

    Opening

  • 11:10 - 12:00

    Text Formatting For a Future Range-Based Standard Library [English]

    Arno Schödl

    Text formatting has been a favorite problem of C++ library authors for a long time. The standard C++ iostreams have been criticized for being difficult to use due to their statefulness and slow due to runtime polymorphism. Despite its age, printf is still popular because of simplicity and speed. The Boost library offers two more alternatives, Boost.Format and Boost.LexicalCast. And finally, the P0645 standard proposal sponsored by Facebook is currently finding its way through the C++ committee. All these approaches are still firmly based on standard containers and iterators. But the Standard Library is changing radically with the advent of ranges, range adaptors and functional style programming in C++. Generating optimized code with metaprogramming is becoming standard fare. In this talk, I want to convince you that the combination of ranges with a bit of metaprogramming makes for a very elegant solution to the text formatting problem. We introduce a form of ranges with internal iteration, which are generating their elements one by one rather than exposing external iterators. We can use these generator ranges to represent the values to be formatted, conceptually turning them into lazily evaluated strings. These can be used just like regular strings are used today: in function returns; as standard algorithm input; embedded into other, equally lazily evaluated strings; and so on, before they are finally expanded for display. By choosing the right interfaces, we can optimize this expansion at compile-time, making it no less pretty to write, but more efficient to expand than any text formatting approaches that rely on format strings that must be parsed at runtime. I believe that this approach is the natural extension of a range-based future standard library to text formatting.

  • 12:10 - 13:00

    Useful constexpr [Russian]

    Antony Polukhin

    A new keyword constexpr was introduced in C++11. It looks really nondescript and from the first glance it looks like it dosn't have much sense... Why this keyword is useful, what superpower it has and what role it plays in future C++ evolution - thess will be topics of our discussion

  • 13:10 - 14:00

    Debug C++ Without Running [English]

    Anastasia Kazakova

    Macros, templates, compile-time evaluation and code generation, reflection and metaclasses – C++ tends to hide the final code passed to the compiler under the tons of various names and aliases. Add here the preprocessor that shadows the actual running curve of your program with dozens of alternatives mixed in a non-trivial way. While this allows to avoid boilerplate code and reduce copy-paste and other errors, such an approach demands better tooling support to make the debugging process easier. To find an error in such a code, one has to continuously read-fix-run it and compare the results with some etalon, or to debug in order to find actual substitutions. But should you really wait until your code is run or even compiled to debug it? Or how to deal with the situations when the code can’t be run on the local machine? A text editor with code completion won’t help, while a smart IDE that “gets” your code can do a better job. In this talk we’ll see interesting approaches to solving cases like macro and typedef ‘debug’, understanding types when auto/decltype hide them, dealing with different code branches depending on the preprocessor’s pass-through, and other ideas. Some suggestions are already implemented as ready-to-use features in CLion and ReSharper C++, tools for C++ from JetBrains (that means I can show it in action), others are planned for the future. The aim of this talk is to share the workflows supported by the tools that can help C++ developers create better modern C++ code.

  • 14:00 - 15:00

    Lunch

  • 15:10 - 15:00

    Asynchronous programming with ranges [English]

    Ivan Čukić

    This talk will be about the design and implementation of a reactive programming model inspired by ranges that allows easy implementation of asynchronous and distributed software systems by writing code that looks like a sequence of ordinary range transformations like filter, transform, etc. This programming model will be demonstrated along with the implementation of a simple asynchronous web service where the whole system logic is defined as a chain of range transformations.

  • 16:10 - 17:00

    Learning in Python, applying in C++ [Russian]

    Pavel Filonov

    This talk is about frequently used pattern at my projects on data analysis, when the education and configuration of the models is performed using python, but production use runs are on C++. We will take a look at some educational examples of implementing such kind of approach, from simple linear regression to image processing using neural networks.

  • 17:10 - 18:00

    Processing sequences in C++ in functional style: from recursion to hylomorphism [Russian]

    Vadim Vinnik

    C++ language, having undergone a long evolution, has acquired a number of features specific to the functional paradigm: functions became first-class objects that can be operated on, and template instrumentation suports compile-time computation on types. The mathematical basis of these two features are lambda calculus and category theory, respectively. Extendinng the language with these tools brought to implementation in C++ of various instruments knows from functional programming. Some of these implementations became a part of the standard library (std::function, std::bind), others reside in third-party libraries, in particular - in Boost collection of libraries (for example, fufnctional, hana). An important place in the functional programming toolkit belongs to fold and unfold operations which are most obviously defined for lists and also can be quite naturally generalised onto other inductive and coinductive data structures. For example, calculating a sum of a list of numbers can be presented as folding the list against addition; building a list of prime factors for a given integer is an example of unfolding that integer. Generalisations of folds and unfolds are known as anamorphisms and catamorphisms. In addition, a composition of unfold (of some object into a collection) with subsequent fold (of that collection into a new object) finds its applications in functional programming. It is demonstrated in this talk that folds, unfolds and compositions thereof can be easily implemented in C++.

  • 18:10 - 19:00

    Concurrency and Parallelism in C++17 and C++20/23 [English]

    Rainer Grimm

    What do threads, atomic variables, mutexes, and conditional variables have in common? They are the basic building blocks of any concurrent application in C++, which are even for the experienced C++ programmers a big challenge. This massively changed with C++17 and change even more with C++20/23. What did we get with C++17, what can we hope for with C++20/23? With C++17, most of the standard template library algorithms are available in sequential, parallel, and vectorised variants. With the upcoming standards, we can look forward to executors, transactional memory, significantly improved futures and coroutines. To make it short. These are just the highlights from the concurrent and parallel perspective. Thus there is the hope that in the future C++ abstractions such as executors, transactional memory, futures and coroutines are used and that threads, atomic variables, mutexes and condition variables are just implementation details.

  • 19:00 - 19:10

    Closing

  • 10:30 - 11:00

    Registration

  • 11:00 - 11:10

    Opening

  • 11:10 - 12:00

    Text Formatting For a Future Range-Based Standard Library [English]

    Arno Schödl

    Text formatting has been a favorite problem of C++ library authors for a long time. The standard C++ iostreams have been criticized for being difficult to use due to their statefulness and slow due to runtime polymorphism. Despite its age, printf is still popular because of simplicity and speed. The Boost library offers two more alternatives, Boost.Format and Boost.LexicalCast. And finally, the P0645 standard proposal sponsored by Facebook is currently finding its way through the C++ committee. All these approaches are still firmly based on standard containers and iterators. But the Standard Library is changing radically with the advent of ranges, range adaptors and functional style programming in C++. Generating optimized code with metaprogramming is becoming standard fare. In this talk, I want to convince you that the combination of ranges with a bit of metaprogramming makes for a very elegant solution to the text formatting problem. We introduce a form of ranges with internal iteration, which are generating their elements one by one rather than exposing external iterators. We can use these generator ranges to represent the values to be formatted, conceptually turning them into lazily evaluated strings. These can be used just like regular strings are used today: in function returns; as standard algorithm input; embedded into other, equally lazily evaluated strings; and so on, before they are finally expanded for display. By choosing the right interfaces, we can optimize this expansion at compile-time, making it no less pretty to write, but more efficient to expand than any text formatting approaches that rely on format strings that must be parsed at runtime. I believe that this approach is the natural extension of a range-based future standard library to text formatting.

  • 12:10 - 13:00

    Cross-platform code generation for C++, continued [Russian]

    Alexey Tkachenko

    The talk deals with code generation when compiling various constructs of the language, from simple to complex, on different platforms: from widely known as x86/x64 to less familiar like ARM and AVR. There will be also examples for very exotic processors such as PowerPC or even MicroBlaze. The main focus will be made not on data processing but rather on mapping of various code constructs onto instructions of the target platform.

  • 13:10 - 14:00

    What the compiler cannot optimize [Russian]

    Alexander Zaitsev

    All of us know that compilers are quite clever nowadays. And we, programmers, sometimes have no need to think about those tiny optimizations – we devote them to the compiler. So, it’s time to find out, whether the compilers are really that clever, and find out the places where a programmer (might be) is cleverer.

  • 14:00 - 15:00

    Lunch

  • 15:10 - 16:00

    Metaclasses: implementing dreams in reality [Russian]

    Sergei Sadovnikov

    The talk is about the question of implementation of Herd Sutter’s proposal PR0707 (metaclasses at C++) outside the compiler – as a separate utility. We will demonstrate the options of metaclasses using in real life, talk about implementation features based on Clang Frontend, and possible perspectives of technology and methodology evolution.

  • 16:10 - 17:00

    Speeding up build process for C++ projects: ways and consequences [Russian]

    Aliaksandr Zhorau

    The talk is about the ways of improving build times of C++ projects, the experience gained during the speeding up the client and tools of World of Tanks. We will also describe the effect on codebase organization (positive and negative) and costs, which are required for supporting those solutions, because some of the are not shareware. The methodology described in the speech: incremental linking, Fastlink), compilation speed-up (include what you use, using precompiled headers).

  • 17:10 - 18:00

    How to teach C++: experience creating Coursera courses [Russian]

    Ilia Shishkov

    For more than 2 years already we are creating online-specialization at Coursera platform. The goal of that specialization is to teach C++ from the very beginning to the level, which is good enough for solving practical tasks, which the authors met during their working experience. In my speech I will tell you about how we create our online-courses, and pay special attention to the tech issues, that we’ve managed to solve during the process of development of the automatic system for evaluating students’ home tasks.

  • 18:10 - 19:00

    Concurrency and Parallelism in C++17 and C++20/23 [English]

    Rainer Grimm

    What do threads, atomic variables, mutexes, and conditional variables have in common? They are the basic building blocks of any concurrent application in C++, which are even for the experienced C++ programmers a big challenge. This massively changed with C++17 and change even more with C++20/23. What did we get with C++17, what can we hope for with C++20/23? With C++17, most of the standard template library algorithms are available in sequential, parallel, and vectorised variants. With the upcoming standards, we can look forward to executors, transactional memory, significantly improved futures and coroutines. To make it short. These are just the highlights from the concurrent and parallel perspective. Thus there is the hope that in the future C++ abstractions such as executors, transactional memory, futures and coroutines are used and that threads, atomic variables, mutexes and condition variables are just implementation details.

  • 19:00 - 19:10

    Closing

  • 10:30 - 11:00

    Registration

  • 11:00 - 11:10

    Opening

  • 11:10 - 12:00

    Text Formatting For a Future Range-Based Standard Library [English]

    Arno Schödl

    Text formatting has been a favorite problem of C++ library authors for a long time. The standard C++ iostreams have been criticized for being difficult to use due to their statefulness and slow due to runtime polymorphism. Despite its age, printf is still popular because of simplicity and speed. The Boost library offers two more alternatives, Boost.Format and Boost.LexicalCast. And finally, the P0645 standard proposal sponsored by Facebook is currently finding its way through the C++ committee. All these approaches are still firmly based on standard containers and iterators. But the Standard Library is changing radically with the advent of ranges, range adaptors and functional style programming in C++. Generating optimized code with metaprogramming is becoming standard fare. In this talk, I want to convince you that the combination of ranges with a bit of metaprogramming makes for a very elegant solution to the text formatting problem. We introduce a form of ranges with internal iteration, which are generating their elements one by one rather than exposing external iterators. We can use these generator ranges to represent the values to be formatted, conceptually turning them into lazily evaluated strings. These can be used just like regular strings are used today: in function returns; as standard algorithm input; embedded into other, equally lazily evaluated strings; and so on, before they are finally expanded for display. By choosing the right interfaces, we can optimize this expansion at compile-time, making it no less pretty to write, but more efficient to expand than any text formatting approaches that rely on format strings that must be parsed at runtime. I believe that this approach is the natural extension of a range-based future standard library to text formatting.

  • 12:10 - 13:00

    Information security and software development: what a programmer should know [Russian]

    Evgeniy Ryzhkov

    Information security is migrating from a separate sphere to the software development more and more. And that means, that “common” programmers should understand the requirements and terminology, which all the security specialists know and use. CWE, CERT, MISRA, SAST – for “common” programmers, those abbreviatures are gibberish. That’s way in that synoptic report we will try to tell you all in simple words about those terms the way all the developers understand and start working in that topic without issues.

  • 13:10 - 14:00

    Know Your Hardware: CPU Memory Hierarchy [Russian]

    Alexander Titov

    If you care about performance, you must know your hardware. Modern CPUs have many properties that can impact the performance of C++ code. This talk provides an overview of the structure and algorithms of a modern CPU with focus on the memory hierarchy. Specific topics include cache organization, locality principle, prefetching, false sharing and cache-friendly program techniques.

  • 14:00 - 15:00

    Lunch

  • 15:10 - 16:00

    Actors vs CSP vs Tasks vs ... [Russian]

    Yauheni Akhotnikau

    During the previous C++ CoreHard conferences, the speaker talked about Actors Model and the experience of using it in C++. But Actors Model is not the only way of working with multithreading complexity. Let’s talk about what else we can use and how it can look in C++

  • 16:10 - 17:00

    What every developer should know or how to pass your job interview [Russian]

    Igor Sadchenko

    We will talk about the process of interviewing the candidate, the required minimum topics for questioning. We will also try to derive the average knowledge level of a well-qualified developer.

  • 17:10 - 18:00

    Packaging open-source libraries with conan.io [Russian]

    Konstantin Ivlev

    It was always challenging to use C++ libraries - you had to properly build them, dealing with various build systems, but with inception of conan.io package manager it became much more straightforward, so now we just need all required libraries packaged, and bincrafters is your OpenSource DevOps team to rescue.

  • 18:10 - 19:00

    Concurrency and Parallelism in C++17 and C++20/23 [English]

    Rainer Grimm

    What do threads, atomic variables, mutexes, and conditional variables have in common? They are the basic building blocks of any concurrent application in C++, which are even for the experienced C++ programmers a big challenge. This massively changed with C++17 and change even more with C++20/23. What did we get with C++17, what can we hope for with C++20/23? With C++17, most of the standard template library algorithms are available in sequential, parallel, and vectorised variants. With the upcoming standards, we can look forward to executors, transactional memory, significantly improved futures and coroutines. To make it short. These are just the highlights from the concurrent and parallel perspective. Thus there is the hope that in the future C++ abstractions such as executors, transactional memory, futures and coroutines are used and that threads, atomic variables, mutexes and condition variables are just implementation details.

  • 19:00 - 19:10

    Closing

Organizers

  • CoreHard

Partners

  • Solarwinds
  • JetBrains
  • think-cell.com/corehard2018
  • PVS-Studio
  • DPI Solutions

Infopartners

  • Job tut.by
  • Wargaming
  • Kaspersky Lab
  • IT-academy
  • Dot Net Summit
  • dev.by
  • Imaguru
  • IBA
  • comaqa.by
  • Epam
  • itstep.by
  • gamedev.by
  • javaday.by
  • conf.cocoaheads.by
  • ITVDN
  • HotWork
  • trud.com
  • avradays.com
  • vse-kursy.by
  • Аргументы и Факты
  • БГУИР
  • afisha.tut.by
  • DMK press