C++ in Depth NEW

• C++ Ecosystem. Code lifecycle from source file to machine execution
• C++ Fundamentals: data types, object lifetime, object representation in memory
• Memory management, stack and heap memory, smart pointers.
• We'll develop the habit of using RAII — one of the most important C++ idioms
• Return value optimization, rvalue-references, move semantics
• How to return an object from a function: by value or by reference
• Templates: we'll write a logger that accepts any number of parameters
• Overview of the standard library: containers, iterators, algorithms

Practice
• Simple utilities implementation (ls, find, tree...)
• Implement own containers and logger

• Type conversions and RTTI: where to use reinterpret_cast and how to implement abstract factory
• Functional programming. Implementation of the observer pattern.
• Error handling: from error codes and exceptions to std::expected. Why do some projects have no exceptions at all?
• Multithreading: from posix mutex to std::condition_variable.
• Common problems (deadlock, false sharing) and how to avoid them.
• Standard library beyond containers: memory, chrono, variant, filesystem, metaprogramming
• Introduction to CMake: targets, dependencies. How to create a simple and correct project structure from libraries and executables
• Working with different compilers and platforms. Undefined, unspecified and implementation-defined behavior: why it's important to know the difference between these concepts and not be afraid of them

Practice
• Implementation of patterns (observer, factory, etc.)
• Implementation of utility programs (file downloader, diff)

• Overview of Qt ecosystem. General ideas and principles of library design
• Working with applications and widgets in Qt
• GUI application architecture. How to separate computation logic from interface logic
• Multithreading: task queues, event loop. How to keep the GUI active while computations are happening
• Building, packaging and distribution of C++ applications

Practice
• Development of a desktop application with a heavy interactive interface
• Performance optimization for interactive scenarios

• API design: how to make an API that's hard to use incorrectly. We'll examine both general concepts and C++-specific techniques
• Cross-platform development: we'll experience the difference in compiler behavior and infrastructure peculiarities of different target systems (Linux, macOS, Windows)
• CMake: working with third-party libraries and unit tests. We'll create a CI-friendly SDK build and prepare an installable package.
• Introduction to the OpenCV library and basic image processing. We'll write an image processing pipeline using OpenCV algorithms
• Unit testing using google-test. From basic scenarios to using gMock

Practice
Develop a cross-platform image processing library: from API design to unit testing and deployment

• Overview of Raspberry Pi. We'll compile and run programs on Raspberry Pi
• Profiling and program optimization. How to read assembly code and when it's worth doing
• Overview of popular 3rd party libraries and their usage
• Tools for C++: static code analysis, clang-tidy, clang-format, profilers, sanitizers
• What C++ looks like in the latest standards: modules, coroutines
• C++ standards and their evolution. Overview of common coding conventions and peculiarities of using
• C++ in different domains: how C++ for a desktop application differs from C++ for NASA

Practice
• Cross-compilation and execution of programs on embedded systems (using the Raspberry Pi as an example)
• Debugging, performance measurement and optimization