はてなブックマーク

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. This post will focus on just one of those features: Flambda, a new IR (intermediate representation) in the depths of the compiler designed to allow for better inlining, paired with a set of optimizations leveraging that IR. Why inlining matters If your expectations about i

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 some of the extensions to Incremental itself that are required to get there. Along the way, we’ll di

I’ve been thinking recently about how to structure dynamic web applications, and in particular about the role that incremental computation should play. In this post, I’d like to outline an approach we’ve been experimenting with internally which uses Incremental, a general purpose library for building so-called self adjusting computations. Self adjusting computations are essentially graph-structure

Here’s a post from a talk I gave this last summer during our internship program about why we use OCaml. It spends a lot of time on how OCaml fits into the space of programming language designs, and why we think OCaml is in a real sweet spot in that design space, especially for the kind of work we do at Jane Street. Warning: it’s a very informal talk, with lots of questions and answers from the aud

Posts about interviewing at Jane Street and our internship program We’ve been doing a bunch of work recently on improving the responsiveness of OCaml’s garbage collector. I thought it would be worth discussing these developments publicly to see if there was any useful feedback to be had on the ideas that we’re investigating. The basic problem is a well-known one: GCs can introduce unpredictable pa

When GADTs (Generalized Algebraic Data Types) landed in OCaml, I wasn’t particularly happy about it. I assumed that it was the kind of nonsense you get when you let compiler writers design your programming language. Which is to say that the standard GADT examples all seem to be about the kinds of things that compiler writers do, like embed domain-specific languages or build typed abstract-syntax t

If you were teaching a programming course, what language would you teach it in? I like this question because it has any number of good answers, each quite different from the other, and each emblematic of a different approach to what programming is about. The first formal programming class I took was COS 217 at Princeton, taught by the excellent (and at the time, I thought, terrifying) Anne Rogers.

Posts about interviewing at Jane Street and our internship program Software Engineering Interviews at Jane Street Welcome to our version of the “Technical Interviews at insert your company here” post. This topic has been covered by a lot of people already, so I’m going to do my best to not repeat all of the copious advice already out there. Interviewing, for both the interviewers and the interview

Almost every programming language uses 64-bit integers on typical modern Intel machines. OCaml uses a special 63-bit representation. How does it affect OCaml? OCaml int memory representation Most of OCaml’s types are in memory represented as a header followed by data. The header is a 64-bit integer containing the length of the data and a tag. Tag is a rough classification of the type. The only OCa

This is the last in my series of posts about new features in OCaml 4.02. So far, I’ve discussed how OCaml is getting more like Lisp because of extension points, how module aliases will massively speed up compilation of Core and similar libraries, and how you can simplify your error handling by catching exceptions with match statements. Below, I’ve summarized the other features that strike me as wo

This post is meant to be an introduction to Core_bench, our micro-benchmarking library for OCaml. Core_bench is similar to Haskell’s micro-benchmarking library, Criterion, in that it serves the same overall purpose. It is however not a direct port of Criterion to OCaml, but instead employs a different approach to estimating costs that we think yields better results. We think the result is a benchm

(OCaml 4.02 is entering a feature freeze, which makes it a good time to stop and take a look at what to expect for this release. This is the first of a few blog pots where I’ll describe the features that strike me as notable.) OCaml’s metaprogramming story is kind of messy. The good news is that OCaml has an effective metaprogramming system. It’s called camlp4, and before complaining about it, I w

As anyone who has looked into functional reactive programming (FRP) knows, there are lots of competing approaches to it, and not a lot of conceptual clarity about how they relate to each other. In this post, I’ll try to shed some light, and in particular give you some guide posts for understanding how the different versions of FRP relate to each other. Plus, I’ll show some connections to a similar

Jul 02, 2025 | 13 min read A Higgs-bugson in the Linux Kernel 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....