+49 (0) 30 5201 4923
info@orb-experts.com
Learn how to design, develop and test modern distributed C++ applications using Qt 6, ZeroMQ and Protocol Buffers. This five-day course combines current C++ development practices with graphical interface development, asynchronous communication, efficient data serialisation, automated testing and containerised Linux workflows. Participants progressively develop a distributed application consisting of a Qt-based user interface and communicating backend components. They learn how to structure maintainable C++ code, manage resources safely, coordinate concurrent tasks and exchange structured messages between processes and services. The course is designed to remain broadly independent of particular minor software versions and Linux distributions. Examples can be delivered using C++17 or C++20 on Ubuntu, Rocky Linux or another supported Linux distribution.
You will learn how to build maintainable C++ applications that combine graphical interfaces, concurrent processing and distributed communication. You will use CMake to manage projects and dependencies, develop interfaces with Qt Widgets, gain an introduction to Qt Quick and QML, implement ZeroMQ messaging patterns and define efficient message contracts with Protocol Buffers.
• Apply modern C++17 or C++20 language and resource-management practices
• Structure applications and libraries with target-based CMake
• Develop desktop interfaces with Qt Widgets
• Understand the fundamentals of Qt Quick and QML
• Use signals, slots, event loops and Qt’s object model effectively
• Implement safe concurrency and asynchronous processing
• Design distributed communication with ZeroMQ messaging patterns
• Define, generate and evolve Protocol Buffers message contracts
• Create automated unit, component and integration tests
• Develop, build and troubleshoot applications in containerised Linux environments
• Practical knowledge of C++ fundamentals
• Familiarity with classes, inheritance, functions and standard library containers
• Basic understanding of Linux and command-line tools
• General knowledge of networking and distributed applications is beneficial
• Previous experience with Qt, ZeroMQ or Protocol Buffers is not required
*We customize the course outline and content to your specific needs and relevant use cases.
Day 1: Modern C++ and the development environment
Module 1: Distributed C++ application architecture
• Characteristics of desktop, client-server and distributed applications
• Separating presentation, domain, communication and infrastructure components
• Understanding processes, threads, services and message boundaries
• Establishing a maintainable project and repository structure
Module 2: Modern C++17 and C++20 practices
• Applying automatic resource management through RAII
• Using smart pointers and clear ownership models
• Working with move semantics, lambdas and modern standard library types
• Applying optional values, variants, ranges and other selected language features
Module 3: Building projects with CMake
• Creating targets for applications, libraries and tests
• Managing include paths, compile features and linked dependencies
• Organising multi-directory projects with reusable CMake configuration
• Generating, installing and packaging application components
Module 4: Linux development and toolchain configuration
• Configuring compilers, build tools, Qt and external dependencies
• Working with GCC or Clang and distribution-independent project settings
• Using build presets and separate development and release configurations
• Preparing reproducible environments for Ubuntu, Rocky Linux or another supported distribution
Day 2: Application development with Qt 6
Module 5: Qt architecture and core concepts
• Understanding QObject, parent-child ownership and meta-object features
• Connecting components through signals and slots
• Working with the event loop, events and queued operations
• Using core Qt types, containers, timers and application services
Module 6: Developing interfaces with Qt Widgets
• Creating windows, dialogs, controls and layouts
• Designing interfaces with Qt Designer and generated forms
• Managing actions, menus, toolbars and user interaction
• Separating interface code from application logic
Module 7: Model/View application design
• Understanding models, views, delegates and selections
• Using standard models for lists, tables and trees
• Developing custom models for application data
• Updating interfaces efficiently when underlying data changes
Module 8: Custom interfaces and application behaviour
• Creating reusable and customised widgets
• Handling painting, geometry and input events
• Managing settings, resources, translations and application state
• Designing responsive error handling and user feedback
Day 3: Qt Quick, concurrency and automated testing
Module 9: Introduction to Qt Quick and QML
• Understanding declarative interface development
• Creating components, properties, bindings and layouts in QML
• Working with Qt Quick Controls and visual states
• Comparing appropriate use cases for Qt Widgets and Qt Quick
Module 10: Connecting C++ and QML
• Exposing C++ objects and data models to QML
• Invoking C++ functionality from declarative interfaces
• Communicating through properties, signals and methods
• Maintaining a clear boundary between interface and application logic
Module 11: Modern concurrency and asynchronous processing
• Comparing threads, tasks, futures and event-driven operations
• Managing thread ownership and object affinity in Qt
• Exchanging data safely between worker and interface components
• Avoiding races, deadlocks, blocked event loops and unsafe object access
Module 12: Automated testing and debugging
• Creating unit and component tests for C++ and Qt code
• Integrating Qt Test, CTest and application test targets
• Testing signals, asynchronous behaviour and user-interface components
• Using debuggers, sanitising tools, logging and diagnostic information
Day 4: Distributed messaging with ZeroMQ
Module 13: ZeroMQ architecture and communication fundamentals
• Understanding contexts, sockets, messages and transports
• Communicating within a process, between processes and over TCP
• Comparing ZeroMQ sockets with conventional network sockets
• Managing connection establishment, queues and asynchronous delivery
Module 14: Core messaging patterns
• Implementing request-reply communication
• Distributing information with publish-subscribe
• Dividing work with push-pull pipelines
• Selecting patterns according to communication and scaling requirements
Module 15: Advanced routing and reliability
• Using dealer-router patterns for asynchronous request processing
• Working with multipart messages and message envelopes
• Managing timeouts, retries, reconnection and controlled shutdown
• Understanding queue limits, backpressure and message-loss conditions
Module 16: Integrating ZeroMQ with Qt applications
• Coordinating ZeroMQ processing with Qt event-driven applications
• Isolating communication work from the user-interface thread
• Delivering received data through thread-safe signals and slots
• Designing communication services with clear lifecycle and ownership rules
Day 5: Protocol Buffers, containers and integrated development
Module 17: Protocol Buffers for C++ applications
• Defining structured messages in protocol definition files
• Generating and integrating C++ code through CMake
• Serialising and deserialising messages
• Using enumerations, repeated fields, maps and alternative field groups
Module 18: Message contracts and schema evolution
• Designing stable messages for distributed components
• Managing field numbers, defaults and optional information
• Evolving schemas while preserving compatibility
• Combining Protocol Buffers messages with ZeroMQ envelopes and routing information
Module 19: Containerised Linux development and integration testing
• Creating reproducible build and runtime containers
• Managing compilers, Qt libraries and application dependencies in container images
• Starting communicating application components in an isolated environment
• Testing process boundaries, message contracts and failure scenarios
Module 20: End-to-end distributed application
• Combining a Qt interface with concurrent backend processing
• Exchanging Protocol Buffers messages through ZeroMQ
• Applying automated testing, logging and controlled error handling
• Building, running and troubleshooting the complete application in a containerised Linux environment
Hands-on learning with expert instructors at your location for organizations.
Master new skills guided by experienced instructors from anywhere.
