Overview
What this challenge is about.
Trace the order allocator and crash records to root-cause heap corruption in a trading gateway, then earn your verifiable certificate.
The scenario
Case file: the order gateway is the software that receives the desk's buy and sell instructions and forwards them to the exchange in microseconds; it recycles order objects through a hand-written memory pool to avoid the cost of the standard allocator. Over a two-week window the operations log records the same pattern fourteen times — a segmentation fault between 08:31 and 09:05 Central time, each crash record showing damaged heap metadata in the order pool, and zero reproductions on the staging replay rig that runs the same code against a recorded feed.
The Brief
What you'll do, and what you'll demonstrate.
Determine, from the case file alone, what is corrupting the order gateway's heap and how to fix it without breaking the gateway's 18-microsecond median latency budget.
Earning criteria — what you'll demonstrate
- Reason from crash evidence (call stacks and damaged heap structures) back to a specific source-code defect without guessing.
- Use AddressSanitizer and ThreadSanitizer to turn an intermittent, load-dependent crash into a deterministic, repeatable test.
- Distinguish the candidate failure modes of a manual memory pool — use-after-free, double-free under a data race, and buffer overrun — and gather evidence for one over the others.
- Design a memory-safety fix that respects a strict latency budget by avoiding new allocations on the hot path.
- Benchmark a low-latency change and report median and tail latency credibly against a recorded workload.
Program Fit
Where this fits in your program.
Sharpens the same skills your degree expects you to demonstrate.
Aligned coursework coming soon.
Skills
Skills you'll demonstrate.
Each one shows up on your verified credential.
- Cpp Programming
Apply cpp programming to solve real industry problems and demonstrate production-level capability.
- Manual Memory Management
Apply manual memory management to solve real industry problems and demonstrate production-level capability.
- Pointers
Apply pointers to solve real industry problems and demonstrate production-level capability.
- Memory Debugging
Apply memory debugging to solve real industry problems and demonstrate production-level capability.
- Performance Benchmarking
Apply performance benchmarking to solve real industry problems and demonstrate production-level capability.
- Concurrency
Apply concurrency to solve real industry problems and demonstrate production-level capability.
Careers
Career paths this challenge builds toward
Completing this challenge demonstrates skills that transfer directly to these roles:
Low-Latency Systems Engineer
Firms that build trading and other real-time systems need engineers who can debug memory corruption in custom allocators without slowing the hot path. This challenge mirrors that work end to end: evidence-driven diagnosis, a deterministic reproducer, and a fix held to a microsecond-level budget.
This challenge sharpens
- cpp-programming
- manual-memory-management
- memory-debugging
Trading Infrastructure Engineer
Trading-infrastructure teams own the gateways between strategy and exchange, where a heap bug can halt a desk. The challenge builds the exact reflex they hire for: isolating a race-driven corruption under load and shipping a fix that survives a strict latency review.
This challenge sharpens
- concurrency
- pointers
- performance-benchmarking
C++ Performance Engineer
Performance engineers are judged on changes that are both correct and fast. Here you practice fixing a memory-safety defect while proving with before-and-after benchmarks that median and tail latency stay inside budget — the dual mandate these roles live by.
This challenge sharpens
- cpp-programming
- performance-benchmarking
- manual-memory-management