Edge Programming with C/C++ and Rust

Welcome

Welcome to Edge Programming in C/C++ and Rust . This textbook explores the application of modern programming paradigms to edge computing, bridging the gap between high-level software engineering and low-level hardware interactions.

The Rise of AIoT

As the Internet of Things evolves into the Artificial Intelligence of Things (AIoT), the demands placed on edge devices have never been higher. Developers must now balance complex logic, machine learning models, and real-time responsiveness against the strict memory, power, and thermal constraints of embedded systems.

This book provides a comprehensive, hands-on guide to mastering these challenges, focusing on the most critical languages in the embedded space: C/C++ and Rust.

What You Will Learn

This textbook is designed to take you from foundational embedded concepts to advanced, memory-safe edge architectures. Key areas of focus include:

• The Foundations of C/C++ at the Edge: Understanding how traditional Object-Oriented Programming (OOP), the C subset of C++, and standard libraries are applied to resource-constrained environments.
• Modern Tooling: Utilising Git, GitLab, and automated workflows to bring modern software engineering practices to embedded development.
• The Transition to Rust: A deep dive into modernising edge development. You will learn how Rust’s ownership model, strict compiler, and zero-cost abstractions provide memory safety and concurrency without sacrificing C-level performance.
• Advanced Edge Capabilities: Extending beyond basic sensors into GUI programming, network programming, and robust concurrency models for edge nodes.
• Practical Embedded Rust: Applying Rust’s safety guarantees directly to hardware, specifically targeting the ESP32 platform for real-world embedded applications, including code and resource management.

Target Hardware: The ESP32

Practical application of code to popular microcontrollers is a core focus of this module. We will target the ESP32 ecosystem, covering GPIO, sensors, communication protocols, and resource management.

How to Use This Book

Use the sidebar navigation to progress through the chapters sequentially, or jump directly to specific topics of interest. The material is structured to provide both theoretical grounding and practical, reproducible coding examples.

Reading

Please note there are Dark Mode, Light Mode and Auto options on the top right hand side of this page.

Book Chapters

• Chapter 1: Introduction
  • 1.1 Introduction to Object-oriented Programming (OOP)
  • 1.2 OOP by Example
• Chapter 2: Edge Programming
  • 2.1 Edge Programming Introduction
• Chapter 3: The C of C++
  • 3.1 C++ Introduction and Types
  • 3.2 C++ Functions and Flow
  • 3.3 C++ Exceptions and Operators
  • Tutorial: C++ Part 1
  • Tutorial: C++ Part 2
  • Tutorial: C++ Part 3
• Chapter 4: GitLab
  • 4.1 Git and GitLab
  • 4.2 Git and GitLab Continued
  • Virtual Lab: Git Flow
  • Virtual Lab: Git Branch
• Chapter 5: C++ with Classes
  • Tutorial: C++ with Classes
  • Tutorial: C++ with Classes 2
  • Virtual Lab: Objects on the Stack
  • Virtual Lab: Class Objects on the Heap
  • Virtual Lab: Modern C++ Smart Pointers
• Chapter 6: C++ Standard Libraries
  • Tutorial: C++ STL
• Chapter 7: Introduction to Rust
  • 7.1 The Case for Rust
  • 7.2 Tooling and Workflow
  • 7.3 Memory Management: Ownership
  • 7.4 Borrowing and Lifetimes
  • 7.5 Language Fundamentals
  • 7.6 Custom Types and Pattern Matching
  • 7.7 Rust’s Approach to OOP for Edge Programming
  • Tutorial: Rust Part 1
  • Virtual Lab: Rust Memory
• Chapter 8: More Rust Fundamentals
  • Tutorial: Rust Part 2
  • Virtual Lab: Rust Enums and Closures
• Chapter 9: GUI Programming
  • 9.1 GUI Programming for Edge Systems
  • Tutorial: Rust GUIs
• Chapter 10: Concurrency
  • Tutorial: Rust Concurrency
• Chapter 11: Network Programming (incomplete)
• Chapter 12: Code and Resource Management
• Chapter 13: Rust on ESP32