developers, architects
3 days

Today stability and security are such essential subjects that in order to achieve them many companies are even willing to sacrifice the performance of the final product.

This training is not a comprehensive training on all security aspects. It rather scopes on the C++ language side of that subject and provides an overview and practical answers on writing stable and secure C++ code. It describes usual coding standards on the C++ market and points out common issues introduced by their usage. Workshop part of the training scopes heavily on how to write robust interfaces that are easy to use and hard to abuse. It also teaches tools, C++ features, and coding practices that enforce writing secure code. Additionally, much attention is put on various types of error handling.

The training targets C++ developers and code architects that need to write software that is resistant to security and stability coding errors.

This course builds on top of the knowledge delivered in Advanced Modern C++ training, so please consider requesting them in that order.


  • Understanding how a poor coding standard encourages the injection of security and stability related issues
  • Particular focus on mastering the skills needed to design and implement robust interfaces
  • Learning the tools that prevent injection of security and stability issues in user's code
  • Broad review and emphasis on selecting the best error handling scenario to do the job


The following plan is an initial proposal for the training material. The final agenda is always created based on the individual pre-training analysis of the client's requirements and constraints.

  1. Advanced Modern C++ in a nutshell
    1. Identifiers
    2. C++ Types
    3. Objects and their representation
    4. Lifetime and Storage
    5. Name Lookup
    6. Special Member Functions
  2. Bad coding standards
    1. Typical issues of legacy code
    2. Pitfalls of buggy coding standards
    3. Class construction and destruction
    4. Magic numbers everywhere
  3. Strong interfaces
    1. Pointless Pointers
    2. Helper types and idioms
    3. C++ Concepts
    4. C++ Contracts
    5. [[nodiscard]]
  4. Features, tools, and practices
    1. Smart pointers
    2. override
    3. static_assert
    4. type_traits
    5. std::variant<Types...>
    6. Range-based for loop
    7. algorithms
    8. C++ ranges
    9. std::array<T, N>, std::string_view, span<T, N>
    10. [[fallthrough]]
  5. Error handling
    1. C-style
    2. C++ dynamic exceptions
    3. std::error_code and std::error_condition
    4. std::optional<T>
    5. std::experimental::expected<T, E>
developers, architects
3 days


Mateusz Pusz