Latest Interviews
Showing 1–12 of 12 transcripts.
Clear all filters- Jane Street48 min
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.
- Jane Street1h 3m
Horace He: Building Machine Learning Systems for a Trillion Trillion Floating Point Operations
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.
- Jane Street1h 4m
Building a Functional Email Server with Dominick LoBraico
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.
- Jane Street1h 24m
Steve Lee: State of the Shell: PowerShell7
The PowerShell team announced a strategic shift where Windows PowerShell 5.1 is now maintenance-only, while the primary focus moves to PowerShell 7 as a cross-platform Long-Term Servicing release aligned with the .NET yearly cycle. Significant technical improvements include the introduction of null propagation, parallel processing capabilities, and a new module management system designed to replace the deprecated v2 architecture. While legacy Windows-specific modules now access via implicit remoting, the product strategy excludes future in-box inclusion in Windows due to mismatched support lifecycles.
- Jane Street58 min
Safe at Any Speed: Building a Performant, Safe, Maintainable Packet Processor
Jane Street engineers optimized their OCaml-based market data distribution system to handle NASDAQ's peak load of 4 million messages per second while maintaining zero-allocation on critical paths to avoid garbage collection delays. By leveraging PPX preprocessors, immediate integer options, and a domain-specific language for protocol generation, the team reduced per-message processing latency from five microseconds to under 750 nanoseconds. This approach demonstrates that strict single-core, low-latency performance targets can be achieved with high-level functional languages through aggressive inlining and careful memory management rather than resorting to lower-level systems code.
- Jane Street1h 9m
A Language-Oriented System Design
The Ontology system presents a dual-language architecture that manages organizational permissions through an English-facing interface backed by a dependently typed, deductive database engine. It distinguishes between hard-coded primitives, extensional tables, and intentional logical rules to enforce strict type safety, ensuring that data retrieval returns verifiable proof objects and automatically maintains referential integrity through cascading deletion and trash mechanisms. While the internal Prolog-like inference engine mitigates undecidability risks via execution budgets, the design allows for extensible permission modeling by uploading new type declarations without requiring code-level system upgrades.
- Jane Street1h 18m
Lindsey Kuper: Abstractions for Expressive, Efficient Parallel and Distributed Computing
Lindsey Kuper, Ron, Laura, Kunle Olokutun, Asante Toney, Neil Conway, Peter Alvaro, Carl, Nikki Vazou
The presentation outlines a unified framework for deterministic parallel computing that utilizes Lattice Variables (LVARs) and Conflict-Free Replicated Data Types to ensure correct distributed executions while enabling high-performance acceleration in Julia and Python through non-invasive domain-specific languages. Complementing these runtime systems, the speaker details a formal verification approach for safety-critical neural networks that employs lazy ReLU splitting within SMT solvers to manage the exponential complexity of non-linear activations. Future research aims to democratize solver development by integrating lattice theories directly into SMT architectures and verifying LVAR constraints through advanced type systems.
- Jane Street1h 7m
Marius Eriksen: Distributed, Incremental Dataflow Processing in the Cloud with Reflow
The Braille bioinformatics team has developed Reflow, an open-source workflow engine designed to treat biological data pipelines as functional programs rather than static dependency graphs. By enforcing a strict data model and dynamic cloud resource provisioning, the system automatically parallelizes tasks, caches results through referential transparency, and ensures reproducible computations via versioned "data spaces." Currently adopted by Grail, the Chan Zuckerberg Institute, and several biotech startups, Reflow reduces infrastructure complexity while enabling efficient incremental updates to massive genomic and machine learning pipelines.
- Jane Street1h 14m
Introduction to Incr_dom: Writing Dynamic Web Apps in OCaml
Jane Street engineers presented IncurDOM, an internal OCaml web UI framework designed to handle high-frequency updates and datasets exceeding 10,000 rows while avoiding browser lag. The demonstration highlighted how incremental computations, partial rendering, and strict adherence to the Elm architecture enable efficient state management and automatic code sharing between server and client logic. Attendees examined practical trade-offs against React and BuckleScript, noting specific optimizations like `IncrMap` that reduce reconstruction costs while identifying future needs for explicit component abstractions and dedicated testing tools.
- Jane Street1h 3m
OCaml All The Way Down
This presentation outlines a hardware design framework utilizing the OCaml-based HardCAML domain-specific language to generate FPGA logic for custom peripherals like LED drivers, SPI sensors, and CORDIC math cores. The implementation targets the MicroBlaze soft CPU architecture, executing OCaml bytecode via a ZINC interpreter while leveraging standard Xilinx place-and-route tools to manage complex FPGA resources such as LUTs and DSP blocks. Future roadmaps prioritize full native CPU development within HardCAML, expanded formal verification using the Z3 solver, and the open-sourcing of testing infrastructure to reduce reliance on vendor-provided software components.
- Jane Street1h 13m
Nate Foster: Verifying Network Data Planes
Nate Foster, Bill Hallahan, JK Lee, Cole Schlesinger, Steffen Smolks, Robert Soule, Han Wang, Ron
Cornell Professor Nate Foster and Barefoot Networks have developed an automated verification tool for P4 programs running on programmable data planes to prevent catastrophic network failures caused by configuration errors. This system transforms P4 code into guarded commands to efficiently compute weakest preconditions using the Sacks and Flanagan algorithm, checking safety conditions against the Z3 SMT solver to generate counter-examples for invalid header accesses without requiring manual annotations. By modeling the separation between data and control planes through ghost state, the tool validates programs up to 20,000 lines of code in minutes, establishing a critical foundation for verifying complex software-defined network topologies.
- Jane Street52 min
Effective ML 2011 Harvard CS51 Part 1
Ron Minsky, a technical leader at Jane Street Capital, presented a comprehensive case for prioritizing code correctness and maintainability through strict OCaml design principles that leverage the type system to enforce data invariants and ensure pattern match exhaustiveness. The lecture outlined specific architectural strategies, including mandatory interfaces, uniform naming conventions, and a "reader-over-writer" philosophy, which collectively minimize cognitive load and prevent silent failures in high-stakes financial systems. Additionally, the speaker addressed immediate course logistics by extending the Moogle project description deadline and recommending simple list-based implementations to avoid unnecessary debugging complexity.