Jane Street Blog

https://blog.janestreet.com/ is fantastic. Jane St are a hedge fund doing some seriously heavy lifting in OCaml land, and they sometimes write up really interesting stuff they've done. It's less tutorial-like than fsharp for fun and profit, though.

Oh dear. I love F# and would really want to motivate myself to Learn me some Haskell but these sort of articles discourage me enormously. Please, if there are any people here who have written successfully production code in Haskell that needs to have as low memory footprint as possible and be as performant as possible and have reached something like 1.5 x C level memory consumption, 0.75 x C level performance I would really be grateful for any references. I cannot wait to shed myself from the chains of C++ but stories like these, that follow patterns like these, give me the impression we're not there yet: 1. Awesome language <3 <3 <3 2. Write production code 3. Hit a mysterious performance problem (too much memory, too slow, or both) Note: My interest is in dense computational kernels that are not I/O bound. Edit: The language is obviously great for problems akin to syntax translation, I'm just constantly hoping someone would do something industrial strength with it and tell about it. Jane Street are extremely bullish about Ocaml (https://blogs.janestreet.com/). I've yet to face a similar perpetual love letter to Haskell as a language from industrial users.

Jane Street has a good one at https://blog.janestreet.com/ https://www.redblobgames.com/ is not strictly speaking a blog, but an interested collection of articles on algorithmic concepts you might want to know for writing games.

I highlighted Jane Street's recruiting outreaches specifically, when talking with an R&D unit at a big financial institution. (I also mentioned the tactic of fringe-tech-that-some-heavy-hitters-love. OCaml, Lisp, Rust, Erlang, etc.) When I first heard of Jane Street, it sounded like Yaron Minsky was going around to MIT and such, high-touch, trying to hire just a few people. And later, things like this blog: https://blog.janestreet.com/author/yminsky/ The only negative thing I recall hearing is Jane Street alumni responsible for the infamous FTX and Alameda Research. I don't know whether the individuals were already fully into hopped-up sociopathic/narcissistic thinking in college, or whether their internship and employment experience contributed.

I found Headland's blog post about quant trading useful [0] and as well as their other blog posts [1]. Jane Street's podcast and blog are insightful too [2]. I read somewhere that Dr. Simons (one of the founds of RenTech) has this book in his office [3]. 0. https://blog.headlandstech.com/2017/08/03/quantitative-trading-summary… 1. https://blog.headlandstech.com/ 2. https://blog.janestreet.com/ and https://signalsandthreads.com/ 3. The Econometrics of Financial Markets, https://www.amazon.com/gp/product/0691043019/

Yaron Minksy is probably too busy. But the tech blog is really good too. https://blog.janestreet.com/

Hi HN! I'm Clark, one of the maintainers of magic-trace. magic-trace was submitted before, our first announcement was this blog post: https://blog.janestreet.com/magic-trace/. Since then, we've worked hard at making magic-trace more accessible to outside users. We've heard stories of people thinking this was cool before but being unable to even find a download link. I'm posting this here because we just released "version 1.0", which is the first version that we think is sufficiently user-friendly for it to be worth your time to experiment with. And uhh... sorry in advance if you run into hiccups despite our best efforts. Going from dozens of internal users to anyone and everyone is bound to discover new corners we haven't considered yet. Let us know if you run into trouble!

There are significantly more devs than that (the total is also over 900, that's from 2018). It depends what you mean by "optimizing their engineering stack". They certainly do put a lot of effort into tooling, by necessity since historically there hasn't been much available for OCaml. For an example of stuff going beyond the open source work to make OCaml usable for large projects, see https://blog.janestreet.com/putting-the-i-back-in-ide-towards-a-github… Obviously there is a lot of infrastructure that you need at a FAANG and not at a company with a few hundred devs. But any trading company that doesn't want to pull a Knight Capital needs to make sure their software is correct and reliable (probably to a greater extent than most of a FAANG).

The author's most recent version of KataGo averages about 50 times greater learning efficiency from self-play. See <https://blog.janestreet.com/deep-learning-the-hardest-go-problem-in-th… This covers developments since the initial post, plus the headline problem (which is still open).

Jane Street also is a regular contributor and a heavily uses OCaml for their infrastructure and trading systems too. They have very technical blogs about how they use OCaml which is very interesting. [0] [0] https://blog.janestreet.com/

That's a great phrase from https://blog.janestreet.com/effective-ml-revisited/

I opened this document expecting to have my mind expanded by learning about amazing new techniques for high-level software engineering. I was disappointed. A lot of it just seems to be about release engineering. Yeah, sure, release engineering is really hard and important for a company like Google, but it's of limited general interest. I was particularly disappointed by Google's indifference to the use of smarter languages than the Big 5 (C++, Java, Python, etc). As an example of something that did expand my repertoire as a software engineer, check out this article by Jane Street: https://blog.janestreet.com/testing-with-expectations/

did a quick search to see this post from janestreet: https://blog.janestreet.com/advent-of-fpga-challenge-2025/ But I too was (edit: also still am!) interesed in fpga so I was just scrolling and I found this really really great video (I can't recommend this enough, so much so that before reading your comment that I actually submitted that video as HN submission) The video I am talking about is this: https://www.youtube.com/watch?v=d3nuepnbmC4 (FPGAs Aren’t Processors (Unless You Want Them to Be) || FPGA Deep Dive and Use) Also check out what this guy has been doing with old factory robot machines and using FPGA for them was a really practical use of it and they have another video about it too that you can find on their channel. Some parts of the video especially near the end went really really out of my head but this might be one of the best videos about FPGA judging from the comments and I just really loved it man, so that's about it yeah, I recommend watching the video!

Hmmm...I disagree with a number of statements in the post but I think the following two hypotheses will make for more interesting discussion than some nitpicks: 1. A large part of why many people love Rust is that it's the first time they've used an ML family language. One of the innovations of Rust was to create a community that felt like home to Unix hackers who weren't programming language nerds. 2. Rust is the first language to bring non-GC automatic memory management to the mainstream. It won't be the last and it might well be the worst. Other languages in this space include Swift (as in OP's post), OCaml[1], and Scala[2]. These alternatives take the approach that tracking ownership is not the default, which is fine for the majority of programs and far more ergonomic. There's also a corollary 3. The age of Smalltalk is over. It's now the age of ML. (Amusingly, going backwards in time, from 1983 to 1975). The languages that dominated the 2000s (Ruby, Python, Javscript, PHP) were all more or less derived from Smalltalk (everything is an object! dynamic types! runtime metaprogramming!) The new languages (Rust, Scala, Swift, Kotlin, etc.) are ML family languages. Similarly, back in the day you could learn, say, Ruby, and still be reasonably proficient in Python or JS. Now you can learn, say, Scala, and pick up Rust or Swift reasonably easily. [1]: https://blog.janestreet.com/oxidizing-ocaml-locality/ [2]: https://dl.acm.org/doi/full/10.1145/3618003

Fully agreed with your overall position, but I got a small correction in regards to what you said about fintech. While you are correct in that at a lot of finance companies, devs just act as "support for the real business" (e.g., Goldman Sachs). But there are others where devs and quants pretty much harmoniously run the show. Look at something like Jane Street and their tech blog[0]. Their annual "what our interns have wrought" blog posts grab my attention like nothing else, and from everything I read coming from them, it seems like engineering there is not just "support for the real business". And there are quite a few companies in fintech like this, they just won't be flashed in the mass media due to their relatively small size, but everyone in the industry (and plenty of people on the outside) knows about them. Out of all things, they are known as one of the largest contributors to OCaml language and its ecosystem. Jane Street was just a singular example, and there are other fintech firms of a similar engineering-focused culture. 0. https://blog.janestreet.com/

I completely agree with your take on this. If you know what a "map" is in the CS context, "mappable" makes perfect sense. Names are absolutely critical to the synthesis of knowledge, as they provide a simple symbol by which to refer to complex concepts, which gives you greater power in wielding those concepts. --- Whenever the topic of names comes up, I reread one of my favorite blog posts I've ever come across: "What's in a Name" by Olin Shivers [0]. Here's the thesis statement: > [My thesis advisor, Allen] Newell [...] explained his understanding of names: “They provide distal access.” That is, a name is a local piece of data that stands for some other piece of data, which is presumably large and remote. You can now use that small, convenient, local datum instead of the large, remote thing for which it stands. (If, like me prior to reading this, you're unfamiliar with the word "distal", it means "Remote from the point of attachment or origin." [1]) [0] https://blog.janestreet.com/whats-in-a-name/ [1] https://en.wiktionary.org/wiki/distal#Adjective

Go’s dependency management story is not just “not pretty” it is a total disaster as recent story with hijacked repo had shown. It does not allow proper versioning, repo management, total garbage. And how is making packages is a problem? You jast add opam file and that is all. You can do versioning, pin any opam or git repo, or even some fs resource. Yes ocaml compiler is light years ahead Go’s one in terms of optimizations and code analysis (and even correctness [1]). It is still not as great as haskell’s one, but very good, especially with new lambda middle end. Go compiler is straightforward as hell and can’t do much inlining or optimizations that ocaml can. Windows support was always tier 1 in compiler. Jbuilder also supports windows and even cross-compilation with windows as a target. Opam now compiles on Windows was too. As for libraries opam now have thousands of these and ocaml libraries’ quality is often much higher than the quality of libs of this other imperative language due to quality of language. >go standard library lol no math for ints, no data structures beyond map, but crappy http and Json serialization. [1] https://blog.janestreet.com/proofs-and-refutations-using-z3

Jane Street: https://blogs.janestreet.com/

The biggest change is OPAM, http://opam.ocaml.org/, a top-notch package management system that makes installing OCaml packages much easier. Shameless plug: there's also a newish O'Reilly book, Real World OCaml http://realworldocaml.org, which I think is a big help in learning the language. Oh, and there's OCaml Labs, a new lab at Cambridge University that's dedicated to improving the language. And of course the compiler is constantly making progress. The upcoming 4.02 release is a pretty fun one, which I documented here: https://blogs.janestreet.com/ocaml-4-02-everything-else/ And before that, changes like GADTs and first-class modules landed, which have been quite useful extensions. Really, it's a very active and fun community these days. The language is getting better quite quickly, but mostly in conservative and tasteful ways. The people in charge of the core language have been doing a great job, and the community infrastructure (things like OPAM) have been making big strides as well.

I've been working on the Jane Street reverse engineering puzzle that was posted here a few days ago[0]. As usual I've not made much progress on the actual challenge because I've fallen down a bunch of rabbit holes. So far I've built a digital circuit simulator, a parser for my circuit design language, and now a parser for my simulator language (so I can run the sim on known inputs and have the machine enforce asserts for me). All to avoid the painful memories I have of verilog/vhdl. If I don't come to my senses, the next thing is probably going to be a wave form viewer because I've wanted to use Raylib for a real project for a while now. [0] edit: forgot link - https://blog.janestreet.com/can-you-reverse-engineer-an-asic/

Honestly, I'm scared too. I think both of our countries lack opportunities. If you look at intergenerational mobility, we're pretty similar on average. But on the flip side, I also believe that if you catch the new wave well, you can find something new. That's probably just self-rationalization, though. One post I enjoyed reading was this one [1]. [1]https://blog.janestreet.com/formal-methods-at-jane-street-index/

https://blog.janestreet.com/formal-methods-at-jane-street-index/ I thought this article from Jane Street makes a nice complimentary pairing.

I know it is out of scope for this article, but there are variants where the operations are monadic rather than applicative and the shape of the graph can change depending on values. And also variations with state - where history can be taken into account. Jane street briefly summarizes some options here: https://blog.janestreet.com/breaking-down-frp/ And they have an interesting talk on the trade-offs and how their own system, incremental, evolved: https://blog.janestreet.com/seven-implementations-of-incremental/

Indeed: https://blog.janestreet.com/author/sdolan/ https://signalsandthreads.com/memory-management/#:~:text=Stephen%20Dol…

Nice! Thanks for sharing. The expectation part reminds me of this jane street post [1]. - [1] https://blog.janestreet.com/the-joy-of-expect-tests/

OCaml and OxCaml https://blog.janestreet.com/introducing-oxcaml/

It's easier to reason in FP plus the python paradox [1] [2]. [1]: https://www.paulgraham.com/pypar.html [2]: https://blog.janestreet.com/why-ocaml/

I assume by 'concurrent GC' you mean multicore parallelism in the same process, in which case, yes, OCaml has it now: https://discuss.ocaml.org/t/ocaml-5-0-0-is-out/10974 And Jane Street have long since moved forward into even more advanced territory. They are now trying to add Rust-like ownership guarantees: https://blog.janestreet.com/oxidizing-ocaml-ownership/

> This repository is a package repository for the opam package manager. It contains OCaml with Jane Street language extensions, including all Jane Street packages and necessary patches to external packages for building our libraries. Key features of note include - Locality via modal types - Layout polymorphism for polymorphic unboxed types See https://blog.janestreet.com/author/mslater/ for more.