Every day:  READ (20 min) → CODE (40–60 min) → PUZZLE (10–20 min)
Every week: One mini-project that ships a working artifact

learn/cpp-advanced/
├── STUDY-PLAN.md                          ← YOU ARE HERE
├── README.md                              ← Navigation & content summary
├── build_all.sh                           ← Build all modules
├── 01-move-semantics-value-categories/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 02-error-handling-memory-model/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 03-rt-linux-programming/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 04-safety-critical-patterns/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 05-build-test-tooling/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 06-ipc-serialization/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 07-ub-advanced-patterns/
│   ├── notes.md
│   ├── exercises/
│   └── puzzles/
├── 08-capstone-flight-software/
│   ├── include/flight_sw/   (8 headers)
│   ├── src/main.cpp
│   └── tests/test_main.cpp
├── 09-hardware-lessons/
│   └── exercises/  (hw01–hw05)
├── 10-safety-lessons/
│   └── exercises/  (sf01–sf05)
├── 11-cpp20-coroutines/           ← NEW: requires GCC 10+
│   ├── notes.md
│   ├── exercises/ (ex01–ex04)
│   └── puzzles/
├── 12-cpp20-ranges/               ← NEW: requires GCC 10+
│   ├── notes.md
│   ├── exercises/ (ex01–ex05)
│   └── puzzles/
├── 13-cpp20-format/               ← NEW: requires GCC 13+
│   ├── notes.md
│   ├── exercises/ (ex01–ex04)
│   └── puzzles/
├── 14-exception-safety/           ← NEW: GCC 9+ compatible
│   ├── notes.md
│   ├── exercises/ (ex01–ex05)
│   └── puzzles/
├── 15-pmr-allocators/             ← NEW: GCC 9+ compatible
│   ├── notes.md
│   ├── exercises/ (ex01–ex05)
│   └── puzzles/
├── 16-sanitizer-workshop/         ← NEW: GCC 9+ compatible
│   ├── notes.md
│   ├── exercises/ (ex01–ex05, multi-sanitizer builds)
│   └── puzzles/
└── 17-sdv-mission-critical/       ← NEW: C++20, optional pthread
    ├── notes.md
    ├── exercises/ (ex01–ex08: E2E, degradation, cyclic exec,
    │   triple buffer, DTC, OTA, SecOC, watchdog)
    └── puzzles/
├── 18-coding-standards-tracing/   ← NEW: profiling, LTTng-style tracing
│   ├── notes.md
│   ├── exercises/ (ex01–ex08: standards, static analysis, cache,
│   │   callgraph, syscall, tracepoints, watchpoints, flamegraph)
│   └── puzzles/ (false sharing, invisible alloc, lying benchmark)

// Exercise 1: Predict the value category of each expression
int x = 42;
int& ref = x;
int&& rref = std::move(x);
// What is the value category of: x? ref? rref? std::move(x)? 42? x+1?

// Exercise 2: Write a function that accepts ONLY rvalues
template<typename T>
void sink(T&& val) requires std::is_rvalue_reference_v<T&&>;

// Exercise 3: Demonstrate that a named rvalue reference IS an lvalue
void prove_named_rref_is_lvalue();

// What does this print? 99% get it wrong.
#include <iostream>
void f(int& x)  { std::cout << "lvalue\n"; }
void f(int&& x) { std::cout << "rvalue\n"; }

template<typename T>
void g(T&& x) { f(x); }  // What gets called?

int main() {
    int a = 1;
    g(a);        // ?
    g(1);        // ? — THIS ONE surprises people
}

// Exercise 1: Implement a class with all 5 special members
// Rule of 5 — make it own a raw resource (fd, mmap, etc.)
class MappedFile {
    int fd_ = -1;
    void* addr_ = nullptr;
    size_t size_ = 0;
public:
    // Implement: ctor, dtor, copy ctor, copy assign, move ctor, move assign
    // The move ctor must leave source in a valid but empty state
};

// Exercise 2: Benchmark copy vs move of std::vector<std::string> with 1M elements
// Use std::chrono::steady_clock — expect 1000x+ difference

// Exercise 3: Show a case where RVO (Return Value Optimization) makes
// move unnecessary — and a case where it can't apply

// Does this compile? If yes, what happens?
std::vector<std::unique_ptr<int>> v;
v.push_back(std::make_unique<int>(42));
auto v2 = v;  // ???

// Exercise 1: Write a factory function that perfect-forwards to any constructor
template<typename T, typename... Args>
std::unique_ptr<T> make(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// Exercise 2: Write an emplace_back equivalent for a fixed-size ring buffer
template<typename T, size_t N>
class RingBuffer {
    std::array<std::aligned_storage_t<sizeof(T), alignof(T)>, N> storage_;
    size_t head_ = 0, tail_ = 0, count_ = 0;
public:
    template<typename... Args>
    bool try_emplace(Args&&... args);  // construct in-place, return false if full
};

// Exercise 3: Show the difference between T&& and auto&& in a for loop
// Why can range-for with auto&& bind to temporaries AND lvalues?

// What types are deduced? Most people get at least one wrong.
template<typename T> void f(T&& x);

int a = 1;
const int b = 2;
int& c = a;

f(a);       // T = ?  x type = ?
f(b);       // T = ?  x type = ?
f(c);       // T = ?  x type = ?
f(42);      // T = ?  x type = ?
f(std::move(a)); // T = ?  x type = ?

// Exercise 1: CRC32 lookup table at compile time
constexpr std::array<uint32_t, 256> make_crc32_table() {
    // Implement the full CRC32 table generation at compile time
    // Verify with static_assert that table[0] == 0 and table[1] == correct value
}

// Exercise 2: Compile-time string hash for switch statements
constexpr uint64_t fnv1a(std::string_view sv) {
    // Implement FNV-1a hash
}
// Use it: switch(fnv1a(input)) { case fnv1a("start"): ... }

// Exercise 3: consteval vs constexpr — show a case where consteval
// catches a bug that constexpr wouldn't
consteval int safe_divide(int a, int b) {
    if (b == 0) throw "division by zero"; // compile error!
    return a / b;
}

// Does this compile? Why or why not?
constexpr int f(int n) {
    if (n <= 1) return 1;
    return n * f(n - 1);
}
constexpr int a = f(5);    // ?
int runtime_val = 10;
int b = f(runtime_val);    // ?
consteval int g(int n) { return f(n); }
int c = g(runtime_val);    // ?

// Exercise 1: Define a Sensor concept for your robot work
template<typename T>
concept Sensor = requires(T t) {
    { t.read() } -> std::convertible_to<double>;
    { t.is_valid() } -> std::same_as<bool>;
    { T::sample_rate_hz } -> std::convertible_to<unsigned>;
};

// Exercise 2: Write a constrained template that only accepts trivially copyable types
// (important for shared memory IPC and DMA buffers)
template<typename T>
concept DmaCompatible = std::is_trivially_copyable_v<T>
                     && (sizeof(T) % alignof(std::max_align_t) == 0);

// Exercise 3: Rewrite this SFINAE horror using concepts
template<typename T, typename = std::enable_if_t<
    std::is_arithmetic_v<T> && !std::is_same_v<T, bool>>>
T clamp_to_range(T val, T lo, T hi);
// → Clean concept version

// Overload resolution with concepts: which function gets called?
template<typename T> concept Integral = std::is_integral_v<T>;
template<typename T> concept SignedIntegral = Integral<T> && std::is_signed_v<T>;

void f(Integral auto x)       { std::cout << "1\n"; }
void f(SignedIntegral auto x)  { std::cout << "2\n"; }

f(42);   // ? — concept subsumption decides
f(42u);  // ?

// Define messages at compile time
struct ImuMessage {
    static constexpr uint32_t id = fnv1a("ImuMessage");
    static constexpr size_t max_size = 48;
    float accel[3];
    float gyro[3];
    uint64_t timestamp_ns;
};

// Compile-time dispatch table
template<typename... Messages>
class MessageRegistry {
    // at compile time: verify no ID collisions
    // at compile time: compute max message size
    // at runtime: O(1) dispatch by ID using switch or array lookup
};

// Exercise 1: Implement Expected<T, E> (like std::expected from C++23)
template<typename T, typename E>
class Expected {
    union { T value_; E error_; };
    bool has_value_;
public:
    // Implement: constructors, value(), error(), has_value()
    // Implement: and_then(), or_else(), transform() (monadic operations)
};

// Exercise 2: Error propagation macro (like Rust's ?)
#define TRY(expr) \
    ({ auto&& _r = (expr); \
       if (!_r.has_value()) return unexpected(_r.error()); \
       std::move(_r).value(); })

// Exercise 3: Show timing difference — exception throw vs error code
// Throw 10,000 exceptions vs return 10,000 error codes — measure wall time

// This function is compiled with -fno-exceptions. What happens?
std::vector<int> v;
v.at(999);  // at() uses exceptions for out-of-bounds
// Answer: std::terminate() is called. Not a nice crash.

// How would you make operator[] safe without exceptions?

// Exercise 1: Model robot states as a variant
using RobotState = std::variant<
    struct Idle {},
    struct Navigating { double target_x, target_y; },
    struct Charging { int battery_percent; },
    struct Error { int code; std::string_view message; }
>;

// Write a state machine using std::visit
void handle_state(RobotState& state, Event event);

// Exercise 2: Implement a command dispatch system
using Command = std::variant<MoveCmd, StopCmd, ChargeCmd, DiagnosticCmd>;
// Process commands without dynamic dispatch or exceptions

// Exercise 3: Measure sizeof(std::variant<A,B,C>) — understand the layout
// Compare with a manual tagged union

// What does std::visit do with this? Does it compile?
std::variant<int, double, std::string> v = "hello";
std::visit([](auto&& arg) {
    arg += arg;  // ??? — does this work for all types?
}, v);

// Exercise 1: Demonstrate a data race with TSan (Thread Sanitizer)
// Compile with: g++ -fsanitize=thread -g
int shared_counter = 0;
void thread_func() { for (int i = 0; i < 100000; ++i) ++shared_counter; }
// Run 2 threads — observe TSan report

// Exercise 2: Fix it three ways:
// (a) std::mutex
// (b) std::atomic<int> with seq_cst
// (c) std::atomic<int> with relaxed + load/store
// Benchmark all three

// Exercise 3: Show why volatile fails as synchronization
volatile bool ready = false;
volatile int data = 0;
// Thread 1: data = 42; ready = true;
// Thread 2: while (!ready); assert(data == 42);
// This CAN fail on ARM/POWER. Show why with memory model reasoning.

// Classic: is this code correct on x86? On ARM?
std::atomic<bool> x{false}, y{false};
int r1, r2;

// Thread 1:              Thread 2:
x.store(true, relaxed);   y.store(true, relaxed);
r1 = y.load(relaxed);     r2 = x.load(relaxed);

// Can r1 == 0 && r2 == 0?
// On x86? On ARM? According to the standard?

// Exercise 1: Implement a simple spinlock using acquire/release
class Spinlock {
    std::atomic<bool> locked_{false};
public:
    void lock() {
        while (locked_.exchange(true, std::memory_order_acquire))
            ; // spin
    }
    void unlock() {
        locked_.store(false, std::memory_order_release);
    }
};

// Exercise 2: Producer-consumer with ONE atomic flag (no mutex)
std::atomic<bool> ready{false};
int payload = 0;
// Producer: payload = 42; ready.store(true, release);
// Consumer: while (!ready.load(acquire)); use(payload);
// Prove this is correct. Then prove the relaxed version is broken.

// Exercise 3: Implement a SeqLock (sequence lock) for read-heavy data
// Used in Linux kernel for clock reads
template<typename T>
class SeqLock {
    std::atomic<uint32_t> seq_{0};
    T data_;
public:
    void write(const T& val);  // increment seq (odd = writing), write, increment (even = done)
    T read() const;            // read seq, read data, read seq again, retry if changed
};

// The "IRIW" problem — can two readers disagree about store order?
// Thread 1: x.store(1, release);
// Thread 2: y.store(1, release);
// Thread 3: r1=x.load(acquire); r2=y.load(acquire);
// Thread 4: r3=y.load(acquire); r4=x.load(acquire);
// Can r1==1,r2==0 AND r3==1,r4==0 simultaneously?
// Hint: yes with acquire/release, no with seq_cst. Why?

// Exercise 1: Lock-free stack (Treiber stack)
template<typename T>
class LockFreeStack {
    struct Node { T data; Node* next; };
    std::atomic<Node*> head_{nullptr};
public:
    void push(T val);  // CAS loop on head
    std::optional<T> pop();  // CAS loop, watch for ABA!
};

// Exercise 2: Atomic increment with CAS (don't use fetch_add)
int atomic_increment(std::atomic<int>& val) {
    int old = val.load(std::memory_order_relaxed);
    while (!val.compare_exchange_weak(old, old + 1,
            std::memory_order_relaxed)) {}
    return old;
}
// Why does weak work here? When would you need strong?

// Exercise 3: Implement an atomic max operation
template<typename T>
T atomic_fetch_max(std::atomic<T>& a, T val) {
    // CAS loop: update only if val > current
}

// The ABA problem in action. What goes wrong?
// Stack has: A -> B -> C
// Thread 1: pop() reads head=A, next=B
//           (gets preempted here)
// Thread 2: pop() A, pop() B, push() A back
//           Stack is now: A -> C
// Thread 1: resumes, CAS(head, A, B) succeeds! (head==A, set to B)
//           But B was freed! Use-after-free.
// How do you fix this? (hazard pointers, epoch-based reclamation, tagged pointers)

template<typename T, size_t Capacity>
class SPSCQueue {
    static_assert((Capacity & (Capacity - 1)) == 0, "must be power of 2");
    std::array<T, Capacity> buffer_;
    alignas(64) std::atomic<size_t> write_pos_{0};  // cache line isolation
    alignas(64) std::atomic<size_t> read_pos_{0};
public:
    bool try_push(const T& val);
    bool try_pop(T& val);
    size_t size() const;
};

// Exercise 1: Measure scheduling latency
// Create a thread, set SCHED_FIFO priority 90, measure wakeup jitter
#include <sched.h>
#include <time.h>

void measure_latency() {
    struct sched_param sp;
    sp.sched_priority = 90;
    sched_setscheduler(0, SCHED_FIFO, &sp);
    mlockall(MCL_CURRENT | MCL_FUTURE);

    struct timespec next;
    clock_gettime(CLOCK_MONOTONIC, &next);

    std::vector<int64_t> latencies;
    for (int i = 0; i < 10000; ++i) {
        next.tv_nsec += 1000000; // 1ms period
        // normalize
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, nullptr);
        struct timespec now;
        clock_gettime(CLOCK_MONOTONIC, &now);
        int64_t lat_ns = (now.tv_sec - next.tv_sec) * 1e9 + (now.tv_nsec - next.tv_nsec);
        latencies.push_back(lat_ns);
    }
    // Print: min, max, avg, p99, p99.9
}

// Exercise 2: Compare SCHED_OTHER vs SCHED_FIFO latency histograms
// Run the above with both schedulers, plot results

// Exercise 3: Run `stress -c $(nproc)` in background
// See how SCHED_OTHER degrades but SCHED_FIFO holds

// Exercise 1: Demonstrate priority inversion
// Create 3 threads: Low (holds mutex), Medium (CPU hog), High (wants mutex)
// Show that High is blocked by Medium — classic Mars Pathfinder bug!

// Exercise 2: Fix with a priority-inheritance mutex
pthread_mutexattr_t attr;
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);

// Exercise 3: Build a "RT-safe logger" that writes from a non-RT thread
// RT thread pushes log entries into SPSC queue (from Week 2!)
// Non-RT thread drains queue and writes to file
class RTLogger {
    SPSCQueue<LogEntry, 4096> queue_;
    std::thread writer_thread_;
public:
    void log(LogEntry entry);  // called from RT thread — zero allocation!
    void drain();              // called from writer thread — can do I/O
};

// This RT thread "works fine in testing." What's the time bomb?
void rt_loop() {
    while (running) {
        auto data = sensor.read();
        auto result = controller.compute(data);
        actuator.write(result);

        std::string log_msg = "pos=" + std::to_string(result.pos); // 💣
        logger.info(log_msg);                                       // 💣💣
    }
}
// Answer: std::string + to_string = malloc in the hot path
// logger.info = likely locks a mutex + does I/O

// Exercise 1: Pin your RT thread to a specific CPU core
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(3, &cpuset);  // pin to core 3
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);

// Exercise 2: Run cyclictest, interpret the results
// sudo cyclictest -t1 -p 90 -i 1000 -l 10000 --mlockall
// Parse: T: 0 Min: X Act: Y Avg: Z Max: W

// Exercise 3: Build a complete "RT thread launcher" utility
struct RTThreadConfig {
    int priority = 90;                    // 1-99
    int policy = SCHED_FIFO;
    int cpu_affinity = -1;               // -1 = no affinity
    bool lock_memory = true;
    size_t stack_size = 8 * 1024 * 1024;  // pre-fault stack
};

std::thread launch_rt_thread(RTThreadConfig config, std::function<void()> fn);
// Must: set scheduler, set affinity, mlockall, pre-fault stack

// Exercise 1: Implement a 1kHz cyclic executive
class CyclicExecutive {
    using Task = std::function<void()>;
    struct ScheduledTask {
        Task fn;
        uint32_t period_ms;     // run every N ms
        uint32_t offset_ms;     // phase offset
    };
    std::vector<ScheduledTask> tasks_;
    uint32_t major_frame_ms_;
    std::atomic<bool> running_{true};

public:
    void add_task(Task fn, uint32_t period_ms, uint32_t offset_ms = 0);
    void run();  // the main RT loop
    void stop() { running_ = false; }

    // Overrun detection: if a minor frame takes longer than its budget
    struct Stats {
        uint64_t total_frames = 0;
        uint64_t overruns = 0;
        int64_t max_latency_ns = 0;
        int64_t max_execution_ns = 0;
    };
    Stats get_stats() const;
};

// Exercise 2: Schedule these tasks in a 10ms major frame:
// - IMU read:      1kHz (every 1ms)
// - Controller:    500Hz (every 2ms)
// - Odometry pub:  100Hz (every 10ms)
// - Heartbeat:     10Hz (every 100ms)

// Exercise 3: Add overrun detection and graceful degradation
// If a frame overruns, skip the lowest-priority task next frame

// Exercise 1: Implement a fixed-size pool allocator
template<typename T, size_t N>
class PoolAllocator {
    union Slot { T obj; Slot* next; };
    std::array<Slot, N> pool_;
    Slot* free_list_ = nullptr;
public:
    PoolAllocator();
    T* allocate();    // O(1), deterministic
    void deallocate(T* p);  // O(1), deterministic
};

// Exercise 2: Use std::pmr with a monotonic buffer
std::array<std::byte, 4096> buffer;
std::pmr::monotonic_buffer_resource mbr(buffer.data(), buffer.size());
std::pmr::vector<int> v(&mbr);
// Fill vector — no heap allocation until buffer is exhausted
// What happens when it IS exhausted? (depends on upstream resource)

// Exercise 3: Benchmark: std::vector<int> vs pmr::vector<int> with pool
// Insert 1000 elements, measure allocation time
// Expected: pmr ~5-10x faster for small allocations

// This look fine but has a subtle bug. What is it?
std::array<std::byte, 256> buf;
std::pmr::monotonic_buffer_resource mbr(buf.data(), buf.size());
std::pmr::string s("hello", &mbr);
auto s2 = s;  // What allocator does s2 use? 💣
// Answer: s2 uses the DEFAULT allocator (global new/delete), not mbr!
// pmr containers copy the allocator only if you explicitly pass it

┌─────────────────────────────────────────────┐
│ RT Thread (SCHED_FIFO, pinned to core 3)    │
│                                              │
│  1kHz: read_sensor() → controller.compute() │
│  100Hz: publish_telemetry() → SPSC queue    │
│  10Hz:  watchdog_kick()                     │
│                                              │
│  Overrun detection + stats                  │
└──────────────┬──────────────────────────────┘
               │ SPSC Queue (lock-free)
┌──────────────▼──────────────────────────────┐
│ Non-RT Thread                               │
│  Drain telemetry → log to file / print      │
│  Health monitoring                          │
└─────────────────────────────────────────────┘

// Exercise 1: Rewrite this function to comply with ALL 10 rules
// Original (violates rules 1, 3, 4, 5, 7):
std::vector<int> flatten(const std::vector<std::vector<int>>& nested) {
    std::vector<int> result;
    for (auto& inner : nested)
        for (auto& x : inner)
            result.push_back(x);
    return result;
}
// JPL version: fixed output buffer, assertions, bounded loops, return status

// Exercise 2: Write a bounded loop version of binary search
// Must have a provable upper bound on iterations (log2(N) + 1)

// Exercise 3: Add contracts (assert-based) to your SPSC queue from Week 2
// Pre: !is_full() for push, !is_empty() for pop
// Post: size increased/decreased by 1
// Invariant: write_pos - read_pos == size (modular)

// Toyota unintended acceleration (2009): single bit flip in RAM
// corrupted the task stack, overwriting the throttle variable.
// 243 violations of Power of 10 were found in their firmware.
// Question: Which rule(s) would have prevented the stack overflow?
// Answer: Rule 1 (no recursion) + Rule 4 (small functions) = bounded stack use

// Exercise 1: Implement a production-grade assertion macro
// Must: log file:line, log the expression, allow custom recovery
#define RT_ASSERT(cond, recovery_action) \
    do { \
        if (!(cond)) [[unlikely]] { \
            rt_assert_handler(__FILE__, __LINE__, #cond); \
            recovery_action; \
        } \
    } while (0)

// Exercise 2: Class invariant checking
class PIDController {
    double kp_, ki_, kd_;
    double integral_ = 0.0;
    double prev_error_ = 0.0;
    static constexpr double MAX_INTEGRAL = 1000.0;

    void check_invariant() const {
        RT_ASSERT(kp_ >= 0.0, return);
        RT_ASSERT(ki_ >= 0.0, return);
        RT_ASSERT(std::isfinite(integral_), integral_ = 0.0);
        RT_ASSERT(std::abs(integral_) <= MAX_INTEGRAL, integral_ = 0.0);
    }
public:
    double compute(double error, double dt) {
        check_invariant();  // pre
        // ... computation ...
        check_invariant();  // post
        return output;
    }
};

// Exercise 3: Saturating arithmetic — never overflow, always clamp
template<typename T>
constexpr T sat_add(T a, T b) {
    // If a + b would overflow, return max; if underflow, return min
    // Must work at compile time (constexpr)
    // Must have assertions for NaN if floating point
}

# Exercise 1: Run clang-tidy on your SPSC queue, fix ALL findings
clang-tidy spsc_queue.hpp -checks='*' -- -std=c++20

# Exercise 2: Compile with ALL sanitizers, one at a time
g++ -fsanitize=address -g code.cpp         # ASan: buffer overflows, use-after-free
g++ -fsanitize=undefined -g code.cpp       # UBSan: signed overflow, null deref
g++ -fsanitize=thread -g code.cpp          # TSan: data races
g++ -fsanitize=memory -g code.cpp          # MSan: uninitialized reads (clang only)

# Exercise 3: Write a .clang-tidy config for safety-critical code

# .clang-tidy for safety-critical C++
Checks: >
  bugprone-*,
  cert-*,
  cppcoreguidelines-*,
  -cppcoreguidelines-avoid-magic-numbers,
  misc-*,
  performance-*,
  readability-*,
  -readability-magic-numbers
WarningsAsErrors: >
  bugprone-use-after-move,
  bugprone-dangling-handle,
  cert-err58-cpp,
  cppcoreguidelines-pro-type-reinterpret-cast

// UBSan catches this. What's the UB?
int x = INT_MAX;
int y = x + 1;  // signed overflow = UB!
// GCC may optimize away if(y < x) because "signed overflow can't happen"
// This is how the Linux kernel null-pointer check was removed (Day 10 reading)

// Exercise 1: Implement a software watchdog timer
class Watchdog {
    std::chrono::milliseconds timeout_;
    std::chrono::steady_clock::time_point last_kick_;
    std::function<void()> on_timeout_;
    std::thread monitor_thread_;
    std::atomic<bool> running_{true};
public:
    Watchdog(std::chrono::milliseconds timeout, std::function<void()> on_timeout);
    void kick();  // called from RT thread — must be fast!
    // Monitor thread periodically checks if last_kick is too old
};

// Exercise 2: Implement a heartbeat publisher
// Every 100ms, publish a heartbeat containing:
// - monotonic timestamp
// - sequence number
// - mode (nominal, degraded, error)
// - worst-case latency since last heartbeat
struct Heartbeat {
    uint64_t timestamp_ns;
    uint32_t sequence;
    uint8_t mode;
    int64_t max_latency_ns;
};

// Exercise 3: Cross-check pattern
// Two independent implementations of atan2, compare results
// If they disagree by > epsilon, flag an error
double safe_atan2(double y, double x) {
    double r1 = std::atan2(y, x);
    double r2 = my_cordic_atan2(y, x);  // your own implementation
    RT_ASSERT(std::abs(r1 - r2) < 1e-6, return r1);
    return r1;
}

# Exercise 1: Create a proper CMake project structure
cmake_minimum_required(VERSION 3.20)
project(rt_framework VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# Library target with PUBLIC/PRIVATE dependencies
add_library(rt_core
    src/spsc_queue.cpp
    src/cyclic_executive.cpp
    src/pool_allocator.cpp
)
target_include_directories(rt_core PUBLIC include)
target_compile_options(rt_core PRIVATE
    -Wall -Wextra -Wpedantic -Werror -Wconversion
)

# Sanitizer presets
option(ENABLE_ASAN "Enable AddressSanitizer" OFF)
if(ENABLE_ASAN)
    target_compile_options(rt_core PUBLIC -fsanitize=address -fno-omit-frame-pointer)
    target_link_options(rt_core PUBLIC -fsanitize=address)
endif()

# Exercise 2: Cross-compile preset for ARM (like your Jetson)
# CMakePresets.json

# Exercise 3: Install rules + package config
install(TARGETS rt_core EXPORT rt_framework-targets)
install(EXPORT rt_framework-targets DESTINATION lib/cmake/rt_framework)

// Exercise 1: Test your SPSC queue with GTest
TEST(SPSCQueue, PushPopBasic) {
    SPSCQueue<int, 16> q;
    EXPECT_TRUE(q.try_push(42));
    int val;
    EXPECT_TRUE(q.try_pop(val));
    EXPECT_EQ(val, 42);
}

TEST(SPSCQueue, FullQueue) {
    SPSCQueue<int, 4> q;
    EXPECT_TRUE(q.try_push(1));
    EXPECT_TRUE(q.try_push(2));
    EXPECT_TRUE(q.try_push(3));
    EXPECT_FALSE(q.try_push(4));  // full! (N-1 usable)
}

// Exercise 2: Concurrent stress test
TEST(SPSCQueue, StressTest) {
    SPSCQueue<uint64_t, 1024> q;
    constexpr uint64_t N = 1'000'000;
    std::thread producer([&] {
        for (uint64_t i = 0; i < N; ++i)
            while (!q.try_push(i)) {}
    });
    uint64_t expected = 0;
    std::thread consumer([&] {
        for (uint64_t i = 0; i < N; ++i) {
            uint64_t val;
            while (!q.try_pop(val)) {}
            EXPECT_EQ(val, expected++);
        }
    });
    producer.join();
    consumer.join();
}

// Exercise 3: GMock — mock a Sensor interface
class MockSensor : public ISensor {
    MOCK_METHOD(double, read, (), (override));
    MOCK_METHOD(bool, is_valid, (), (const, override));
};

// Exercise 1: Fuzz your message deserializer
// Build: clang++ -fsanitize=fuzzer,address -g fuzz_message.cpp
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    // Feed random bytes to your message parser
    // libFuzzer + ASan will find buffer overflows, OOB reads, etc.
    auto result = parse_message(data, size);
    return 0;
}

// Exercise 2: Fuzz your Expected<T, E> type with random operations
// Exercise 3: Let the fuzzer run for 10 minutes — analyze crash reports

# Exercise 1: Profile your RT loop with perf
perf record -g ./rt_executive --duration 10
perf report

# Exercise 2: Generate a flame graph
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

# Exercise 3: Use Valgrind's callgrind for instruction-level profiling
valgrind --tool=callgrind ./rt_executive --duration 1
kcachegrind callgrind.out.*

# Exercise 4: Cache miss analysis
perf stat -e cache-misses,cache-references,L1-dcache-load-misses ./rt_executive
# Your SPSC queue should have very few cache misses due to cache line alignment

// Exercise 1: Shared memory ring buffer between two processes
// Use shm_open + mmap to create a shared memory region
// Place your SPSC queue's data there (trivially copyable types only!)

// Exercise 2: Demonstrate the DmaCompatible concept from Week 1
// Only types that pass DmaCompatible can go in shared memory

// Exercise 3: Measure latency: pipe vs socket vs shared memory
// Expected: shared memory ~100ns, others ~10μs+

// Exercise 1: Define an IMU message in protobuf
// Serialize/deserialize, measure throughput (messages/sec)

// Exercise 2: Same message in FlatBuffers (zero-copy!)
// Compare: protobuf vs FlatBuffers serialization time
// FlatBuffers should be 10-100x faster because no copy on read

// Exercise 3: Write a benchmark comparing:
// - Raw memcpy (trivially copyable struct)
// - Protobuf
// - FlatBuffers
// - JSON (as a baseline to laugh at)

// Exercise 1: Implement type erasure (like std::function but simpler)
class AnyCallable {
    struct Concept {
        virtual void invoke() = 0;
        virtual ~Concept() = default;
    };
    template<typename F>
    struct Model : Concept {
        F fn;
        void invoke() override { fn(); }
    };
    std::unique_ptr<Concept> impl_;
public:
    template<typename F>
    AnyCallable(F&& f) : impl_(std::make_unique<Model<F>>(std::forward<F>(f))) {}
    void operator()() { impl_->invoke(); }
};

// Exercise 2: Small buffer optimization — avoid the heap allocation
// Store small callables inline (e.g. 32 bytes)

// Exercise 3: Plugin loading with dlopen
// Load a .so at runtime, resolve a symbol, call it
using PluginFactory = IController* (*)();
void* handle = dlopen("./libmy_controller.so", RTLD_NOW);
auto factory = (PluginFactory)dlsym(handle, "create_controller");

┌─────────────┐      shared memory      ┌─────────────┐
│ RT Process   │  ──── SPSC queue ────>  │ Logger Proc │
│ (sensor sim) │                         │ (file write) │
└─────────────┘                         └─────────────┘
        │                                       │
        │ FlatBuffers                    protobuf/JSON
        │                                       │
        ▼                                       ▼
   [Local display]                    [Network export]

// Puzzle 1: What does this print?
int i = 0;
int j = (i++) + (i++);
std::cout << j << "\n";
// Answer: UB! Unsequenced modification of i. Any result is valid.

// Puzzle 2: Is this legal?
int* p = new int(42);
delete p;
std::cout << p << "\n";  // just printing the pointer, not dereferencing!
// Answer: UB! Even using the value of a deleted pointer is UB.

// Puzzle 3: The signed overflow trap
for (int i = 1; i > 0; i *= 2)
    std::cout << i << " ";
// What does this print? How many iterations?
// Answer: UB on overflow. Compiler may assume infinite loop, or terminate.

// Puzzle 4: Strict aliasing violation
float f = 3.14f;
int i = *(int*)&f;  // type punning through pointer cast = UB!
// Correct way: std::bit_cast<int>(f)  (C++20)
// or: std::memcpy(&i, &f, sizeof(i))

// Puzzle 5: Returning reference to local
const std::string& getName() {
    std::string name = "robot";
    return name;  // dangling reference!
}
// Many compilers warn but don't error. The caller gets garbage.

// Puzzle 6: The null reference "can't happen"
void f(int& x) { if (&x == nullptr) return; /* ... */ }
// Compiler removes the null check because references can't be null.
// But what if someone did: f(*static_cast<int*>(nullptr))?

// Puzzle 7: Order of evaluation
std::map<int, int> m;
m[0] = m.size();  // Is m[0] == 0 or m[0] == 1?
// Answer: unspecified (not UB, but non-deterministic)

// Puzzle 8: Lifetime of temporaries
const std::string& r = std::string("hello");  // OK — lifetime extended!
const std::string& r2 = std::string("hello").substr(0, 3);  // DANGLING!
// Why? Lifetime extension only applies to the direct temporary.

// Puzzle 9: The infinite loop assumption (C++11)
void compute(int* data, size_t n) {
    for (size_t i = 0; i < n; ++i) {
        if (data[i] == 0) return;
        data[i] = process(data[i]);
    }
    // Compiler may assume this function terminates
    // If it doesn't (infinite loop with no side effects) → UB
}

// Puzzle 10: memory_order_relaxed surprise
std::atomic<int> x{0}, y{0};
// Thread 1: x.store(1, relaxed); y.store(1, relaxed);
// Thread 2: while (y.load(relaxed) != 1); assert(x.load(relaxed) == 1);
// Can the assert fire? YES! relaxed doesn't guarantee ordering.

// Exercise 1: CRTP for static polymorphism (zero-cost)
template<typename Derived>
class SensorBase {
public:
    double read() { return static_cast<Derived*>(this)->read_impl(); }
    bool is_valid() { return static_cast<Derived*>(this)->is_valid_impl(); }
};

class IMU : public SensorBase<IMU> {
    friend class SensorBase<IMU>;
    double read_impl() { /* actual hardware read */ return 0.0; }
    bool is_valid_impl() { return true; }
};
// No virtual dispatch! Compiler inlines everything.

// Exercise 2: Policy-based controller
template<typename IntegrationPolicy, typename SaturationPolicy>
class PIDController {
    IntegrationPolicy integrator_;
    SaturationPolicy saturator_;
    // The policies are injected as template parameters — zero overhead
};

struct TrapezoidalIntegration { double integrate(double error, double dt); };
struct ClampSaturation { double saturate(double value, double min, double max); };
using MyPID = PIDController<TrapezoidalIntegration, ClampSaturation>;

// Exercise 3: Benchmark CRTP vs virtual dispatch
// 10M calls — measure time difference
// Expected: CRTP 2-5x faster due to inlining

// Exercise 1: Set up spdlog with structured JSON output
// But remember: DON'T use spdlog in the RT path!
// Use the RT-safe logger pattern from Day 16.

// Exercise 2: Implement a log-level that can be changed at runtime
// Use an atomic<int> for the level — no mutex needed for reads
std::atomic<int> log_level{LOG_INFO};

// Exercise 3: Implement a lock-free trace ring buffer
// Fixed-size entries, overwrite oldest when full
// Can be dumped post-mortem after a crash (like a flight data recorder)
template<size_t N>
class TraceBuffer {
    struct Entry {
        uint64_t timestamp_ns;
        uint32_t event_id;
        uint32_t data;
    };
    std::array<Entry, N> buffer_;
    std::atomic<uint64_t> write_pos_{0};
public:
    void record(uint32_t event_id, uint32_t data);  // RT-safe!
    std::vector<Entry> dump() const;  // non-RT: copy out for analysis
};

┌─────────────────────────────────────────────────────────┐
│                    Mode Manager                         │
│  BOOT → INIT → NOMINAL → DEGRADED → SAFE → SHUTDOWN    │
└────────────────────────┬────────────────────────────────┘
                         │
┌────────────────────────▼────────────────────────────────┐
│              Cyclic Executive (1kHz)                     │
│                                                          │
│  1kHz:  sensor_read()       ── pool-allocated ──>        │
│  500Hz: controller_compute()                    SPSC     │
│  100Hz: telemetry_publish() ──────────────────> Queue    │
│  10Hz:  health_check()                                   │
│  1Hz:   heartbeat_publish()                              │
│                                                          │
│  Watchdog kick every iteration                           │
│  Overrun detection + task shedding                       │
└─────────────────────────────────────────────────────────┘
          │                              │
    ┌─────▼──────┐              ┌───────▼────────┐
    │ Sensor Sim  │              │ Telemetry Proc │
    │ (noise +    │              │ (FlatBuffers   │
    │  failures)  │              │  → file)       │
    └────────────┘              └────────────────┘

// file_a.cpp
struct Config { int timeout = 100; bool verbose = false; };

// file_b.cpp
struct Config { int timeout = 100; int verbose = 0; };  // bool vs int!

// Both compile. Both link. The program silently uses ONE definition
// chosen by the linker. Which one? UNDEFINED BEHAVIOR.
// No warning. No error. Your program just does something random.

// Create this exact ODR violation in two .cpp files
// Compile and link: g++ -o odr_test a.cpp b.cpp
// Run it — observe "it works"
// Now compile with: g++ -fsanitize=undefined -o odr_test a.cpp b.cpp
// Or use gold linker: g++ -fuse-ld=gold -Wl,--detect-odr-violations
// Observe: it was broken all along

// Without visibility control, EVERY symbol is exported from your .so
// A 20-year dev's first line in any shared library:
#pragma GCC visibility push(hidden)  // hide everything by default

// Then explicitly export only the public API:
#define API_PUBLIC __attribute__((visibility("default")))

class API_PUBLIC RobotController {
public:
    void start();  // exported
private:
    void internal_stuff();  // hidden — not in the symbol table
};

# Build a shared library with and without visibility
g++ -shared -o libfoo.so foo.cpp
nm -D libfoo.so | wc -l  # count exported symbols — will be HUGE

g++ -shared -fvisibility=hidden -o libfoo_hidden.so foo.cpp
nm -D libfoo_hidden.so | wc -l  # much smaller

# The difference is: link time, load time, binary size, symbol collision risk

# This fails:
g++ main.o -lm -o app libcustom.a
# This works:
g++ main.o libcustom.a -lm -o app
# Why? The linker is single-pass. It resolves symbols left-to-right.
# If libcustom.a needs symbols from -lm, -lm must come AFTER.

// You have a static library libutil.a and a shared library libcore.so
// libcore.so has a function foo() that calls bar() in libutil.a
// Your main.cpp also calls bar() directly.
// Question: How many copies of bar() exist in the final executable?
// Answer: TWO. One baked into libcore.so at so-build-time, one in your exe.
// If bar() has static variables, they are DIFFERENT variables.
// This causes "impossible" bugs where a singleton has two instances.

// Juniors think Pimpl is about "hiding implementation details."
// Seniors know it's about ABI STABILITY.

// Version 1 of your library (shipped to 100 customers as libfoo.so.1):
class RobotArm {
    double joint_angles_[6];
    bool enabled_;
public:
    void move_to(double x, double y, double z);
};
// sizeof(RobotArm) == 56  (48 + 1 + 7 padding)

// Version 2 — you need to add a new field:
class RobotArm {
    double joint_angles_[6];
    bool enabled_;
    double max_velocity_;     // NEW! Shifts everything after it
public:
    void move_to(double x, double y, double z);
};
// sizeof(RobotArm) == 64 — CHANGED!
// Every binary compiled against v1 now reads memory wrong
// when it accesses an instance created by v2 code.
// Random crashes. Data corruption. Welcome to ABI hell.

// The Pimpl fix:
class RobotArm {
    struct Impl;
    std::unique_ptr<Impl> impl_;   // sizeof(RobotArm) == 8 — FOREVER
public:
    void move_to(double x, double y, double z);
};
// Now you can add fields to Impl freely — the ABI never changes.

// 1. Build a shared library v1 with a class (no Pimpl)
// 2. Build an app linked against v1
// 3. Rebuild the library as v2 (add a field in the middle of the class)
// 4. Run the old app with new library (LD_LIBRARY_PATH)
// 5. Watch it crash or produce wrong results
// 6. Fix with Pimpl, repeat — now it works

// Key command:
// pahole MyClass  — shows the exact memory layout with padding

// Adding a virtual function to a class CHANGES THE VTABLE LAYOUT
// If anyone links against your .so and uses virtual dispatch,
// adding a virtual function is an ABI BREAK.

// Safe: Add virtual functions at the END of the class declaration
// Unsafe: Add them in the middle (shifts vtable indices)
// Also unsafe: Remove a virtual function, even if unused
// Also unsafe: Change the order of base classes

// This is why Qt, KDE, and Chrome use "reserved" vtable slots:
class Widget {
    virtual void event(Event*);
    virtual void paint();
    virtual void reserved1() {} // placeholder for future use
    virtual void reserved2() {}
    virtual void reserved3() {}
};

// This code links fine on GCC but crashes on Clang (or vice versa).
// Why? Same standard, same language, different ABIs.
struct Foo {
    std::string name;
    int id;
};
// GCC: std::string uses COW (Copy-On-Write) = 8 bytes (pointer)
// Clang's libc++: std::string uses SSO = 24 bytes (inline buffer)
// sizeof(Foo) is DIFFERENT between compilers!
// Pass Foo across a library boundary compiled with different compilers = crash
// Rule: NEVER pass STL types across shared library boundaries

L1 cache hit:    ~1 ns     (4 cycles)
L2 cache hit:    ~4 ns     (12 cycles)
L3 cache hit:    ~12 ns    (40 cycles)
RAM (DRAM):      ~60 ns    (200 cycles)
Branch mispredict: ~15 ns  (50 cycles)

Virtual function call: 0-2 ns (if predicted, ~same as direct call)
std::function call: 1-3 ns (indirect call + possible allocation)

// AoS — what you'd naturally write:
struct Particle {
    float x, y, z;         // position
    float vx, vy, vz;      // velocity
    float mass;
    uint32_t color;
    bool active;
    // 33 bytes + padding = 36 bytes per particle
};
std::vector<Particle> particles(100000);

// To update positions: for (auto& p : particles) p.x += p.vx * dt;
// Cache loads 64 bytes per line, but you only use 8 bytes (x, vx)
// Cache efficiency: 8/36 = 22% — you're wasting 78% of every cache line!

// SoA — what a 20-year dev writes:
struct Particles {
    std::vector<float> x, y, z;
    std::vector<float> vx, vy, vz;
    std::vector<float> mass;
    std::vector<uint32_t> color;
    std::vector<bool> active;  // careful: vector<bool> is special
};

// Now: for (size_t i = 0; i < n; ++i) x[i] += vx[i] * dt;
// Cache loads: x is contiguous, vx is contiguous
// Cache efficiency: 100% — every byte loaded is used
// Also: compiler can now auto-vectorize with SIMD (SSE/AVX)!

// Benchmark AoS vs SoA for 1M particles, 1000 frames
// Measure: time per frame, cache misses (perf stat)
// Expected: SoA is 3-10x faster for position-only updates

// perf stat -e L1-dcache-load-misses,L1-dcache-loads \
//   ./benchmark_aos
// perf stat -e L1-dcache-load-misses,L1-dcache-loads \
//   ./benchmark_soa

// ECS: entities are just IDs. Components are SoA tables.
// Commonly used in: game engines, physics simulations, robotics

// Each "system" iterates over only the components it needs
// → Perfect cache utilization, easy parallelism

// Example: A Physics system only reads (Position, Velocity, Mass)
// It doesn't touch (Color, Name, AI_State) — those don't pollute the cache

// Which is faster for summing values, and by how much?
// A) std::vector<int> (contiguous array)
// B) std::list<int> (linked list)
// C) std::unordered_set<int> (hash table)

// Answer: A is 50-200x faster than B, 10-50x faster than C.
// NOT because of algorithmic complexity (all O(n) for traversal).
// Because vector = 1 cache miss per ~16 ints (64-byte line / 4 bytes)
// list = 1 cache miss per EVERY node (nodes scattered in heap)

// A senior never uses std::list. EVER. std::deque if you need
// stable iterators, std::vector for everything else.

// Bonus: std::unordered_map<int,int> with default allocator is
// ~7x slower than a sorted std::vector<std::pair<int,int>> for
// small maps (n < 100) because of hash table node allocation.
// Abseil's flat_hash_map or a robin-hood map fixes this.

# 1. Enable core dumps on your system
ulimit -c unlimited
echo "/tmp/core.%e.%p" | sudo tee /proc/sys/kernel/core_pattern

# 2. Build with debug info EVEN in release
# -g = debug symbols, -O2 = still optimized
# This combination is standard for production builds at Google, Facebook, etc.
g++ -O2 -g -o my_app main.cpp

# 3. Keep the non-stripped binary alongside the stripped one
cp my_app my_app.debug
strip my_app  # ship this
# When you get a crash, load the .debug binary in gdb

# Load the core dump
gdb ./my_app.debug /tmp/core.my_app.12345

# Essential commands:
(gdb) bt                    # backtrace — where did it crash?
(gdb) bt full               # backtrace with all local variables
(gdb) frame 3               # jump to frame 3 in the stack
(gdb) info registers        # CPU register state at crash
(gdb) x/16xw $rsp           # examine 16 words of stack memory
(gdb) print *this            # print the object that crashed
(gdb) info threads           # was it a multi-thread crash?
(gdb) thread apply all bt   # every thread's backtrace

# For optimized code where variables are "optimized out":
(gdb) info registers        # the value is probably in a register
(gdb) disassemble           # read the assembly to find it

// 1. Write a program that crashes (null deref, or use-after-free)
// 2. Enable core dumps, run it, get the core
// 3. Open in gdb, reconstruct what happened from ONLY the core dump
// 4. Now do the same with an OPTIMIZED build (-O2 -g)
//    — notice that some variables say "<optimized out>"
//    — learn to read registers and disassembly to find them

// 5. The HARD one: double-free crash
// The crash backtrace is in malloc/free internals.
// The CAUSE is somewhere else (the first free).
// How do you find where the first free happened?
// Answer: MALLOC_CHECK_=3 ./my_app or ASan

# When you only have a stack trace from syslog/journal:
# "my_app[12345]: segfault at 0x0 ip 0x55a3b4c01234 sp 0x7ffd12345678"
addr2line -e my_app.debug -f -C 0x55a3b4c01234
# Output: RobotController::update() at robot_controller.cpp:142

// Bug class 1: Heap corruption (crash happens far from the cause)
// The crash is in malloc/free, but the bug is a buffer overflow
// 10,000 lines ago. ASan finds these. In production without ASan:
// Use MALLOC_CHECK_=3 (glibc) or jemalloc's debug mode.

// Bug class 2: The Heisenbug (disappears under observation)
// Adding printf makes it work. Removing printf makes it crash.
// Cause: timing-dependent race condition.
// The printf adds enough delay to change thread scheduling.
// Fix: run with TSan, or add strategic barriers.

// Bug class 3: Works in Debug, crashes in Release
// Cause: optimization-dependent UB (see Day 43)
// The optimizer assumes no UB and removes "unnecessary" checks.
// Example: a null check is removed because "references can't be null"
// but someone passed *(int*)0.
// Fix: compile with -O2 -fsanitize=undefined

// Bug class 4: "Corrupted stack" on embedded / RT systems
// Stack overflow. Your 8KB stack in the RT thread wasn't enough.
// The stack grows into the heap or other data, corrupting everything.
// Fix: guard pages (mmap PROT_NONE after the stack)
//      or: paint the stack with a known pattern, check periodically

// You get a crash report from a deployed robot. The backtrace shows:
//   #0  0x00007f2a... in __libc_fatal (assert.c:...)
//   #1  0x00007f2a... in __malloc_assert (malloc.c:...)
//   #2  0x00007f2a... in _int_free (malloc.c:...)
//   #3  0x0000558a... in std::vector<int>::push_back(...)
//   #4  0x0000558a... in Controller::update(...)
//
// The crash is in push_back, but push_back isn't buggy.
// What actually happened?
//
// Answer: Something earlier corrupted malloc's internal data structures
// (a buffer overflow, double free, or use-after-free somewhere).
// malloc detected the corruption only when it tried to split/merge
// a chunk. The crash location is the SYMPTOM, not the CAUSE.
// You need ASan/Valgrind replay or MALLOC_CHECK to find the real bug.

// EVERY senior has caused this bug at least once:
std::vector<int> v = {1, 2, 3, 4, 5};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == 3) {
        v.erase(it);  // 💣 iterator invalidated!
        // it++ in the for-loop header is now UB
    }
}
// Correct:
for (auto it = v.begin(); it != v.end(); ) {
    if (*it == 3) it = v.erase(it);  // erase returns next valid iterator
    else ++it;
}
// Even more correct (C++20):
std::erase(v, 3);  // just do this

// The COMPLETE invalidation rules (memorize these):
// vector: insert/push_back invalidates ALL iterators if reallocation occurs
//         (size == capacity). erase invalidates from erase point onward.
// deque:  insert/erase in middle invalidates ALL iterators.
//         insert/erase at ends only invalidates if reallocation.
// list:   insert/erase only invalidates the erased iterator. Others safe.
// map/set: insert/erase only invalidates the erased iterator. Others safe.
// unordered_*: insert invalidates ALL if rehash. Erase invalidates erased only.

// Most std::string implementations (GCC, Clang) store short strings
// INLINE in the object, no heap allocation.
// Typical SSO threshold: 15 bytes (GCC) or 22 bytes (libc++)

std::string short_str = "hello";      // NO heap allocation — fits in SSO buffer
std::string long_str(100, 'x');       // HEAP allocation needed

// Why this matters for performance:
// If all your robot's topic names are < 15 chars, string creation is O(1)
// If they're 16+ chars, every creation is a malloc (60ns penalty)

// Exercise: determine your platform's SSO threshold
for (size_t i = 0; i < 30; ++i) {
    std::string s(i, 'x');
    // If &s[0] points inside the string object → SSO
    // If &s[0] points to heap → heap allocated
    bool is_sso = (&s[0] >= reinterpret_cast<const char*>(&s) &&
                   &s[0] < reinterpret_cast<const char*>(&s) + sizeof(s));
    std::cout << i << " bytes: " << (is_sso ? "SSO" : "HEAP") << "\n";
}

// Junior: "hash map is O(1), tree map is O(log n), always use hash map"
// Senior: "it depends on N, access pattern, and cache behavior"

// For N < 100 elements:       use a sorted vector + binary search
// For N < 1000, read-heavy:   use std::map (cache-friendly tree walk)
// For N > 1000, lookup-heavy: use absl::flat_hash_map (open addressing)
// NEVER use std::unordered_map for performance-critical code:
//   - It uses chained hashing (linked list per bucket → cache hostile)
//   - Each node is a separate heap allocation
//   - Rehash copies everything

// Exercise: Benchmark all 4 for insert + lookup with N = 10, 100, 10K, 1M
// You'll find sorted vector wins until ~200 elements due to cache effects

// shared_ptr has hidden costs that compound in hot paths:
// 1. Two allocations: one for the object, one for the control block
//    (use make_shared to merge into one allocation)
// 2. Atomic reference count: every copy/destroy is an atomic increment/decrement
//    On x86: lock xadd (30-50 cycles). On ARM: ldrex/strex loop.
// 3. Thread-safe destruction: the destructor calls atomic decrement + conditional delete

// In a tight loop passing shared_ptr by value:
void process(std::shared_ptr<Data> data);  // atomic inc + dec per call!
void process(const std::shared_ptr<Data>& data);  // zero atomic ops — pass by ref!
void process(Data& data);  // even better if you don't need ownership

// Exercise: Benchmark these three function signatures with 1M calls
// Expected: by-value shared_ptr is 10-100x slower than by-reference

// Senior rule: shared_ptr is for OWNERSHIP TRANSFER at boundaries.
// Inside a component, use raw pointers or references.
// If nobody needs to own it, don't wrap it in shared_ptr.

// std::move is a CAST, not an operation. It casts to rvalue reference.
// The actual move happens in the move constructor/assignment.

std::string s = "hello";
std::string s2 = std::move(s);  // s is now in "valid but unspecified state"

// But this DOESN'T move anything:
const std::string cs = "hello";
std::string cs2 = std::move(cs);  // COPIES! const rvalue → const lvalue ref!
// No warning. No error. Just a silent copy.

// Exercise: prove this with a class that logs its special members
struct Verbose {
    Verbose() { puts("default ctor"); }
    Verbose(const Verbose&) { puts("copy ctor"); }
    Verbose(Verbose&&) { puts("move ctor"); }
    Verbose& operator=(const Verbose&) { puts("copy assign"); return *this; }
    Verbose& operator=(Verbose&&) { puts("move assign"); return *this; }
};
const Verbose cv;
Verbose v2 = std::move(cv);  // "copy ctor" — NOT "move ctor"!

// Exercise 1: Compare these on godbolt.org with -O2
int sum_loop(const int* arr, int n) {        // which generates SIMD?
    int s = 0;
    for (int i = 0; i < n; ++i) s += arr[i];
    return s;
}

int sum_range(const std::vector<int>& v) {   // does this auto-vectorize?
    int s = 0;
    for (int x : v) s += x;
    return s;
}

int sum_algorithm(const std::vector<int>& v) {
    return std::accumulate(v.begin(), v.end(), 0);   // same or different?
}
// Spoiler: on GCC -O2, all three generate identical SIMD assembly

// Exercise 2: Does the virtual call get devirtualized?
struct Base { virtual int value() = 0; };
struct Derived : Base { int value() override { return 42; } };
int get_value() {
    Derived d;
    Base& b = d;
    return b.value();  // virtual call... or is it?
}
// With -O2: the compiler sees the concrete type and devirtualizes!
// The "virtual call overhead" is ZERO in this case.

// 1. Is it vectorized? (look for xmm/ymm registers, movaps, addps)
// 2. Is the branch predicted? (look for cmov instead of jmp)
// 3. Was the function inlined? (look for call instruction)
// 4. Are there cache prefetches? (look for prefetcht0)
// 5. Did the compiler eliminate dead code? (count instructions)

// Exercise 3: Write code that you THINK should vectorize but doesn't
// Then figure out why (aliasing? non-contiguous? data-dependent branch?)
void add_arrays(float* dst, const float* a, const float* b, int n) {
    for (int i = 0; i < n; ++i)
        dst[i] = a[i] + b[i];  // Does this vectorize?
}
// Answer: MAYBE. If dst aliases a or b, the compiler can't vectorize.
// Fix: void add_arrays(float* __restrict__ dst, ...)
// __restrict__ promises no aliasing → compiler vectorizes aggressively

// Exercise 4: Compare on godbolt with -O2:
// Raw loop vs std::transform vs ranges::transform
auto raw = [](std::vector<int>& v) {
    for (auto& x : v) x *= 2;
};

auto stl = [](std::vector<int>& v) {
    std::transform(v.begin(), v.end(), v.begin(), [](int x) { return x*2; });
};

auto ranges = [](std::vector<int>& v) {
    auto view = v | std::views::transform([](int x) { return x*2; });
    std::ranges::copy(view, v.begin());
};
// Check: do they generate the same assembly?
// In practice with -O2: usually yes. "Zero-cost" IS actually zero-cost.
// But: add -fno-inline and watch the abstraction cost appear.

// This function is 50x slower than expected. The godbolt output shows
// no SIMD despite float arithmetic in a tight loop. Why?
float compute(float* data, int n) {
    float result = 0.0f;
    for (int i = 0; i < n; ++i) {
        result += data[i];
    }
    return result;
}
// Answer: Floating-point addition is NOT associative.
// (a+b)+c != a+(b+c) due to rounding.
// The compiler CANNOT reorder additions → CANNOT vectorize.
// Fix: compile with -ffast-math, or manually unroll:
// float r0=0,r1=0,r2=0,r3=0;
// for(i=0; i<n; i+=4) { r0+=data[i]; r1+=data[i+1]; ... }
// result = r0+r1+r2+r3;

// C++ name-mangles functions: int foo(int) → _Z3fooi
// C doesn't: int foo(int) → foo
// extern "C" tells the C++ compiler to use C linkage (no mangling)

extern "C" {
    // These functions can be called from C code or loaded with dlsym
    int initialize(const char* config_path);
    int shutdown();
    int process(const float* data, int n, float* out);
}

// GOTCHA: You can't use extern "C" with:
// - Overloaded functions (C has no overloading)
// - Templates
// - Namespaced functions (C has no namespaces)
// - Functions with default arguments (technically works, but C callers can't use them)

// C libraries use function pointers + void* for callbacks:
// typedef void (*callback_t)(int event, void* user_data);
// void register_callback(callback_t cb, void* user_data);

// Senior pattern: wrap with a static member (thunk):
class EventHandler {
    int state_ = 0;

    static void c_callback(int event, void* user_data) {
        auto* self = static_cast<EventHandler*>(user_data);
        self->handle(event);  // dispatch to C++ method
    }

    void handle(int event) {
        state_ += event;
    }

public:
    void register_with_c_library() {
        register_callback(&c_callback, this);
    }
};

// DANGER: The C library holds a raw pointer to your C++ object.
// If the object is destroyed while the callback is registered → UB.
// Senior fix: RAII + deregister in destructor
~EventHandler() { deregister_callback(&c_callback, this); }

// Every C resource follows the same pattern:
// create/open → use → close/destroy

// Template RAII wrapper for ANY C resource:
template<typename T, auto Deleter>
class CResource {
    T handle_;
public:
    explicit CResource(T h) : handle_(h) {}
    ~CResource() { if (handle_) Deleter(handle_); }

    CResource(const CResource&) = delete;
    CResource& operator=(const CResource&) = delete;
    CResource(CResource&& o) noexcept : handle_(std::exchange(o.handle_, {})) {}
    CResource& operator=(CResource&& o) noexcept {
        if (this != &o) { if (handle_) Deleter(handle_); handle_ = std::exchange(o.handle_, {}); }
        return *this;
    }

    T get() const { return handle_; }
    explicit operator bool() const { return handle_ != T{}; }
};

// Usage:
using FileHandle = CResource<FILE*, fclose>;
using ShmHandle = CResource<int, close>;  // for file descriptors

FileHandle f(fopen("/tmp/test", "w"));
// fclose called automatically when f goes out of scope

// ROS1 is C++03 with Boost everywhere. ROS2 is modern C++ under the hood,
// but the C middleware (rmw_fastrtps, rmw_cyclonedds) uses plain C APIs.
// Your warehouse robot's base controller talks to hardware via C APIs.
// This pattern is exactly how ros_control wraps hardware interfaces.

// 1. Headers that include the world
// #include <algorithm>  — pulls in 60,000+ lines on GCC 12
// #include <iostream>   — pulls in 30,000+ lines
// #include <regex>      — pulls in 100,000+ lines (!!!)

// Exercise: measure include cost
echo '#include <vector>' | g++ -x c++ -std=c++20 -E - | wc -l    # ~15,000
echo '#include <iostream>' | g++ -x c++ -std=c++20 -E - | wc -l  # ~30,000
echo '#include <regex>' | g++ -x c++ -std=c++20 -E - | wc -l     # ~100,000+
echo '#include <string>' | g++ -x c++ -std=c++20 -E - | wc -l    # ~20,000

// 2. Templates in headers (instantiated in EVERY translation unit)
// 3. Inline functions in headers (re-compiled in EVERY .cpp)
// 4. Unnecessary includes (header A includes header B, nobody needs B)