Please rotate your tablet to be horizontal.

You can dismiss this notice but please note that this experience has not been designed for mobile devices and so will be less than optimal

Dismiss
Back To Schedule

System Architecture and Design Using Modern C++

3 Day Workshop (7th-9th September) 09:00 - 15:00 MDT
Interface Design & Portability
Add to Google Calendar

System Architecture and Design Using Modern C++ is a three-day online training course with programming examples, taught by Charley Bay. It is offered online from 09:00 to 15:00 Aurora time (MDT), 11:00 to 17:00 EDT,  17:00 to 23:00 CEST, Wednesday, September 7th through Friday, September 9th, 2022 (before the conference).

Course Description

C++ developers confront daunting responsibilities: to be familiar with the guarantees and idioms for the C++ language; know data structures and algorithms with intrinsic benefits and constraints explored by Computer Science; and understand the application domain in which the practicing professional is expected to make implementation decisions that manage complexity and resolve edge-cases to effectively solve real-world problems.

And yet, none of these directly address the meta-patterns and system-wide concerns defined by “architecture”, nor the reasoned tradeoffs of “design” that divide responsibilities and ultimately define subsystems and APIs. Often, these higher-order concerns are relegated to senior and experienced engineers charged with balancing business constraints with technical tradeoffs to establish a Theory of Operation for individual systems, and for product families.

This course is intended for intermediate and advanced C++ engineers with experience making architectural and design decisions, or who are evolving into roles that demand proficiency in system-level analysis and decision making. We will focus on Modern C++ and deeply explore successes and failures in projects and systems from a variety of industries. And, we will discover that some crossroads are universal, despite the unique concerns that may present pragmatic challenges and cause technical implications to be ranked differently based on the specific domain to which the solution is applied.

Prerequisites

Course participants should:

  • Have solid knowledge of C++ and familiarity with common C++ idioms and code patterns
  • Be able to deeply explore priorities and constraints for at least one industry domain
  • Be prepared to discuss, analyze, and reflect upon past project-level successes and failures (yours or those raised by other participants)
  • Be excited to share with and learn from real-world experts facing similar challenges in different domains, but which expose solutions and insight into your domain

Course Topics

Course objectives are for participants to: (1) Increase exposure to architecture and design through a disciplined survey of concerns; (2) Develop a sense for probable paths of exploration most likely to yield solutions for a given domain; and (3) Grow in understanding for the business and technical implications of employing a specific engineering approach.

The course will be a mixture of material review (60-70%), case studies (10-20%), and discussion (10-20%). Focus is on deep investigation into critical system constraints, and the implications of decisions. Participants are expected to be experienced C++ engineers (intermediate to advanced), familiar with common language idioms and programming paradigms; and will be encouraged to share experiences, provide insight, and influence the direction of those topics that will be explored more deeply. Bring your provocative architectural and design scenarios for consideration by the group! It is hoped that participants will challenge assertions and provide critical analysis as we attempt to rank concerns and delve into domain-specific scenarios.

Due to time constraints, not all topics can be explored equally; but the course will probe and examine most of the following:

  • Main Reasons for Failure in Modern C++ Systems
  • Common “Meta-Patterns” in Modern C++ Systems, and Why
  • Practical “Do-This” and “Don’t Do That” To Address Technical Challenges
  • Architecture vs. Design
  • Business Concerns vs. Technical Concerns
  • Managing Complexity at the Design-level, versus Implementation Level
  • Categories Of Design Concerns
  • Identifying and Leveraging Orthogonal Dependencies
  • “Top-Down” vs. “Bottoms-Up”
  • The role of the Type System, Symmetry, and Invariants to Simplify Design
  • Distinguishing between Abstraction and Artifact
  • The Purpose for Levels of Abstraction
  • Defining and Identifying “Well-Defined” Behavior
  • Data Flows and Object State Lifecycle
  • Impedance Mismatch in Design, and the role of Adapters
  • Coupling and Complexity in relation to Data Structures, Algorithms, and Side-Effects
  • Customization Points and the Role of ADL
  • Concurrency, Parallelism, and Threading Models
  • Identifying System Constraints and Throughput Limitations
  • The role of “Wide” and “Narrow” Contracts
  • Identifying Patterns, and Anti-Patterns
  • Diagramming and Mapping of Concerns
  • The role of “Reuse” versus “Application-specific”
  • Models for Development Feedback, and Customer Feedback
  • Constrained and Unconstrained Frameworks
  • Separating “Research” (i.e., “Feasibility”) from “Development”
  • When to embrace new/novel language features and idioms

Join us for two days of discussion among seasoned industry professionals that share their insights (of successes and failures) in Architecture and Design, where wisdom would otherwise be cultivated over decades through hard-fought undertakings.

Register Here

atters is a three-day online training course with programming exercises, taught by Andreas Fertig. It is offered online from 09:00 to 15:00 Aurora time (MDT), 11:00 to 17:00 EDT,  17:00 to 23:00 CEST, Wednesday, September 7th through Friday, September 9th, 2022 (before the conference).

Course Description

You will learn about various features of modern C++, how they work, where to use them, and how they translate to code. With that knowledge, you understand what each feature brings you and its costs regarding code size and performance.

You will learn how to write less code and get the same result. Less code helps you to save human resources when it comes to maintenance and debugging.

In times where a lot of applications are battery-powered, saving run-time is a great asset. As part of this class, you will learn to control the footprint and the speed of your binary.

You will learn all topics with exercises and live demos in C++ Insights and Compiler Explorer.

Prerequisites

Students are expected to have a basic knowledge of C++11.

Course Topics

  • Type-deduction surprises
  • Range-based for-loops how they work and what you have to watch out for
  • How noexcept helps you
  • How a std::initializer_list works
  • Scope control using if or switch with initialization
  • Safe and efficient constructors
    • In-class member initialization
    • Constructor inheritance and its trap
  • Under the hood of lambdas
    • Lambda captures and their implications
    • Generic as well as templated (a preview into C++20)
  • Structured bindings
  • Templates
    • Variadic templates
    • Recursive variadic templates vs. fold-expressions
    • Guidelines for efficient use of templates
  • Devirtualize your virtual functions with `final`
  • How a local non-trivial `static` variable works
  • The power of compile-time vs. run-time
    • How and when to apply constexpr
    • How to achieve constant initialization
    • Select only the data you need with constexpr if
  • Move-semantics
    • Move or copy?
    • The difference between std::move vs std::forward
    • Make your move-operations noexcept: noexcept, move, and STL containers
  • Know the costs of the abstraction: shared-/unique-ptr
  • Using the STL efficiently
    • Choosing the right container for your data
    • Best to use container methods for performance

Register Here

Charley Bay

Charley Bay has over three decades of experience using C++ in multiple regulated and high-performance fields focused on large-scale and distributed systems in performance-sensitive environments including time-sensitive processing of large data sets, performance visualization, real-time processing, low-latency, embedded, and system status and control. He is an internationally recognized technical speaker, is active in the Boost Community (including Review Manager of Boost.Outcome), and active in SG14 (Low Latency) for ISO C++ WG21. He has taught C++ and Computer Science in post-secondary environments for over a decade, and brings broad experience from multiple industry domains.

Charley speaking on a related content.