We’ve always found strace useful but somewhat hard to work with. Its output is often inscrutable, it’s hard to follow subprocesses or threads, and if you want to filter syscalls you have to rerun the trace with a flag for each one. What you want in debugging is a tool for exploring, refining, etc., but strace can make this difficult.
Jane Street
https://blogs.janestreet.com/category/ocaml/ · 100 posts · history since 2016 · active
26 May
22 Apr
Attention is a computational primitive at the core of modern language models, allowing internal representations to reference and influence each other. It’s how these models handle sequential data in the first place.
24 Feb
A lot of “capture-the-flag” style ML puzzles give you a black box neural net, and your job is to figure out what it does. When we were thinking of creating our own ML puzzle early last year, we wanted to do something a little different. We thought it’d be neat to give users a complete specification of the neural net,…
11 Feb
At the end of last year, we decided to try something new: a challenge that would run alongside Advent of Code, where we asked the community to show us how they could design hardware to solve the same problems. We had no idea what level of participation to expect, but we received a huge number of submissions, many of which…
5 Feb
For a long time I was skeptical of LLMs—whenever I reached for them I was disappointed by the results. Last year I tried Copilot and Cursor to tweak a game I’d built, and neither generated working changes. At a previous job I tried Gemini to outline product briefs and generate wireframes, but ended up throwing them all away. Every time…
6 Jan
I recently ported the Hardcaml_step_testbench library, one of the libraries that we use at Jane Street for Hardcaml simulations, from using monads to using algebraic effects, a new OCaml 5 feature. This blog post walks through what algebraic effects are, why you should consider using them in lieu of monads, and how to actually work with them using the Handled_effect…
3 Dec 2025
Testing is an essential part of building reliable software. It’s a form of documentation, a reminder of mistakes of the past, and a boost of confidence when you want to refactor. But mostly, testing is a way of showing that your code is correct and resilient. Because it’s so important, we’ve invested a lot of effort at Jane Street to…
24 Nov 2025
Update: We got over 200 submissions to this challenge, spanning a wide variety of HDL languages and hardware platforms! We featured our favorite submissions in the results blog post, check it out here
27 Aug 2025
Yet again, we’re at the end of our internship season, and so it’s time to summarize what the interns were up to!
2 Jul 2025
We recently ran across a strange higgs-bugson that manifested itself in a critical system that stores and distributes the firm’s trading activity data, called Gord. (A higgs-bugson is a bug that is reported in practice but difficult to reproduce, named for the Higgs boson, a particle which was theorized in the 1960s but only found in 2013.) In this post…
14 Jun 2025
At Jane Street, we’ve been actively making improvements to OCaml for a long time. Over the last few years, we’ve started to build some fairly ambitious extensions to the language. Our aim is to make OCaml a great language for performance engineering. This work has always been open source, and our hope is to contribute these extensions to upstream OCaml,…
22 Mar 2025
Update: For the 2025 Advent of Code, we ran an Advent of FPGA Challenge where we invited the community to implement their own synthesizable solutions to this year’s puzzles! We got over 200 submissions spanning a wide variety of HDL languages and hardware platforms, check out our favorite solutions in the results blog post
24 Jan 2025
A “build system” is one of the most important tools in a developer’s toolbox. Roughly, it figures out how to create runnable programs from a bunch of different source files by calling out to the compiler, setting up and executing test suites, and so on. Because you interact with it daily, above all it has to be fast – but…
4 Oct 2024
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.
29 Aug 2024
It’s no secret that Jane Street is an active participant in the programming language community, and we’re excited to be attending ICFP 2024, the International Conference on Functional Programming, in Milan next week! Most members of our OCaml Language team will be there, and as usual, we look forward to sharing our work with the wider community. Please see below…
26 Aug 2024
We’re once again at the end of our internship season, and it’s time do our annual review of what the interns achieved while they were here.
22 Jul 2024
Neural networks are often thought of as opaque, black-box function approximators, but theoretical tools let us describe and visualize their behavior. In particular, let’s study piecewise-linearity, a property many neural networks share. This property has been studied before, but we’ll try to visualize it in more detail than has been previously done.
12 Sept 2023
We’re once again at the end of our internship season, and it’s my task to provide a few highlights of what the dev interns accomplished while they were here.
1 Sept 2023
OCaml with Jane Street extensions is available from our public opam repo. Only a slice of the features described in this series are currently implemented.
6 Jul 2023
Jane Street is excited to announce our sponsorship of SoME3, Grant Sanderson and James Schloss’s third Summer of Math Exposition. SoME is a contest that Grant and James created to encourage the development of fun and interesting mathematics education videos.
21 Jun 2023
OCaml with Jane Street extensions is available from our public opam repo. Only a slice of the features described in this series are currently implemented.
26 May 2023
OCaml with Jane Street extensions is available from our public opam repo. Only a slice of the features described in this series are currently implemented.
14 Apr 2023
Our traders and researchers love Python for its agility and for its huge open-source ecosystem, especially when it comes to machine learning. But the heavy use of notebooks can make it difficult to support. Notebooks have a very different lifecycle than regular code, and aren’t always rigorously version controlled. And while most of our code (much of it written in…
9 Jan 2023
At Jane Street we use a pattern/library called “expect tests” that makes test-writing feel like a REPL session, or like exploratory programming in a Jupyter notebook—with feedback cycles so fast and joyful that it feels almost tactile. Having used them for some time now this is the only way I’d ever want to write tests.
7 Dec 2022
In 2022 a consortium of companies ran an international competition, called the ZPrize, to advance the state of the art in “zero-knowledge” cryptography. We decided to have a go in our free time at submitting solutions to both the Multi-Scalar Multiplication (MSM) and Number Theoretic Transform (NTT) tracks, using the same open source Hardcaml libraries that Jane Street uses for…
23 Nov 2022
The Dojima rice market, established around 1716, is widely considered to be the world’s first organized futures exchange. Instead of directly exchanging money for rice on the spot, merchants would agree on a price and future date at which rice and money would be exchanged. This allowed farmers and consumers to hedge their risk. As a result, information about the…
17 Nov 2022
One of the problems we wrestle with at Jane Street is how to understand and manage the costs associated with the positions we hold: things like margin, financing costs, market risk, regulatory capital requirements, and so on. To that end, we’ve built systems that estimate these costs and propose ways to reduce them. Essentially, this is a numerical optimization problem.
30 Aug 2022
We are excited to announce the launch of the Jane Street Graduate Research Fellowship!
25 Aug 2022
We’re once again at the end of our internship season, and it’s my task to provide a few highlights of what the interns accomplished while they were here.
4 Mar 2022
We are excited to announce research internships in our Tools and Compilers group.
14 Jan 2022
Software engineering intern candidates often ask how team placement works and how much input incoming interns have over their teams and projects. We know team placement is an important factor for many students when deciding which internship to accept. We’ve spent considerable time and thought on this process in recent years and hope to demystify the experience with this post.
11 Jan 2022
Intel Processor Trace is a hardware technology that can record all program execution flow along with timing information accurate to around 30ns. As far as I can tell almost nobody uses it, seemingly because capturing the data is tricky and, without any visualization tools, you’re forced to read enormous text dumps.
21 Oct 2021
We spend a lot of time on education at Jane Street. Like, really a lot.
26 Aug 2021
We recently restructured our standard libraries at Jane Street in a way that eliminates the difference between Core_kernel and Core and we’re happy with the result. The new layout should reach the open source world before the end of the year.
9 Aug 2021
It’s the end of another dev internship season, and this one marked something of a transition, since halfway through the season, NY-based interns were invited back to the recently reinvigorated office. Which means that many more of us got the chance to meet and hang out with the interns in person than we did last year. And hopefully the interns…
15 Jun 2021
This role has been filled
1 Dec 2020
I am pleased to announce that we have recently released a slew of new Hardcaml libraries!
24 Nov 2020
Jane Street is running a Kaggle contest based on a real problem with real financial data. If you like ML projects, or think you might, head over and check it out. We think it’s a pretty fun one. The prizes are pretty good too, with a total $100K being paid out.
6 Oct 2020
Memory issues can be hard to track down. A function that only allocates a few small objects can cause a space leak if it’s called often enough and those objects are never collected. Even then, many objects are supposed to be long-lived. How can a tool, armed with data on allocations and their lifetimes, help sort out the expected from…
15 Sept 2020
Since version 4.10, OCaml offers a new best-fit memory allocator alongside its existing default, the next-fit allocator. At Jane Street, we've seen a big improvement after switching over to the new allocator. This post isn't about how the new allocator works. For that, the best source is these notes from a talk by its author. Instead, this post is about…
31 Aug 2020
I’m excited (and slightly terrified) to announce that Jane Street is releasing a new podcast, called Signals and Threads, and I’m going to be the host.
17 Aug 2020
It’s been an unusual internship season.
24 Jul 2020
We’re busy preparing for our software engineering fall hiring season. Over the years we’ve done our best to make our interview process more transparent to candidates. While many candidates show up knowing something about what our interviews look like, much of the information floating around on the internet is outdated or wrong. These past few months have also changed a…
22 Jun 2020
At Jane Street, we have some experience using FPGAs for low-latency systems–FPGAs are programmable hardware where you get the speed of an application-specific integrated circuit (ASIC) but without being committed to a design that’s burned into the chip. It wasn’t so long ago that FPGAs were expensive and rare, but these days, you can rent a $5,000 card on the…
1 Jun 2020
At Jane Street, an “expect test” is a test where you don’t manually write the output you’d like to check your code against – instead, this output is captured automatically and inserted by a tool into the testing code itself. If further runs produce different output, the test fails, and you’re presented with the diff.
17 Apr 2020
Web browsers have supported custom plug-ins and extensions since the 1990s, giving users the ability to add their own features and tools for improving workflow or building closer integration with applications or databases running on back-end servers.
20 Feb 2020
Jane Street has been posting tech talks from internal speakers and invited guests for years—and they’re all available on our YouTube channel:
3 Feb 2020
When we set up a schedule on a computer, such as a list of commands to run every day at particular times via Linux cron jobs, we expect that schedule to execute reliably. Of course we’ll check the logs to see whether the job has failed, but we never question whether the cron daemon itself will function. We always assume…
16 Dec 2019
The cover image is based on Jupiter family by NASA/JPL.
6 Dec 2019
Updates and a New Run
14 Oct 2019
My job involves a lot of staring at large numbers, mostly latencies in nanoseconds, and picking out magnitudes like microseconds. I noticed myself constantly counting digits in my text editor, in my terminal, and in Jupyter notebooks in my browser.
30 Aug 2019
Jane Street’s intern program yet again is coming to an end, which is a nice opportunity to look back over the summer and see what they’ve accomplished.
19 Aug 2019
Back when the Raspberry Pi was first released in 2012 Michael Bacarella wrote a blog post on using OCaml and Async on this little device. Since then installing OCaml via opam has become a pretty smooth experience and everything works out of the box when using Raspbian – the default Raspberry Pi distribution.
16 Aug 2019
As our Tools & Compilers team has grown, the kinds of projects we work on has become more ambitious. Here are some of the major things we’re currently working on:
12 Jul 2019
Now that OCaml 4.08 has been released, let’s have a look at what was accomplished, with a particular focus on how our plans for 4.08 fared. I’ll mostly focus on work that we in the Jane Street Tools & Compilers team were involved with, but we are just some of the contributors to the OCaml compiler, and I’ll have a…
9 Jul 2019
Welcome to another post in our series of how to use OCaml for machine learning. In previous posts we’ve discussed artistic style-transfer and reinforcement learning. If you haven’t read these feel free to do so now, we’ll wait right here until you’re done. Ready? Ok, let’s continue …
13 May 2019
At Jane Street, for the last several years, we have been increasingly interested in machine learning and its many use cases. This is why it was exciting when earlier this year myself and a few of my colleagues had the opportunity to attend the AAAI 2019 conference. We’d like to take this space to share with you some of the…
17 Apr 2019
If you haven’t heard of it, Depth First Learning is a wonderful resource for learning about machine learning.
28 Feb 2019
Jane Street is sponsoring this year’s MakeMIT hackathon, and we wanted to create a prize for the winners that would do justice to the maker spirit of the competition. As makers ourselves – it’s not unusual to find a “software” engineer here who hacks on FPGAs or who has a CNC machine at home – it felt natural to get…
At Jane Street, over the last few years, we’ve been increasingly exploring machine learning to improve our models. Many of us are fascinated by the rapid improvement we see in a wide variety of applications due to developments in deep learning and reinforcement learning, both for its exciting potential for our own problems, and also on a personal level of…
2 Feb 2019
In a previous blog post we detailed how we used OCaml to reproduce some classical deep-learning results that would usually be implemented in Python. Here we will do the same with some Reinforcement Learning (RL) experiments.
29 Jan 2019
This blog post is about an interesting detail about machine learning that I came across as a researcher at Jane Street - that of the interaction between L2 regularization, also known as weight decay, and batch normalization.
15 Jan 2019
At Jane Street, our web UIs are built on top of an in-house framework called Incr_dom, modeled in part on React’s virtual DOM. Rendering different views efficiently in response to changes made to a shared model is a quintessentially incremental computation—so it should be no surprise that Incr_dom is built on top of Incremental.
26 Sept 2018
At Jane Street, we often work with data that has a very low signal-to-noise ratio, but fortunately we also have a lot of data. Where practitioners in many fields might be accustomed to having tens or hundreds of thousands of correctly labeled examples, some of our problems are more like having a billion training examples whose labels have only a…
20 Sept 2018
Last year we held a machine learning seminar in our London office, which was an opportunity to reproduce some classical deep learning results with a nice twist: we used OCaml as a programming language rather than Python. This allowed us to train models defined in a functional way in OCaml on a GPU using TensorFlow.
6 Aug 2018
Yet again, intern season is coming to a close, and so it’s time to look back at what the interns have achieved in their short time with us. I’m always impressed by what our interns manage to squeeze into the summer, and this year is no different.
29 Jun 2018
With the external release of OCaml 4.07.0 imminent, we in Jane Street’s Tools & Compilers group have been planning what we want to work on for inclusion in OCaml 4.08. These days OCaml uses (or at least attempts) a time-based release process with releases scheduled every 6 months. We’re trying to avoid rushing in changes at the last minute –…
22 Apr 2018
Expect tests are a technique I’ve written about before, but until recently, it’s been a little on the theoretical side. That’s because it’s been hard to take these ideas out for a spin due to lack of tooling outside of Jane Street’s walls.
4 Apr 2018
One of the joys of working at Jane Street for the last 15 or so years has been seeing how our software stack has grown in scope. When I started, I was building pretty narrowly focused systems for doing statistical research on trading strategies, and then building systems for executing those same strategies.
27 Mar 2018
Imagine a system for editing and reviewing code where:
16 Feb 2018
Interested in learning OCaml? In the NYC area? Then this might be for you!
15 Feb 2018
People often think of formal methods and theorem provers as forbidding tools, cool in theory but with a steep learning curve that makes them hard to use in real life. In this post, we’re going to describe a case we ran into recently where we were able to leverage theorem proving technology, Z3 in particular, to validate some real world…
20 Dec 2017
As Jane Street grows, the quality of the development tools we use matters more and more. We increasingly work on the OCaml compiler itself: adding useful language features, fine-tuning the type system and improving the performance of the generated code. Alongside this, we also work on the surrounding toolchain, developing new tools for profiling, debugging, documentation and build automation.
31 Oct 2017
This post is aimed at readers who are already familiar with stochastic gradient descent (SGD) and terms like “batch size”. For an introduction to these ideas, I recommend Goodfellow et al.’s Deep Learning, in particular the introduction and, for more about SGD, Chapter 8. The relevance of SGD is that it has made it feasible to work with much more…
29 Oct 2017
It’s time for our next Jane Street Tech Talk. When we’ve solicited suggestions for topics, one common request has been to talk about our internal development process. Our next talk, How Jane Street Does Code Review, should fit the bill. The talk is being given by our own Ian Henry, and discusses how we approach code review, and in particular…
26 Sept 2017
After a summer hiatus, the Jane Street Tech Talks series is back on for the fall! Last we left it, our very own Dominick LoBraico presented on the evolution of our internal configuration methodology and the systems that support it. For anybody that missed it, you can check out a recording of the talk on YouTube.
28 Aug 2017
Trading is a competitive business. You need great people and great technology, of course, but also trading strategies that make money. Where do those strategies come from? In this post we’ll discuss how the interplay of data, math and technology informs how we develop and run strategies.
25 Aug 2017
For those of you interested in what what interns do at Jane Street, here’s a post from former intern Tristan Hume, on his work developing tree-diffing algorithms last summer at Jane Street. It’s a fun (and very detailed!) read.
24 Aug 2017
People seem to enjoy talking about programming methodologies. They give them cute names, like eXtreme programming, Agile, and Scrum; run conferences and build communities around them; write books that describe how to use them in excruciating detail; and manifestos that lay out their philosophy.
16 Aug 2017
Jane Street is looking to hire an engineer with experience in both software and hardware design to work on FPGA-based applications, and on tools for creating such applications.
14 Aug 2017
Intern season is coming to a close, and it’s a nice time to look back (as I’ve done in previous years) and review some of what the interns did while they were here. The dev intern program has grown considerably, with almost 40 dev interns between our NY, London, and Hong Kong offices.
11 May 2017
There are abundant resources online trying to scare programmers away from using shell scripts. Most of them, if anything, succeed in convincing the reader to blindly put something that resembles
1 May 2017
Update: I’m excited to say that we’ve now hired a (great!) technical writer, so the position is closed.
25 Apr 2017
We have a new tech talk coming up on May 17th, from our very own Dominick LoBraico. This one is about how to represent configurations with programs. In some sense, this is an obvious idea. Lots of programmers have experienced the dysphoria that comes from watching your elegant little configuration format metamorphize into a badly constructed programming language with miserable…
20 Apr 2017
It’s often surprising just how much software performance depends on how the software is deployed. All the time and effort you’ve invested in optimization can be erased by a few bad decisions in scheduler policy, affinity, or background workload on a server.
20 Mar 2017
From now and then, I found myself having to write some mechanical and repetitive code. The usual solution for this is to write a code generator; for instance in the form of a ppx rewriter in the case of OCaml code. This however comes with a cost: code generators are harder to review than plain code and it is a…
15 Mar 2017
I’m happy to announce our next public tech talk, called Seven Implementations of Incremental, on Wednesday, April 5th, presented by yours truly. You can register here.
28 Feb 2017
Are you thinking about applying to Jane Street for a software engineering role? Or already have a phone interview scheduled but unsure what to expect? Read on as we walk through an example phone interview with you.
16 Feb 2017
Our first Jane Street Tech Talk went really well! Thanks to everyone who came and made it a fun event.
11 Jan 2017
UPDATE: We are full up. Tons of people signed up for the talk, and we’re now at the limit of what we feel like we can support in the space. Thanks for all the interest, and if you didn’t get into this one, don’t worry, we have more talks coming!
9 Jan 2017
Spacetime is a new memory profiling facility for OCaml to help find space leaks and unwanted allocations. Whilst still a little rough around the edges, we’ve found it to be a very useful tool. Since there’s not much documentation for using spacetime beyond this readme, I’ve written a little intro to give people an idea of how to use it.
8 Nov 2016
Ppx is a preprocessing system for OCaml where one maps over the OCaml abstract syntax tree (AST) to interpret some special syntax fragments to generate code.
27 Oct 2016
I was recently invited to do the keynote at the Commercial Users of Functional Programming workshop, a 15-year-old gathering which is attached to ICFP, the primary academic functional programming conference.
13 Sept 2016
Now that the interns have mostly gone back to school, it’s a good time to look back at what they did while they were here. We had a bumper crop – more than 30 dev interns between our London, New York and Hong Kong offices – and they worked on just about every corner of our code-base.
31 Aug 2016
Recruiting talented people has always been challenging.
30 Aug 2016
In the last few years, we’ve spent more and more effort working on developer tools, to the point where we now have a tools-and-compilers group devoted to the area, for which we’re actively hiring.
21 Jun 2016
Earlier this year, we created a ppx_let, a PPX rewriter that introduces a syntax for working with monadic and applicative libraries like Command, Async, Result and Incremental. We’ve now amassed about six months of experience with it, and we’ve now seen enough to recommend it to a wider audience.
23 May 2016
At Jane Street, we have always been heavy users of pre-processors, first with camlp4 and now ppx. Pre-processing makes the infrastructure a bit more complex, but it save us a lot of time by taking care of a lot of tedious boilerplate code and in some case makes the code a bit prettier.
9 Mar 2016
We finally got a decent recording of one of my favorite talks. This one is about our Incremental library (which I wrote about here), and in particular about the story of how we got to the present, quite performant, implementation.
1 Mar 2016
In my previous post I wrote about Flambda, which is the single biggest feature coming to OCaml in this release. In this post, I’ll review the other features of 4.03 that caught my eye.