Latest Interviews
Showing 16–30 of 30 transcripts.
Clear all filters- Jane Street1h 23m
Memory Management with Stephen Dolan
Stephen Dolan, KC Sivaramakrishnan, Ron Minsky, Mark Mandelmann, Simon Hughes, Matt Sullivan, Mark Blyther, Paul Lewisohn, Simon Verstraeteker
Stephen Dolan discusses advanced optimizations in the OCaml language, detailing how generational, incremental garbage collection and software pre-fetching reduce memory access latency by up to 90%. He introduces local types and unboxed representations to enable safe stack allocation and native memory layouts, thereby eliminating heap overhead for temporary values while maintaining automatic memory safety without manual lifetime annotations. The presentation concludes with a roadmap for integrating multi-core garbage collection and lifting GC barriers to support denser data structures, balancing performance with ergonomic simplicity.
- Jane Street1h 1m
What is an Operating System? with Anil Madhavapeddy
Anil Madhavapeddy, Ron Minsky, Mark Mandelbaum, Mark Blyther
Mirage OS is a pure OCaml unikernel framework that compiles applications into minimal, single-purpose binaries by linking only essential drivers and protocol stacks directly to the kernel. Since its origins as a Cambridge research project to verify high-level language performance, the system has achieved significant industrial adoption, powering Docker for Mac and Windows, Tezos blockchain nodes, and energy-efficient solar sensor networks. By utilizing a library operating system model and advanced features like the LDRF memory model, Mirage delivers enhanced security through a reduced attack surface while enabling scalable multi-core execution in upcoming language releases.
- Jane Street1h 0m
Building a UI Framework with Ty Overby
Ty Overby, a Jane Street engineer since 2018, developed Bonsai to replace the restrictive InkerDOM library with a pure, static directed acyclic graph architecture that enables efficient incremental computation in OCaml. This meta-language framework treats components as universal computation units rather than mere UI views, facilitating deep compiler optimizations like constant folding while maintaining strict encapsulation through local model and action types. Despite facing current challenges regarding CSS class collisions and syntax verbosity, Overby's design prioritizes structural stability and debuggability, drawing inspiration from systems like Blender and Excel to solve the limitations of traditional web platforms.
- Jane Street1h 1m
Writing, Technically with James Somers
James Summers leverages his background as a software engineer to transform Jane Street's institutional knowledge from fragile phone calls into durable, executable documentation systems that mechanically validate technical accuracy. By treating writing as a distinct discipline rather than a secondary coding task, he implements a "literate docs" architecture and social feedback loops to incentivize contributors and combat the curse of knowledge within the organization's rapidly expanding workforce. This strategic shift aims to evolve documentation from an afterthought into a scalable cultural asset that guides diverse reader archetypes while preserving the critical "searchable trails" necessary for a 1,500-employee firm.
- Jane Street1h 3m
An Inside Look at Jane Street’s Tech Internship with Jeanne Van Briesen, Matt Else, and Grace Zhang
Jeanne Van Briesen, Matt Else, Grace Zhang, Ron Minsky
Jane Street's internship program recruits diverse candidates without requiring prior OCaml knowledge, grounding them in a boot camp before assigning them to dual-team rotations on production-critical infrastructure. Recent projects by interns such as Grace Yang and Matt Els have directly implemented risk management features and redesigned API systems, while a rigorous code review culture ensures these contributions are safely integrated into live environments. The transition from intern to full-time engineer involves navigating a steep technical learning curve and balancing feedback dynamics within a community that actively pursues demographic diversity across non-traditional feeder schools.
- 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 8m
Language Design with Leo White
Jane Street compiler team member Leo White discusses OCaml's unique design philosophy, which balances pure mathematical type theory with practical modularity to optimize for compiler construction. He outlines current limitations in memory layout and dependent types that hinder systems programming, while highlighting upcoming features like modular implicits and algebraic effects aimed at resolving compositionality issues without sacrificing safety. The conversation further details Jane Street's collaborative upstream strategy, which uses internal forks to experiment with risky innovations while maintaining rigorous backward compatibility for the broader open-source community.
- Jane Street45 min
Clock Synchronization with Chris Perl
Responding to MIFID 2 regulations, Jane Street engineered a hybrid time synchronization system that combines GPS-driven Precision Time Protocol with Linux-based NTP Interleaved Mode to achieve sub-100-microsecond accuracy across its infrastructure. By leveraging hardware timestamping at the network interface and cross-verifying local and distant time sources, the architecture mitigates standard PTP vulnerabilities while maintaining a simple, inspectable network topology. This design successfully reduces worst-case synchronization errors to approximately 35 microseconds, effectively balancing regulatory compliance with robust fault tolerance.
- Jane Street1h 0m
Python, OCaml, and Machine Learning with Laurent Mazare
Jane Street employs a dual-language architecture that leverages OCaml for robust, statically-typed production systems while utilizing Python for rapid machine learning research and data analysis. Laurent Mazarin highlights how the firm bridges these environments through the PyML library to enable bidirectional communication, though this integration faces technical challenges regarding garbage collection and memory management. To address evolving needs, the organization is exploring Swift for automatic differentiation and investigating algebraic effects in OCaml to achieve fine-grained resource control comparable to Rust.
- Jane Street1h 10m
Compiler Optimization with Greta Yorsh
Jane Street compiler engineer Greta Jorsch presents a strategic shift toward combining formal verification with targeted testing and super optimization to address the undecidability limits of pure verification in compiler design. Her team's implementation of sampling-based Feedback-Directed Optimization in the OCaml compiler achieved 10–20% performance gains by stabilizing runtime behavior and minimizing cache misses while managing the trade-off between portability and architecture-specific micro-optimizations. Jorsch advocates for open-sourcing these performance tooling benchmarks to influence upstream development, emphasizing that modular compiler passes can balance internal innovation with community maintainability.
- Jane Street1h 2m
Multicast and the Markets with Brian Nigito
Over the past two decades, securities exchanges have transitioned from physical floors to highly regulated, electronic ecosystems where ultra-low latency determines competitive advantage. To achieve this, firms utilize specialized networking architectures like UDP multicast and co-located hardware to distribute market data faster than standard internet protocols allow, while relying on custom recovery layers and sequencer models to ensure transactional reliability. As hardware speeds approach 25 Gbps, the industry is increasingly shifting from general-purpose servers to specialized FPGAs and custom network cards to manage serialization delays and maintain deterministic performance.
- Jane Street58 min
Build Systems with Andrey Mokhov
This presentation analyzes the historical evolution of build systems, highlighting the enduring dominance of `Make` and its specific technical limitations regarding scalability and complexity, as illustrated by the GHC migration to Hadrian. It introduces a theoretical framework that decomposes build architectures into schedulers and rebuilders to propose innovations like Cloud Shake, while examining industry-specific implementations at Jane Street, such as the Dune and Jenga systems. The discussion concludes by exploring emerging trends toward fine-grained incrementality, IDE integration, and the broader convergence of build tools with general-purpose incremental computation models.
- Jane Street59 min
Programmable Hardware with Andy Ray
Jane Street leverages FPGA and ASIC hardware to achieve deterministic, line-rate processing for high-frequency financial trading, overcoming the latency and scalability limitations inherent in general-purpose software. To modernize this engineering workflow, the firm utilizes HardCAML, an open-source domain-specific language built on OCaml that enables composable, test-driven hardware design comparable to modern software development. By releasing specialized libraries and realistic examples, Jane Street aims to lower the barrier to entry for complex hardware engineering and accelerate industry-wide adoption of rigorous, software-style verification practices in chip design.
- 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.
- Jane Street1h 13m
Caml Trading
Jane Street Capital, a proprietary trading firm operating in four global cities, transitioned its primary development stack to the functional programming language OCaml to satisfy critical demands for absolute correctness, high performance, and code maintainability. This adoption enables the firm's 35 core developers to leverage OCaml's powerful type system and algebraic data types for static exhaustiveness checks, ensuring the rigorous standards required to process billions of dollars in daily equity trades without error. While the language presents challenges in ecosystem maturity, the firm has actively mitigated these gaps through its Jane Street Summer Project and achieved superior hiring outcomes by attracting engineers skilled in functional paradigms.