Latest Interviews

Trustworthy Human-AI Collaboration in a Live Type-Theoretic Computational Commons

Cyrus Omar

Hazel addresses the "gap problem" in traditional programming by implementing a live execution environment that uses visual "holes" for error recovery and instant probes to provide immediate feedback on code changes. The system enforces a pure functional design with incremental memoization to enable real-time data flow analysis, while integrating advanced security measures like object capabilities and formal verification to safely coordinate human-AI collaboration. Future iterations aim to solve scalability challenges in multi-agent development through content-addressed versioning and semantic models, ultimately supporting a computational commons where code and data evolve together in a shared, verifiable state.

Wrestling the World Into Rows with Eric Mannes

Eric Mannes, Ron

Eric Manis details Jane Street's evolution from a trading firm into a technology-driven organization by shifting from centralized infrastructure to embedded "desk devs" and launching a scaled alternative data team. The firm navigates complex market mechanics, such as the 2020 negative oil pricing event, by prioritizing rigorous data engineering and physical world insight over pure mathematical modeling. This strategic focus on high-quality unstructured data and specialized hiring practices has enabled the company to transform raw information into actionable trading signals while maintaining robust risk management systems.

Positional Encodings and Group Theory | 3Blue1Brown and Alok Puranik

3Blue1Brown, Alok Puranik, Grant Sanderson

This theoretical framework establishes that valid positional encodings in attention mechanisms are mathematically defined by a minimal set of linearity and translation variance assumptions, resulting in a general form where the transformation matrix is the exponential of a constant matrix. By analyzing the eigenvalues of this matrix, the work classifies existing methods into distinct dynamic behaviors, explicitly identifying Rotary Positional Embeddings (RoPE) as a pure rotation case while recovering ALiBi as a non-diagonalizable construction yielding linear dependence. The analysis concludes that the space of stable, useful encodings is effectively exhausted by combinations of exponential decay, pure rotation, and damped rotation, suggesting that future novel approaches would likely reside in unstable or higher-order polynomial regimes.

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.

Matt Godbolt: Advanced Skylake Deep Dive

Matt Godbolt, Jesper

Matt Godbolt, a prominent C++ developer transitioning to HRT, presents a detailed reverse-engineered analysis of the Skylake-era CPU microarchitecture based on community findings rather than official documentation. The talk dissects critical pipeline stages including the front-end's instruction decoding, the micro-op cache limitations, and the complex register renaming mechanics that define the processor's performance characteristics. Key revelations include specific hardware flaws like the Loop Stream Detector bug, port allocation strategies, and the diminishing returns of increasing architectural register counts compared to the hundreds of physical registers already available.

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.

Why ML Needs a New Programming Language with Chris Lattner

Chris Lattner, Ron Minsky

Former LLVM creator Chris Lattner founded Modular to solve the AI industry's fragmentation by introducing Mojo, a Python-compatible language designed to unify performance and portability across competing hardware vendors. The company generates revenue through enterprise infrastructure solutions rather than licensing the language itself, aiming to replace complex C++ and CUDA workflows with a single release train supporting both NVIDIA and AMD accelerators. This approach seeks to democratize high-performance computing by providing a neutral software foundation that allows developers to build portable AI models without sacrificing hardware efficiency.

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 Thermodynamics of Trading with Daniel Pontecorvo

Daniel Pontecorvo, Ron Minsky, Dan Pontecorvo, Mark Mirchandani, David Abelson

Jane Street's physical engineering team manages a complex lifecycle of data centers and offices, prioritizing microsecond-level latency constraints and evolving from traditional air cooling to high-density liquid immersion solutions for AI infrastructure. The organization deploys proprietary monitoring stacks to prevent catastrophic failures while optimizing Power Utilization Efficiency through economizer cycles and rear-door heat exchangers that handle rack densities up to 170 kW. Their human-centric workspace design leverages modular furniture and circadian lighting to sustain collaboration, supported by a hiring strategy that blends industry veterans with graduates to challenge established engineering assumptions.

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.