Skip to content

claude_study_plan

Jump to bottom
Madrajib Lab edited this page May 16, 2026 · 1 revision

6-Month Embedded Systems Career Growth Plan

From Userspace Expert to Platform-Level Systems Engineer

Overview

Goal: Transform from excellent userspace systems engineer to platform-level embedded systems engineer by deepening Linux internals, kernel-adjacent debugging, and modern C++ systems design.

Time Commitment: 20 hours/week (10 study + 10 code)

Focus Areas:

  1. Linux Kernel Internals & Driver Development
  2. Modern C++ (C++17/20/23)
  3. Advanced Debugging & Observability (eBPF)
  4. PCIe & Hardware Interconnects
  5. Performance Engineering
  6. Android Platform Internals

Month 1-2: Linux Kernel Fundamentals + First Driver

Week 1: Kernel Build & Development Environment

Study (10 hours)

  • "Linux Kernel Development" by Robert Love - Chapters 1-3 (kernel architecture, process management)
  • Set up kernel development environment: build mainline kernel from source
  • Study kernel coding style and submission process

Code (10 hours)

  • Clone Linux kernel, configure for ARM64 (your platform)
  • Build and boot custom kernel in QEMU
  • Write a "Hello World" kernel module with proper init/exit
  • Experiment with module parameters and /proc interface
  • Deliverable: Loadable module that logs to dmesg with configurable debug levels

Week 2: Memory Management Deep Dive

Study (10 hours)

  • "Understanding the Linux Kernel" - Chapter 8 (Memory Management)
  • Study slab/slub allocators, kmalloc vs vmalloc
  • Virtual memory, page tables, TLB for ARM architecture
  • Read mm/slab.c and mm/vmalloc.c in kernel source

Code (10 hours)

  • Write a module that allocates memory using different methods (kmalloc, vmalloc, get_free_pages)
  • Track allocations, implement proper cleanup
  • Use /proc/slabinfo to monitor your allocations
  • Trigger intentional memory leaks, debug with kmemleak
  • Deliverable: Memory allocator test module with stats tracking

Week 3: Kernel Synchronization & Locking

Study (10 hours)

  • Linux Kernel Development - Chapter 10 (Kernel Synchronization)
  • Study spinlocks, mutexes, semaphores, RCU
  • Read Documentation/locking/ in kernel tree
  • Understand preemption, interrupt contexts

Code (10 hours)

  • Build a multi-threaded kernel module using kthreads
  • Implement shared counter with different lock types (spinlock, mutex)
  • Create race conditions intentionally, then fix them
  • Use lockdep to detect deadlocks
  • Deliverable: Concurrent kernel data structure (ring buffer) with proper locking

Week 4: Character Device Driver (Part 1)

Study (10 hours)

  • "Linux Device Drivers" (LDD3) - Chapter 3 (Char Drivers)
  • Study file_operations, major/minor numbers, cdev structure
  • Read drivers/char/mem.c as reference

Code (10 hours)

  • Write a basic character driver (/dev/mychar)
  • Implement open, release, read, write operations
  • Use copy_to_user/copy_from_user correctly
  • Create device nodes with udev rules
  • Deliverable: Character driver that echoes data with userspace test program

Week 5: Character Device Driver (Part 2) + ioctl

Study (8 hours)

  • LDD3 - Chapter 6 (Advanced Char Driver Operations)
  • Study ioctl, blocking I/O, poll/select mechanisms
  • Read drivers/char/random.c for real-world example

Code (12 hours)

  • Add ioctl interface to your char driver for configuration
  • Implement blocking read with wait queues
  • Add poll() support for select/epoll
  • Create buffer management with proper synchronization
  • Write comprehensive userspace test suite
  • Deliverable: Full-featured char driver with multiple I/O methods

Week 6: Interrupt Handling & Workqueues

Study (10 hours)

  • Linux Kernel Development - Chapter 7 (Interrupts and Interrupt Handlers)
  • Study top/bottom halves, softirqs, tasklets, workqueues
  • Read kernel/workqueue.c and kernel/softirq.c

Code (10 hours)

  • Write a module that uses delayed work and workqueues
  • Simulate interrupt handling with timers (timer callbacks)
  • Implement both tasklet and workqueue bottom halves
  • Measure latency differences between approaches
  • Deliverable: Interrupt simulation framework with performance metrics

Week 7: USB Subsystem Deep Dive

Study (10 hours)

  • LDD3 - Chapter 13 (USB Drivers)
  • Study USB core, URBs, endpoints, pipes
  • Read drivers/usb/core/ and simple drivers like usb-skeleton.c
  • Your resume shows USB work - connect theory to practice

Code (10 hours)

  • Write a USB driver for a simple device (USB-to-serial or mass storage)
  • Implement probe/disconnect, URB submission
  • Handle USB control, bulk, and interrupt transfers
  • Debug with usbmon and Wireshark
  • Deliverable: Working USB driver with transfer examples

Week 8: First Kernel Patch Contribution

Study (8 hours)

  • Read "Submitting patches" kernel documentation
  • Study git format-patch, git send-email workflow
  • Review recent patches on LKML for your subsystem
  • Find a "good first issue" or documentation improvement

Code (12 hours)

  • Fix a real kernel bug or improve driver you studied
  • Test thoroughly on real hardware or QEMU
  • Run checkpatch.pl, sparse, coccinelle
  • Format patch properly with signed-off-by
  • Submit to staging or relevant subsystem
  • Deliverable: Submitted kernel patch (even if rejected, it's learning)

Month 3-4: Modern C++ & Performance Engineering

Week 9: Modern C++ Foundations (C++17/20)

Study (10 hours)

  • "Effective Modern C++" by Scott Meyers - Items 1-20
  • Study move semantics, rvalue references, perfect forwarding
  • Learn constexpr, if constexpr, fold expressions
  • "C++ Concurrency in Action" - Chapter 1-2

Code (10 hours)

  • Rewrite your ARM Trace parser header in modern C++
  • Replace raw pointers with unique_ptr/shared_ptr
  • Implement move constructors/assignment properly
  • Use structured bindings, std::optional, std::variant
  • Deliverable: Modernized trace parser library header

Week 10: RAII & Zero-Cost Abstractions

Study (8 hours)

  • Effective Modern C++ - Items 21-30
  • Study RAII patterns for resource management
  • Learn about Perfect Forwarding and universal references
  • Read Chromium C++ style guide

Code (12 hours)

  • Create RAII wrappers for your common resources (file descriptors, memory maps, locks)
  • Build a type-safe API for your ELF/DWARF parser
  • Replace C-style error handling with exceptions/std::expected (C++23)
  • Measure zero-overhead with compiler explorer (godbolt.org)
  • Deliverable: RAII resource manager library with benchmarks

Week 11: C++ Concurrency & Lock-Free Structures

Study (10 hours)

  • "C++ Concurrency in Action" - Chapters 3-5
  • Study std::atomic, memory_order, lock-free programming
  • Learn about mutexes, condition_variables, futures/promises
  • Read Folly and Abseil concurrency libraries

Code (10 hours)

  • Implement a lock-free SPSC (single-producer-single-consumer) queue
  • Build a thread pool with work stealing
  • Create a concurrent hash map with fine-grained locking
  • Compare performance: lock-free vs mutex-based
  • Deliverable: Concurrent data structure library with performance tests

Week 12: Refactor Real Project to Modern C++

Study (6 hours)

  • Review your existing C++ Binder bridge code
  • Study C++20 concepts, ranges, coroutines basics
  • Read "A Tour of C++" by Bjarne Stroustrup

Code (14 hours)

  • Refactor your Android Binder bridge to C++20
  • Use concepts for compile-time type constraints
  • Replace loops with ranges and views
  • Add proper error handling with std::expected
  • Write unit tests with Google Test
  • Deliverable: Production-quality refactored Binder bridge

Week 13: Performance Engineering - CPU & Cache

Study (10 hours)

  • "What Every Programmer Should Know About Memory" by Ulrich Drepper
  • Study cache hierarchies, false sharing, prefetching
  • Learn about CPU branch prediction, pipelining
  • Read Agner Fog's optimization manuals for ARM

Code (10 hours)

  • Profile your multi-client daemon with perf
  • Identify hot paths with flame graphs (perf + FlameGraph)
  • Optimize critical loops for cache locality
  • Reduce cache misses with data structure alignment
  • Measure with perf stat (cache-misses, branch-misses)
  • Deliverable: Performance report with before/after metrics

Week 14: SIMD Programming (ARM NEON)

Study (8 hours)

  • ARM NEON Programmer's Guide
  • Study intrinsics vs assembly for SIMD
  • Learn auto-vectorization techniques (compiler flags)
  • Read ARM NEON optimization case studies

Code (12 hours)

  • Vectorize data processing in your trace parser
  • Implement NEON-optimized memory copy/compare
  • Compare scalar vs NEON performance (4x-8x expected)
  • Use compiler intrinsics (arm_neon.h)
  • Profile with perf to verify SIMD instruction usage
  • Deliverable: NEON-optimized log filtering with benchmarks

Week 15: Low-Latency System Design

Study (8 hours)

  • Study your own low-latency video streaming project
  • Read "Systems Performance" by Brendan Gregg - Chapters 2-4
  • Learn about tail latency, percentile metrics
  • Study jitter reduction techniques

Code (12 hours)

  • Benchmark your daemon's latency distribution (p50, p95, p99)
  • Implement latency tracking with rdtsc/ARM cycle counter
  • Reduce jitter: CPU pinning, isolcpus, SCHED_FIFO
  • Optimize syscall overhead (io_uring for I/O)
  • Create latency heatmap visualization
  • Deliverable: Low-latency daemon with <100μs p99 target

Week 16: Complete Performance Optimization Project

Study (6 hours)

  • Review all optimization techniques learned
  • Study real-world case studies (Google, Meta optimization blogs)
  • Learn about continuous profiling in production

Code (14 hours)

  • Apply all techniques to one critical component
  • Optimize end-to-end: algorithms, data structures, cache, SIMD, concurrency
  • Create comprehensive benchmark suite
  • Document optimizations with performance data
  • Present findings (write detailed blog post)
  • Deliverable: Fully optimized component with 2x+ speedup and documentation

Month 5: eBPF & Advanced Debugging

Week 17: eBPF Fundamentals

Study (10 hours)

  • "Learning eBPF" by Liz Rice - Chapters 1-4
  • Study eBPF maps, programs, verifier constraints
  • Read kernel documentation on eBPF
  • Understand eBPF vs kernel modules tradeoffs

Code (10 hours)

  • Set up bpftool, libbpf development environment
  • Write "Hello World" BPF program with bpftrace
  • Create a simple syscall tracer (trace openat calls)
  • Use BPF maps to aggregate data
  • Visualize results with simple Python script
  • Deliverable: Syscall monitoring tool with BPF

Week 18: BCC (BPF Compiler Collection)

Study (8 hours)

  • Study BCC framework and Python bindings
  • Read existing BCC tools source (execsnoop, biolatency)
  • Learn about kprobes, uprobes, tracepoints

Code (12 hours)

  • Write custom BCC tool to trace your daemon's behavior
  • Monitor function call frequency and latency
  • Track memory allocations per code path
  • Create histogram of operation durations
  • Build dashboard with real-time BPF data
  • Deliverable: Production daemon profiler using BCC

Week 19: libbpf & CO-RE (Compile Once - Run Everywhere)

Study (10 hours)

  • Study libbpf library and CO-RE concepts
  • Learn BTF (BPF Type Format) and vmlinux.h
  • Read Andrii Nakryiko's BPF blog posts
  • Understand BPF skeleton generation

Code (10 hours)

  • Migrate one BCC tool to pure libbpf
  • Use CO-RE for kernel version portability
  • Generate BPF skeleton with bpftool gen
  • Implement ring buffer for efficient data transfer
  • Deploy on multiple kernel versions
  • Deliverable: Portable BPF profiler with libbpf

Week 20: Advanced Kernel Debugging

Study (10 hours)

  • "Linux Kernel Debugging" techniques documentation
  • Study ftrace, trace-cmd, KernelShark
  • Learn KASAN, UBSAN, lockdep in detail
  • Read about kdump and crash analysis

Code (10 hours)

  • Use ftrace to trace kernel functions in your USB driver
  • Set up dynamic tracing with kprobes
  • Trigger and analyze a kernel panic with crash utility
  • Use KASAN to find memory bugs in your modules
  • Create custom ftrace plugin for your subsystem
  • Deliverable: Kernel debugging toolkit and crash analysis report

Month 6: PCIe, Android Internals & Integration

Week 21: PCIe Architecture Deep Dive

Study (12 hours)

  • "PCI Express System Architecture" book - Chapters 1-5
  • Study TLP (Transaction Layer Packets), enumeration
  • Learn about DMA, IOMMU, MSI/MSI-X interrupts
  • Read PCIe driver examples in kernel (drivers/pci/)

Code (8 hours)

  • Analyze existing PCIe driver you work with at Qualcomm
  • Trace PCIe initialization and enumeration flow
  • Write a simple PCIe device simulator/test driver
  • Monitor PCIe traffic with lspci -vvv and debugging
  • Document PCIe data flow in your system
  • Deliverable: PCIe driver analysis document with diagrams

Week 22: DMA & Memory Mapping

Study (8 hours)

  • Study DMA API in kernel (coherent vs streaming)
  • Learn about IOMMU, scatter-gather lists
  • Read Documentation/DMA-API.txt
  • Study ARM SMMU architecture

Code (12 hours)

  • Implement DMA buffers in your test driver
  • Create proper DMA mappings with dma_map/unmap
  • Handle cache coherency issues
  • Test with different IOMMU configurations
  • Debug DMA issues with IOMMU debugging
  • Deliverable: DMA-capable driver with proper memory handling

Week 23: Android Binder Internals

Study (10 hours)

  • Study Android Binder IPC mechanism in detail
  • Read Binder kernel driver (drivers/android/binder.c)
  • Learn about AIDL/HIDL interface definitions
  • Study servicemanager and hwservicemanager

Code (10 hours)

  • Trace Binder transactions for your cross-domain bridge
  • Instrument Binder driver with ftrace/BPF
  • Measure Binder IPC latency and overhead
  • Optimize your Binder usage (reduce copies, batch calls)
  • Document data flow with sequence diagrams
  • Deliverable: Binder performance analysis and optimization report

Week 24: Android HAL & Native Services

Study (8 hours)

  • Study Android HAL architecture (passthrough vs binderized)
  • Learn about VNDK, APEX, Treble architecture
  • Read Android native service examples
  • Study SELinux policy for native services

Code (12 hours)

  • Map complete data flow in your vendor-system bridge
  • Analyze HAL interface definitions (AIDL)
  • Implement missing error handling in service layer
  • Add comprehensive logging and metrics
  • Test across Android version upgrades
  • Deliverable: Hardened vendor-system bridge with documentation

Week 25: Integration Project - Part 1

Study (6 hours)

  • Review all techniques learned in 6 months
  • Design a complex integration project using everything
  • Plan architecture: kernel driver → userspace daemon → Android service

Code (14 hours)

  • Build a complete diagnostic framework:
    • Kernel module collecting hardware stats
    • eBPF programs for performance monitoring
    • Modern C++ userspace daemon with lock-free queues
    • Android Binder service exposing data
    • Command-line and Android app interfaces
  • Implement kernel module and eBPF components
  • Deliverable: Kernel and eBPF components of diagnostic framework

Week 26: Integration Project - Part 2 & Portfolio

Study (4 hours)

  • Review code quality, documentation standards
  • Study how to present technical work (portfolio, blog)
  • Prepare for technical interviews on systems topics

Code (16 hours)

  • Complete userspace daemon with modern C++
  • Implement Android service layer
  • Add comprehensive testing (unit, integration, performance)
  • Create full documentation with architecture diagrams
  • Write blog post explaining design decisions
  • Polish GitHub portfolio with all projects
  • Deliverable: Complete end-to-end diagnostic framework + portfolio

Concurrent Activities (Throughout 6 Months)

Weekly Open Source (2-4 hours/week)

  • Continue Zephyr contributions (ESP32 drivers)
  • Submit kernel patches (staging, drivers, documentation)
  • Review others' patches to learn from feedback
  • Build reputation in one subsystem

Weekly Reading (2-3 hours/week)

  • Follow LKML threads for your subsystems
  • Read Qualcomm internal architecture docs
  • Study competitor solutions (QNX, VxWorks)
  • Follow systems programming blogs (Cloudflare, Meta)

Bi-weekly Projects (4 hours every 2 weeks)

  • Update your GitHub with polished code
  • Write technical blog posts
  • Document learnings and gotchas
  • Create reference material for team

Monthly Milestones

Month Milestone
Month 1 First kernel module running
Month 2 USB driver submitted as patch
Month 3 Modern C++ project complete
Month 4 eBPF profiler in production
Month 5 PCIe driver analysis done
Month 6 Full integration project demo-ready

Success Metrics

Technical

  • ✅ 5+ kernel patches submitted (2+ accepted)
  • ✅ 3+ major C++ projects refactored
  • ✅ 2+ BPF tools in production use
  • ✅ 1 complete end-to-end systems project

Career

  • ✅ Portfolio website with detailed project writeups
  • ✅ 3+ technical blog posts published
  • ✅ Speaking at internal tech talks
  • ✅ Ready for Staff/Principal engineer interviews

Time Commitment

  • 20 hours/week (10 study + 10 code)
  • Weekends: 10 hours (or spread across evenings)
  • Flexibility: Adjust based on work intensity

Essential Resources

Books

  1. Linux Kernel Development - Robert Love
  2. Understanding the Linux Kernel - Daniel P. Bovet, Marco Cesati
  3. Linux Device Drivers (LDD3) - Jonathan Corbet, Alessandro Rubini, Greg Kroah-Hartman
  4. Effective Modern C++ - Scott Meyers
  5. C++ Concurrency in Action - Anthony Williams
  6. Learning eBPF - Liz Rice
  7. Systems Performance - Brendan Gregg
  8. PCI Express System Architecture - Ravi Budruk, Don Anderson, Tom Shanley

Online Resources

  • Linux kernel documentation (kernel.org/doc)
  • LKML (Linux Kernel Mailing List)
  • Bootlin training materials
  • ARM developer documentation
  • Android source code (AOSP)
  • eBPF documentation and examples

Tools to Master

  • GDB, QEMU, perf, ftrace, trace-cmd
  • bpftool, bpftrace, BCC, libbpf
  • Compiler explorer (godbolt.org)
  • Git, checkpatch.pl, sparse, coccinelle
  • Valgrind, KASAN, lockdep

Top 10 Skill Areas (Priority Order)

  1. Linux Kernel Internals & Driver Development - Months 1-2
  2. Modern C++ (C++17/20/23) - Months 3-4
  3. Advanced Debugging & Observability (eBPF) - Month 5
  4. PCIe & Hardware Interconnects - Month 6
  5. Performance Engineering - Months 3-4
  6. Android Platform Internals - Month 6
  7. Heterogeneous Computing & SoC Architecture - Ongoing
  8. Real-Time Systems & RTOS - Ongoing (Zephyr)
  9. Networking Stack - Self-study
  10. Rust for Systems Programming - Month 7+

Weekly Schedule Template

Weekdays (2-3 hours/day)

  • Evening 1-2: Study (reading, documentation)
  • Evening 3-4: Coding (hands-on practice)
  • Evening 5: Open source contributions

Weekends (5 hours/day)

  • Saturday Morning: Deep study session
  • Saturday Afternoon: Major coding project
  • Sunday: Code review, documentation, blogging

Progress Tracking

Create a simple tracker:

## Week X Progress

Completed


    

  •  Study task 1
    • 

  •  Study task 2
    • 

  •  Code task 1
    • 

  •  Code task 2
    • 

  •  Deliverable created
    • 



Challenges


    

  • What was difficult?
    • 

  • What took longer than expected?
    • 



Learnings


    

  • Key insights
    • 

  • Gotchas to remember
    • 



Next Week Prep


    

  • Materials to gather
    • 

  • Environment setup needed

    •

Final Notes

This plan emphasizes building, not just reading. Every week has concrete deliverables you can show in interviews or add to your portfolio. You'll have real code, real measurements, and real contributions to discuss.

Flexibility: Adjust the pace based on your work commitments, but maintain consistency. It's better to do 15 hours consistently than 30 hours sporadically.

Community: Engage with the Linux kernel community, C++ communities, and eBPF developers. Ask questions, review patches, and learn from experts.

Documentation: Document everything you build. Future you (and interviewers) will thank you.

Ready to start Week 1? Good luck on your journey to becoming a platform-level embedded systems engineer!

Clone this wiki locally