Demystifying Systems Programming
As a tutor for Grundlagen Betriebssysteme und Systemsoftware (GBS) at TUM, I guided second-year students from low-level C into the abstractions that power modern operating systems.
We dissected processes, threads, memory hierarchies, file systems, and Linux primitives so every concept was paired with hands-on tracing, debugging, and measurement.
Key Contributions
I designed tutorial journeys that blended concept-first walkthroughs, visual knowledge maps, formative feedback, and responsive support across all course channels.
Teaching & Mentorship
I led weekly lab-style sessions that rehearsed process orchestration, CPU scheduling trade-offs, address translation, and synchronization techniques, reinforced with concise C labs and live Unix tooling such as strace, perf, and gdb.
Assessment & Evaluation
I graded written exams and programming assignments, provided rubric-aligned feedback, supervised proctored tests, and resolved regrade requests with transparent reasoning backed by scheduler traces and memory diagrams.
Operating System Pillars I Teach
Each unit advanced from pointer-safe C foundations to the OS services that make software secure and performant. I complemented theory with timelines, memory maps, and tooling demos so students saw every abstraction in action.
Process & CPU Management
Contrasted processes and threads, explored scheduling algorithms from FCFS to the Linux CFS, and practiced analyzing preemption timelines with Gantt charts.
Concurrency & Synchronization
Diagnosed race conditions, applied mutexes and semaphores, and modeled critical sections with Petri nets to prove deadlock freedom.
Memory & Storage Architecture
Mapped stack vs. heap layouts, walked multi-level page tables, simulated buddy allocation, and decoded inode-driven file system structures.
Modern Isolation & Virtualization
Demonstrated Linux namespaces and cgroups, tying them to container sandboxes and resource governance in real deployments.
Skill Development & Impact
This role sharpened my ability to translate systems internals into approachable stories, pairing rigorous analysis with empathetic coaching so students stayed confident while tackling OS-scale complexity.
Technical Communication
Narrated scheduler states, memory translations, and IO paths with layered visuals that helped students evaluate trade-offs quickly.
Systems Debugging
Recreated faults with instrumentation, from pointer misuse to starvation, so students internalised rigorous debugging habits.
Leadership & Empathy
Cultivated a curiosity-first culture that rewarded collaborative reasoning and precise language when describing kernels.
Want to see more?
Check out the projects and resources I've built along the way.