Course Description
Why Choose ExcelR for Modern Systems Programming Training
ExcelR's Modern Systems Programming training is designed for engineering teams working on high-performance, system-level, backend, embedded, and infrastructure applications.
- Practical coverage of advanced C++ debugging on Linux
- Hands-on learning across C++20/23, Rust, and WASM
- Real-world C++ to Rust migration and interoperability approach
- Focus on performance, memory safety, portability, and production readiness
- Lab-driven training with code, migration guides, templates, and checklists
Who Should Attend
This program is ideal for professionals involved in system-level development, backend engineering, infrastructure modernization, and legacy C++ application maintenance.
This training is relevant for:
- Senior C/C++ Developers
- Systems Engineers
- Backend Engineers
- Embedded Engineers
- Infrastructure Engineers
- Software Architects
- Engineering Teams working on modernization projects
Program Deliverables
Participants receive:
- Source code for all labs
- Debugging cheat sheets
- C++ to Rust migration guide
- WASM deployment templates
- Performance tuning checklist
Learning Outcomes
By the end of this training, participants will be able to:
- Debug production C++ systems efficiently
- Write modern C++ using C++20/23 features
- Build safe and high-performance systems using Rust
- Migrate selected C++ modules to Rust
- Use WebAssembly for portable and secure compute deployment
- Design integrated architectures using Modern C++, Rust, and WASM
Key Value for Organizations
This program enables teams to transition from legacy C++ systems to modern, safe, and portable architectures using:
Modern C++ + Rust + WebAssembly
Course Curriculum
Course Overview
Participants learn advanced debugging techniques for production-grade C++ applications on Linux environments such as RHEL 9.
Key Topics:
- Debugging optimized vs debug builds
- Symbol tables and DWARF information
- Stack and heap corruption patterns
- GDB mastery with breakpoints, watchpoints, and reverse debugging
- Crash and core dump analysis
- Memory debugging using Valgrind, ASAN, and UBSAN
- Performance debugging using perf and flame graphs
- Debugging 100% CPU usage scenarios
- Debug a crashing multithreaded service
- Identify memory leaks using ASAN
- Analyze a real core dump
This module focuses on modern C++ design, safer coding practices, and new language capabilities.
Key Topics:
- RAII revisited
- Smart pointers deep dive
- Move semantics and ownership
- C++20 concepts, ranges, and constexpr improvements
- Concurrency using threads, async, futures, and coroutines
- Modern libraries including fmt, spdlog, Boost, and googletest
- C++23 features such as std::expected, improved ranges, and deducing this
Hands-on Lab:
- Refactor legacy C++ code to modern C++
- Implement async workflow using coroutines
- Replace raw pointers with smart pointers
Participants build a strong foundation in Rust and understand how it improves memory safety without compromising performance.
Key Topics:
- Rust philosophy
- Memory safety without garbage collection
- Zero-cost abstractions
- Ownership, borrowing, and lifetimes
- Move semantics vs C++
- Structs, enums, pattern matching, and traits
- Error handling using Result and Option
- Rust concurrency with Send, Sync, Mutex, and channels
Hands-on Lab:
- Rewrite a C++ module in Rust
- Fix memory bugs using Rust’s ownership model
- Implement a thread-safe service
This module covers practical migration strategies and interoperability between C++ and Rust.
Key Topics:
- When not to migrate
- Incremental vs full rewrite strategies
- Risk management in migration projects
- Migration from legacy C++ to C++23
- C++ ↔ Rust interoperability using FFI
- Binding generation with bindgen and cbindgen
- Calling Rust from C++
- Unsafe Rust and memory layout compatibility
- Rust vs C++ performance comparison
- Real migration case study
Hands-on Lab:
- Wrap a C++ library in Rust
- Build a hybrid C++ + Rust system
- Replace unsafe C++ code with safe Rust
Participants explore WebAssembly as a portable execution layer and learn how C++, Rust, and WASM can work together in modern architectures.
Key Topics:
- WASM architecture and execution model
- Sandbox environment
- LLVM to WASM
- Emscripten for C++
- Rust to WASM using wasm-pack
- WASI and runtime environments
- Running WASM outside the browser
- Edge computing use cases
- WASM performance and security
- C++ - Rust - WASM pipeline
- Multi-language architecture
Final Hands-on Project:
Build an integrated system with:
- A legacy C++ module
- A Rust module for safe logic
- A WASM module for portable execution
- Full integration into one working system
Contact Our Team of Experts
