Marcus Weber

Marcus finished his CS masters at EPFL, then spent four years writing systems software for a high-frequency trading desk before he started tutoring full time. The kernel-bypass networking stack, the lock-free ring buffers, the cache-line-aligned struct layouts. The work was relentless on memory discipline, which is exactly the discipline most undergraduate C and C++ assignments are trying to teach. He moved to tutoring after a sabbatical year, kept the rigor, and dropped the production-fire stress. 980+ CSHH assignments and six years later, students still get the trading-desk debugger workflow whether they asked for it or not.

His specialty is the class of bugs that students cannot reproduce in their own debugger. Segfaults that only appear with optimization enabled. Heap corruption that surfaces three function calls after the actual overrun. Race conditions in pthreads code that pass 99 times and fail the hundredth on the autograder. He keeps a documented Valgrind workflow for each: --tool=memcheck with --track-origins=yes for use-after-free, --tool=helgrind for the thread race, --tool=cachegrind when the question is performance instead of correctness. Students who watch him work the toolchain start to recognize the failure modes by signature.

A representative case from earlier this year. A CS61C student submitted a multi-threaded matrix multiplication that passed all functional tests but ran 40% slower than the staff reference on the performance autograder. The student suspected the OpenMP scheduling. Marcus ran the binary under cachegrind, identified that the inner loop was thrashing the L1 cache because the matrix had been stored row-major and accessed column-major. The fix was eight lines: transpose the second matrix before the multiply, eat the O(n^2) transpose cost to win back O(n^3) cache hits. Score went from 60% to 100% on the next submission. The student understood why because Marcus walked through the cache-miss numbers cachegrind printed line by line.

On the C side his teaching pattern is to make memory ownership explicit before writing any code. Every malloc has a named owner, every owner has a free in the corresponding cleanup path, every function signature documents whether it takes ownership of its arguments or borrows them. Students who learn this discipline stop writing memory leaks because the leak is visible in the function signature before the code runs. C++ students get the same treatment with RAII: every resource is owned by an object, ownership transfers happen at construction or with std::move, and naked new is a code smell that needs justification.

The concurrency work is where most C and C++ students lose their footing. Marcus walks them through a concrete model before any code: shared memory, threads of execution, the happens-before relation, the difference between data race and race condition. Then he picks a textbook bug, a counter incremented from two threads without a mutex, and shows it in three forms. The C source. The compiler-generated assembly with the load, add, store sequence visible. The thread-sanitizer output flagging the race. Students see why the race exists at the instruction level, not just at the C level. The next mutex they write goes in the right place.

His CSHH workflow leans heavily on reproducing the failure before patching it. The brief arrives, he reads the autograder spec first, compiles the student starter code with -Wall -Wextra -Werror -fsanitize=address,undefined, and runs it against the rubric inputs. Bugs that surface under sanitizers but not under a clean compile are almost always the source of the failing test. He sends back a patched solution plus a short writeup explaining what the sanitizer caught and how to read the trace next time. Students who keep the writeup learn to find their own bugs the following week, which is the actual goal of the exercise even when the immediate need is the failing autograder.