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 surroundin...

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 tha...

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...

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 tal...

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.

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.

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.

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.

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.

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

Update: I’m excited to say that we’ve now hired a (great!) technical writer, so the position is closed.

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 f...

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.

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 ...

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.

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.

Our first Jane Street Tech Talk went really well! Thanks to everyone who came and made it a fun event.

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!

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...

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.

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.

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.

Recruiting talented people has always been challenging.

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.

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.

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.

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.

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.

OCaml 4.03 is branched and a first release candidate is imminent, so it seems like a good time to take stock of what’s coming.

In my last post, I gave some simple examples showing how you could use self adjusting computations, or SAC, as embodied by our Incremental library, to incrementalize the computation of virtual dom nodes. In this post, I’d like to discuss how we can extend this approach to more realistic scales, and ...