Like most places, Jane Street largely teaches developers through a kind of apprenticeship model. A team matching process tries to thoughtfully match new devs to a team that suits them; and from there carefully chosen projects, one-on-one mentorship, code review, and close collaboration with people “on the row” – teammates sitting near you – does most of the rest.

But we also put a lot of effort into more formal, classroom-style teaching. People who work here are curious and and we’ve found that bona fide classes do more than cultivate new skills; they help spread knowledge, including the normally tacit knowledge about what everybody else works on, who the subject-matter experts are, and what hard lessons we’ve learned in recent history as we’ve built new systems and maintained old ones.

Bootcamps and Teach-ins

There are two main sets of classes that developers take when they start at Jane Street: OCaml Bootcamp, which is a kind of OCaml-and-our-tools-101, and Dev Teach-ins, a collection of deeper and more specialized classes.

OCaml Bootcamp is an immersive introduction to the language that usually lasts one or two weeks. It starts with basic exercises to familiarize you with OCaml’s syntax and then gradually ramps up toward more open-ended challenges that have you building small applications using our foundational libraries and tools. Along the way there’s another, secret purpose: OCaml Bootcamp is where we introduce you to the most important of our developer tools, like the build system, testing framework, documentation system, editor integrations, and so on – it’s a ton of stuff, and easier to learn hands-on, in the context of solving problems.

Bootcamp is generally done independently by new full-time hires, and in a classroom form for interns. There are lectures, TAs, some supplementary videos and reading, and students are also encouraged to read along in Real World OCaml, the definitive textbook on the language co-authored by our own Ron Minsky.

Teach-ins don’t start until a little later in your tenure, through the middle of the first year, after you’ve had some time to soak in actual project work. Among other things, they’re designed to help you take a step back and get a broader view of what’s happening around the firm. It can just be too easy to put blinders on once you’re settled into a team.

At the same time, teach-ins introduce students to a wide range of important tools, techniques, and systems. And not just in a one-off, “here’s a quick blog post about it” way, but with time to slow down and work through hands-on exercises.

Each teach-in course lasts 2-3 full days in one of the dedicated Classroom spaces in our offices. Developers are strongly encouraged to attend at least some of the courses, and managers make a point of making space for participants to step back from their ordinary work and really take the time to learn something new.

The Dev Teach-in curriculum

To get a taste of it, here’s the current curriculum. It’s by no means a complete picture of everything we find interesting—the courses and their material are constantly evolving, and there’s also some flexibility in the exact courses each participant takes.

Testing

Done right, tests can be pleasant to write, easy to read and update, and fast and deterministic to run. In a system where you’ve done the work to make this possible, testing is actually fun, and you’ll find yourself doing more of it, which in the end will help you ship more reliable software, faster.

The goal of this teach-in is to show students some of the tools and approaches that Jane Street has built up over the years to achieve these goals. It does this by showing what it looks like to work in a system that’s built for testability from the ground up.

Besides covering workhorse tools like expect tests and property-based tests (using a library called Quickcheck), the teach-in focuses on several tools for writing good tests at larger scopes:

  • Datafetcher, an internal library which automates testing processes (like config generation) that depend on external data sources that are not easy to simulate.

  • Async.Time_source, part of Jane Street’s open source Async library, as a tool for writing testable systems with time-dependent behavior.

  • Netkit, an internal library for writing testable systems that use the network.

Marketdata

Marketdata is a fundamental part of our business, and a shaping force in our technology, influencing everything from datacenter design to trader spreadsheets. The marketdata teach-in is designed to give people who aren’t marketdata devs a sense for what it’s like to work with under the hood. The teach-in involves building a marketdata library from scratch.

It covers the following topics:

  • how an order book works

  • the design of a typical exchange feed (including reliable multicast)

  • the performance constraints that influence the design of our marketdata APIs

  • the challenges of feed normalization

  • common gotchas for marketdata clients

Advanced Functional Programming

This teach-in, designed and run by our OCaml Language team, covers a few advanced functional programming techniques relevant to OCaml language features, library design, and refactoring.

Students start out by seeing how smart use of type system features like parameterized types and GADTs can make APIs safer and more expressive. Practical exercises include API-directed debugging of a system for distributing symbology information to order engines.

Next, students learn how to take advantage of basic algebraic structures to define a highly general, pure data structure called a finger tree—so general in fact that various other general-purpose data structures fall out of different instantiations of the API.

The teach-in culminates with an exploration of techniques like continuation-passing style and defunctionalization. Students apply these to optimize a parallel job system, and then bring everything together in an exercise implementing automatic differentiation from scratch (and using said differentiation to power an image enhancement application).

OCaml Performance

This teach-in focuses on what tools we have to determine where an application is spending its time, and (perhaps more importantly) why. Concretely, students:

  • Learn about the basic tools available for measuring performance: time-stamp counters, inline benchmarks, perf, memtrace (an OCaml-specific tool for measuring allocations), and magic-trace

  • Learn the pitfalls of “microbenchmarks” and how to avoid them

  • Write simple programs which illustrate how performance is dictated by the architecture of the underlying machine—in particular by writing programs that explore the cache hierarchy and learning some low-level details of how the hardware itself operates

  • Understand how to measure performance in the average case, as well as in rare (but critical) code sections

  • Learn some of the peculiarities of OCaml and its foreign function interface

Developing Web Applications with Bonsai

At Jane Street a lot of our UIs used to be old curses-style command-line tools, and we still have plenty of those – they are fast, keyboard friendly, and super flexible – but increasingly we build web UIs, too. We’ve made our own frontend framework, called Bonsai, that was inspired by React and especially by Elm (though its design has diverged reasonably far from those by now).

  • The exercises in this teach-in take you through some of the basics of the framework: the virtual DOM, effects, managing state, re-computing that state incrementally, and managing control flow in a typical web application.

  • But the bulk of the work is building an example app, designed around a partially rendered table of live-updating marketdata.

  • Students leave not just with a completed app but with some experience using Chrome’s debugging and performance tracing tools.

Systems Debugging

The goal of this course is for students to develop a foundation in how computer programs interact with the operating system and the hardware below it, and to build an intuition for where to look when things go sideways. It’s designed to level up students’ systems administration skills. Students work through material covering:

  • Advanced usage of the shell, including subshells, job control and signals, pipelines and redirection, parameter expansion, quoting, and an AWK tutorial

  • The purpose and design of the Linux operating system, with exercises on packaging programs and reverse engineering them with strace, coredumpctl, and gdb

  • Deep dives into memory, including the kernel’s view of memory, and memory virtualization; CPU, the scheduler, and interrupts; network monitoring and debugging; and filesystems, disks, and caches

  • Debugging the behavior of the kernel itself

Taking education seriously

One takeaway from all of this is that education is of central importance here. You can see it from the physical space and the way we use it. We’ve had dedicated classroom space in all of our offices for years, and it gets used constantly. It’s just part of the culture, and it’s treated as a first-class thing – we don’t think of these classes as a diversion from “real work” but as important work in itself.

That’s part of the reason that we’ve started hiring dedicated dev educators who spend their time thinking about how to improve programs like Bootcamp and the teach-ins, develop entirely new materials, and help the people who run these programs to become even better teachers.