Latest Interviews

Programming with OCaml's Local Mode | OCaml Unboxed

Jane Street Doe Camel

A Jane Street team member demonstrates practical limitations of the OCaml "Locals" region-based memory management system while optimizing the `best_of_prime_widgets` function to avoid heap allocation. To resolve type mismatches where local lists must escape their regions, the implementation employs a custom zero-overhead `global` wrapper type alongside a recursive map function annotated with `exclave` constraints. Although the solution successfully maintains local allocation for list structures while treating elements as global, the speaker identifies these manual workarounds as sharp corners requiring future improvements through mode polymorphism.

Regions with OCaml's Local Types | OCaml Unboxed

Jane Street researchers introduce a `regional` variant within the OCaml compiler's `locals` feature that treats function parameters as variables permitted to escape their enclosing region exactly once. This mechanism enforces strict type constraints on return values while enabling critical stack allocation optimizations in recursive tail calls and loop iterations. By defining regions around function and loop bodies, the system prevents $O(N)$ space complexity for local data without compromising the language's type safety guarantees.

Exploring the Hidden Secrets within OCaml’s Local Function Types | OCaml Unboxed

Jane Street's OCaml compiler branch enforces strict region safety by automatically inferring hidden `local` annotations on partial applications of functions with local arguments, preventing closures from escaping their intended stack scope. This mechanism triggers compilation errors when such intermediate closures are passed to standard functions like `List.map`, as they attempt to store local data in global heap structures, though these issues can be resolved by fully applying the function or utilizing explicit type expansions. Consequently, the team is considering syntax modifications to function definitions to make these constraints more explicit and prevent accidental region escapes during currying.

Pitfalls with Tail Calls and Locals in OCaml | OCaml Unboxed

Goldfirere

Jane Street researchers developed a "local mode" for their OCaml compiler to optimize memory allocation on the stack, but discovered that standard tail call optimization causes "local value escapes" errors when recursive closures capture variables from a region that ends immediately before the call. To address this, the team introduced a "regional" sub-mode that permits specific values to escape one region boundary, allowing tail-recursive functions to maintain $O(1)$ stack space without explicit `non-tail` annotations, though passing these values through intermediate functions can strip this status and force $O(n)$ allocations. The developers acknowledge that current workarounds like explicit annotations or variable indirection are cumbersome for practical use, prompting a push for better compiler heuristics to automate safe tail calls in future upstream releases.

Stack Allocation with Locals in OCaml | OCaml Unboxed

I

Jane Street is developing an open-source "local mode" branch for the OCaml compiler that reallocates data onto a specialized local stack to eliminate mark-and-sweep garbage collection pauses. By enforcing strict regional scoping where values cannot escape their lifecycle, this architecture enables constant-time deallocation and prevents the cache invalidation and stop-the-world latency inherent in standard heap allocation. The initiative aims to significantly boost low-latency performance by removing the overhead of garbage collection while maintaining memory safety through a novel mechanism called "exclaves."

OCaml Locals Save Allocations | OCaml Unboxed

goldfirere

Jane Street demonstrates how a specialized OCaml compiler reduces memory allocation by introducing the `local` keyword, which restricts value lifetimes to specific function and loop regions. This approach requires replacing standard library functions like `list.iter` with custom implementations that explicitly label arguments as `local` to prevent value escapes, achieving a 50% reduction in word allocations in benchmark tests. Further refinements with the `exclave` keyword and strict type inference drive allocation overhead to near-zero, thereby minimizing garbage collection latency for the experimental feature planned for future upstream integration.

Inferring Locality in OCaml | OCaml Unboxed

The OCaml compiler utilizes an internal allocation discipline that infers local versus global modes for variables and parameters to enable stack-based memory usage and reduce garbage collection overhead. This system prioritizes local inference for arguments while defaulting return values to global to ensure maximum compatibility, with integers serving as a special case that can safely cross mode boundaries under specific annotations. Although this framework enhances performance, current limitations such as standard library functions lacking locality awareness and the need for explicit type signatures to trigger safety checks continue to shape its practical application.

Understanding OCaml Locals as a Mode (with Sub-Moding) | OCaml Unboxed

I

This presentation introduces local and global modes in OCaml as a type system extension that governs memory lifetime and escape properties rather than value structure. The speaker details how these modes enforce safety by preventing local values from escaping their declaration scope while establishing a sub-mode relationship where global values can safely be treated as local. Additionally, the talk outlines four distinct, incompatible function arrow types that strictly regulate argument and result modes to prevent unintended memory escapes, with future work proposed to automate these annotations.

Annotating OCaml Variables and Returns with local_ | OCaml Unboxed

Jane Street is developing an experimental OCaml feature set that enforces strict region constraints through `local` annotations to optimize memory usage and eliminate escaping values. The system introduces the `exclave` keyword to terminate function regions early, enabling specific allocations in the caller's scope while preventing mutable references from capturing local data. Current implementation faces known pitfalls regarding return position rules and compiler error precision, with further refinements planned to address these sharp edges.

Introducing the OCaml Local Mode | OCaml Unboxed

camels

Jane Street is refining the OCaml compiler's type system to introduce a "local mode" feature that enforces function parameters to remain within their execution scope, thereby preventing value escaping. This mechanism guarantees the isolation of mutations and facilitates safer resource management in callback patterns by ensuring local arguments cannot be stored or returned. While the feature remains experimental within the Jane Street branch, it aims to optimize allocation behavior for latency-sensitive code before potential upstream integration.

Performance Engineering on Hard Mode with Andrew Hunter

Andrew Hunter, Ron Minsky

This analysis contrasts the performance engineering strategies of hyperscalers, which prioritize broad infrastructure optimization for massive scale, against Jane Street's focus on deterministic latency reduction for specialized trading systems. The discussion details measurement trade-offs between statistical sampling and hardware tracing, while examining how OCaml engineers overcome memory locality gaps through zero-allocation dialects and low-overhead C interop. Ultimately, the presentation advocates for developing mechanical sympathy and accelerating OODA loops to shift optimization discipline from micro-tuning to systemic architectural design.

A Poet's Guide to Product Management with Peter Bogart-Johnson

Peter Bogart-Johnson, Ron Minsky

Peter Bogart-Johnson, formerly a D.E. Shaw researcher, joined Jane Street three years ago to formalize program management as the firm expanded to over 2,000 employees, successfully transitioning from ad-hoc engineering coordination to a structured discipline that bridges technical and non-technical workflows. His approach emphasized low-latency communication tools and an "anthropological" onboarding strategy that mitigated early engineer resistance by prioritizing empathy and incremental trust-building over rigid frameworks. These efforts enabled a critical 2023 strategic pivot toward machine learning, where program managers now facilitate rapid infrastructure scaling and high-stakes experimentation while balancing consensus-driven decision-making with the urgent demands of new GPU deployments.

Get to Know Us: Ezio Talks Linux Engineering at Jane Street

Ezio

Ezio, a Linux Engineer at Jane Street's London office since 2020, leverages deep theoretical knowledge to automate infrastructure and drive complex troubleshooting within a culture that values humility and consultative decision-making. As the founder of the firm's global Pride Community Group, he secured critical health insurance benefits for trans employees while fostering collaboration across offices in New York, London, Amsterdam, Singapore, and Hong Kong. His experience highlights the firm's emphasis on balancing technical rigor with inclusive social initiatives and advises new hires to prioritize absorbing organizational context before offering suggestions.

The Future of Programming with Richard Eisenberg

Richard Eisenberg, Ron Minsky

Richard Eisenberg joined Jane Street's tools and compilers team to lead the development of "unbox types" for OCaml, a feature designed to eliminate runtime pointer indirections while retaining garbage collection. Previously an eight-year Haskell ecosystem contributor who chaired the Haskell Foundation, Eisenberg brings extensive experience in type theory and compiler design to address OCaml's memory representation challenges. His work involves a careful trade-off between parametric polymorphism and performance optimization, tested internally before seeking community consensus for upstream integration.

A Jane Street Software Engineering Mock Interview with Grace and Nolen

Grace, Nolen, Nolan, Emily Fortuna, Colton Ogden, Todd Kerpelman, Jen Person, Colt McAnlisley, Dan Galpin, Mark Mirchandani

Nolan and Grace, experienced Jane Street employees, co-created a mock interview simulation featuring a unit conversion challenge that evaluates a candidate's graph-based algorithm design and problem-solving collaboration. During the session, the candidate developed a breadth-first search solution to minimize floating-point errors while iteratively correcting structural flaws regarding bidirectional graph construction and edge cases. The exercise underscores Jane Street's emphasis on code clarity, effective communication, and the ability to refine logic through dialogue rather than demanding immediate optimization or perfect syntax.