Latest Interviews

Production Engineering When Trading Billions of Dollars a Day

Mark Doss

Mark, a production engineer at Jane Street, outlines a high-stakes trading environment where even a 0.01% error rate can trigger insolvency, necessitating a monitoring strategy that rejects standard service level objectives in favor of code-level, event-based alerts. The firm employs a defense-in-depth approach using redundant, symptom-focused detection systems to catch catastrophic failures like fat-finger trades or stale market data before they cascade. By integrating deep domain knowledge into incident response and treating monitoring infrastructure as more critical than the trading systems themselves, Jane Street ensures that traders and engineers collaborate to resolve unique operational risks with extreme precision.

The Cost of Concurrency Coordination with Jon Gjengset

Jon Gjengset, John, Gabriel Kreiman

The presentation challenges the conventional view that mutexes are inherently slow, demonstrating instead that performance degradation in high-concurrency environments stems from CPU cache coherence overheads and MESI protocol costs rather than the lock mechanism itself. To address false sharing and serialization issues found in reader-writer locks, the speaker details the Left-Right data structure, a lock-free architecture that achieves linear scaling for read-heavy workloads by decoupling reader access from writer synchronization. Finally, the discussion emphasizes that optimal synchronization strategy depends on the specific read-to-write ratio and consistency requirements, urging developers to profile cache behavior and avoid blind optimization of lock primitives.

Bryan Cantrill: Andreessen’s Folly - The False Dichotomy of Software and Hardware

Bryan Cantrill, Andreessen, Alan Kay, Jonathan Gruber, Trevor Johnsen, Tred Wansell, Jermaine

Speaker critiques Marc Andreessen's "Software Eating the World" thesis as a false dichotomy while detailing Oxide Computer Company's hardware-software co-design strategy to reclaim stack control. By abandoning proprietary layers like UEFI and Baseboard Management Controllers in favor of custom operating systems and holistic integration with AMD silicon, the company addresses systemic reliability failures that plague commoditized reference designs. This approach has already resolved complex hardware-software interaction bugs and positions the firm to pursue open-source firmware and transparent accelerator partnerships to eliminate vendor lock-in in future data center infrastructure.

Arjun Guha: How Language Models Model Programming Languages & How Programmers Model Language Models

Arjun Guha

Arjun Guha presents a comprehensive analysis of large language models in programming, highlighting how traditional benchmarks are saturating while new methods like multi-PLE and language-agnostic transforms reveal significant performance gaps in low-resource languages such as OCaml. Through mechanistic interpretability techniques like activation steering, the talk demonstrates that internal model vectors can effectively correct type prediction errors and switch target languages without retraining, exposing shared representations across diverse syntaxes. These technical insights are contextualized by human studies showing that student success in prompting models hinges on providing specific semantic clues rather than syntactic fixes, while industry data reveals a surge in AI co-authorship alongside complex debates regarding actual productivity gains.

Making GPUs Actually Fast: A Deep Dive into Training Performance

Corwin, Savant Diaz, Sylvain De Wecker

Jane Street engineers optimize deep learning infrastructure by eliminating CPU-GPU synchronization bottlenecks and fusing PyTorch operations via `torch.compile` and Triton to maximize throughput. When automated compilation fails on complex Python logic, they deploy custom CUDA kernels that leverage shared memory and warp-level reductions to achieve nearly 1,000x speedups in specialized tensor operations. This hierarchical approach, ranging from standard PyTorch to hand-optimized C++, ensures efficient utilization of the H100's 132 Streaming Multiprocessors and strict memory bandwidth constraints.

Neil Mitchell: Pyrefly: Type Checking 1.8 Million Lines of Python Per Second

Neil Mitchell, Roman

Meta engineer Neil Mitchell introduced PyreFly, an open-source Python type checker reimplemented in Rust to address performance and scalability limitations for massive codebases like Instagram. The tool utilizes an aggressive memory eviction strategy and file-level concurrency to deliver rapid IDE feedback while supporting complex type features such as structural subtyping and flow narrowing. Released under the MIT license with over 100 contributors, PyreFly aims to replace legacy systems by prioritizing broad ecosystem adoption and seamless integration with build tools like Buck.

Hacking OCaml

Corwin de Zahr

In a 2021 CTF challenge titled "Secure OCaml Sandbox," the speaker demonstrates how to bypass type safety by exploiting exceptional polymorphism and runtime inconsistencies within the OCaml standard library. By leveraging functions like `callback.register` alongside low-level insights into integer tagging and closure memory layouts, the attacker constructs a custom `obj.magic` to redirect code execution toward blocked primitives such as `open_in`. This successful exploitation retrieves the hidden flag, illustrating how deep knowledge of the OCaml runtime can undermine soundness guarantees even when standard file and command execution are restricted.

Will Crichton: Rust for Everyone!

Will Crichton

Will Creighton's research at the Cognitive Engineering Lab applies human-centered design and formal cognitive theories to address fundamental learning and debugging barriers in Rust. By developing three core tools—Aquascope for visualizing ownership permissions, Argus for interactive trait solver trees, and Flow History for precise program slicing—the team achieved a 9-point score increase in learner assessments and a threefold speedup in error localization during user studies. Future efforts are now directed toward resolving async/await complexities and promoting extensible IDE frameworks like CodeMirror to further advance a scientific approach to programming language design.

The Saga of Multicore OCaml

After a nine-year development cycle, Jane Street successfully deployed Runtime 5, a multi-core garbage collector for OCaml that addresses initial performance regressions through a redesigned pacing model and a Mark Delay synchronization patch. The team resolved complex "load-bearing bugs" and floating garbage issues to achieve stable parallelism while maintaining the sequential performance required for high-frequency trading environments. Despite rejecting the ownership model of languages like Rust, Jane Street is now releasing its production-ready OxCamel branch to facilitate researcher experimentation on future parallelism tools and type-level race freedom guarantees.

Making OCaml Safe for Performance Engineering

Mark

Jane Street's research introduces a suite of OCaml extensions featuring unboxed types and stack allocation to eliminate memory waste and garbage collection overhead in performance-critical applications. These innovations expand into a static mode system that guarantees data race freedom for parallel execution by enforcing lifetime and portability constraints without explicit annotations. Currently deployed in production for memory management features and undergoing beta testing for concurrency safety, this work aims to integrate into mainline OCaml while earning a POPL award for its formal verification of race freedom.

Horace He: Building Machine Learning Systems for a Trillion Trillion Floating Point Operations

Horace He

Meta compiler engineer Horace He analyzes the dramatic consolidation of AI infrastructure, noting that modern model training now requires massive power resources and billions in capital to achieve state-of-the-art performance. He details how the industry has transitioned from simple imperative execution to complex compiler strategies like FlexAttention and `torch.compile`, which are essential for managing the critical balance between GPU compute and memory movement. Ultimately, He argues that the primary challenge in this field is shifting focus from pure optimization to designing robust programming models that allow developers to reliably express complex performance trade-offs in large-scale distributed systems.

The Uncertain Art of Accelerating ML Models with Sylvain Gugger

Sylvain Gugger, Ron Minsky, Jeremy Howard, Mark Mandelmann, Mark Mirchandani, Francesc Campoy, Gabriel Sanchez

Former fast.ai co-author Jeremy Howard discusses his transition from mathematics education to optimizing machine learning infrastructure at Jane Street, highlighting breakthroughs in learning rate schedules and image resizing that previously secured top benchmark placements. He details the development of the Hugging Face Accelerate library, a lightweight tool designed to abstract complex hardware parallelism and eliminate boilerplate code for training across diverse GPUs and TPUs. The discussion further explores the architectural constraints of financial data, the dominance of PyTorch's iterative execution model, and Jane Street's rigorous approach to reproducibility and custom model development for high-frequency trading.

State Machine Replication, and Why You Should Care with Doug Patti

Doug Patti, Ron

Doug Patti's presentation details Jane Street's architectural evolution from the rigid, single-sequencer Concord system to the more flexible ARIA infrastructure, which supports 24/7 operations and hierarchical topic namespaces. ARIA addresses previous limitations in versioning and overhead while preserving global deterministic ordering for high-frequency trading, enabling internal teams to manage complex workflows with reduced operational burden. Despite these advancements, the architecture still faces challenges regarding rate limiting and snapshot capabilities, prompting ongoing optimizations to support broader firm-wide adoption.

Building a Functional Email Server with Dominick LoBraico

Dominick LoBraico, Ron Minsky

Faced with the security risks and operational rigidity of a legacy mail server, Jane Street engineers replaced the system with MailCore, a homegrown server implemented in OCaml where configuration is expressed as composable code. To ensure safety during the one-year migration, the team deployed a parallel shadow instance that continuously diffed outputs against the legacy system, effectively reverse-engineering implicit knowledge while eliminating memory-safety bugs common in C-based alternatives. This architectural shift transformed email management into a software culture practice, allowing generalist engineers to safely modify routing and filtering logic using standard OCaml tools rather than relying on specialized knowledge of opaque custom domains.

Raph Levien: A Taste of GPU Compute

Raph Levien

The presentation details how modern GPU architectures prioritize throughput over single-thread latency to overcome the plateau of CPU scaling, leveraging parallelism to achieve tenfold improvements in performance per dollar and watt. It outlines a functional programming model for GPU compute that employs hybrid tiling and bitmasking strategies to minimize branch divergence and maximize read efficiency in rendering workloads. Finally, the event analyzes the industry's shift from proprietary CUDA ecosystems toward standardized open APIs like Vulkan and WebGPU, which facilitate portable, high-performance computing through intermediate languages like SPIR-V and formal memory models.