The Curious Engineer

All blogs / OCaml / F#

Jane Street Blog

blog.janestreet.com

Jane Street Blog Homepage

OCaml / F#FPGA / HDLAI / MLSoftware / engineering practiceEngineering blogs

’10’15’20’25
Posts
268 from 25 Apr 2008 to 13 Oct 2026
Posting
weekly (26 in the last year)
Kind
company blog
Feed
https://blog.janestreet.com/feed.xml

2026 24

  1. Flex Model: an event-driven feature engineering system
  2. Building and testing a config management orchestrator for Windows
  3. Scaling and benchmarking a critical message bus using a new indexing strategy
  4. How recurring network maintenance exposed 6 bugs
  5. Results from the ASIC puzzle
  6. A resilient kernel log reporter
  7. A FUSE server for our in-house storage backend
  8. What the interns have wrought, special jumbo 2026 edition
  9. What the SP interns have wrought, 2026 edition
  10. Trading off compute for memory with activation checkpointing
  11. What the TDOE interns have wrought, 2026 edition
  12. Mitigating memorization in LLMs
  13. Can you use autoregressive diffusion to generate market data?
  14. A study of sequence weighting at scale
  15. Can you design a chip? Announcing the protocol emulator ASIC competition
  16. Can you reverse engineer an ASIC?
  17. Using OxCaml to implement type-safe reference counting between OCaml and Python
  18. Formal methods and the future of programming
  19. strace-ui, Bonsai_term, and the TUI renaissance
  20. Using group theory to explore the space of positional encodings for attention
  21. Can you reverse engineer our neural network?
  22. Results from the Advent of FPGA Challenge
  23. I design with Claude more than Figma now
  24. Fun with Algebraic Effects - from Toy Examples to Hardcaml Simulations

2025 7

  1. Getting from tested to battle-tested
  2. Advent of FPGA — A Jane Street Challenge
  3. What the interns have wrought, 2025 edition
  4. A Higgs-bugson in the Linux Kernel
  5. Introducing OxCaml
  6. Advent of Hardcaml
  7. How we accidentally built a better build system for OCaml

2024 4

  1. Developer education at Jane Street
  2. ICFP 2024
  3. What the interns have wrought, 2024 edition
  4. Visualizing piecewise linear neural networks

2023 7

  1. What the interns have wrought, 2023 edition
  2. Oxidizing OCaml: Data Race Freedom
  3. We're sponsoring SoME3
  4. Oxidizing OCaml: Rust-Style Ownership
  5. Oxidizing OCaml: Locality
  6. Building reproducible Python environments with XARs
  7. What if writing tests was a joyful experience?

2022 8

  1. Accelerating zk-SNARKs - MSM and NTT algorithms on FPGAs with Hardcaml
  2. Visualizing information propagation in markets
  3. Computations that differentiate, debug, and document themselves
  4. Introducing the Jane Street Graduate Research Fellowship
  5. What the interns have wrought, 2022 edition
  6. Research internships in our Tools and Compilers group
  7. How Jane Street Pairs Interns to Projects and Teams During the Software Engineering Internship
  8. Magic-trace: Diagnosing tricky performance issues easily with Intel Processor Trace

2021 4

  1. Hiring a Developer Educator
  2. Goodbye Core_kernel
  3. What the interns have wrought, 2021 edition
  4. Looking for a developer experience engineer

2020 12

  1. Growing the Hardcaml toolset
  2. Announcing Our Market Prediction Kaggle Competition
  3. Finding memory leaks with Memtrace
  4. Memory allocator showdown
  5. Announcing Signals and Threads, a new podcast from Jane Street
  6. What the interns have wrought, 2020 edition
  7. The Jane Street Interview Process — 2020 Edition
  8. Really low latency multipliers and cryptographic puzzles
  9. Using ASCII waveforms to test hardware designs
  10. Chrome extensions: Finding the missing proof
  11. Watch all of Jane Street's tech talks
  12. Troubleshooting systemd with SystemTap

2019 14

  1. Using Python and OCaml in the same Jupyter notebook
  2. Deep-Learning the Hardest Go Problem in the World
  3. Commas in big numbers everywhere: An OpenType adventure
  4. What the interns have wrought, 2019 edition
  5. Using OCaml to drive a Raspberry Pi robot car
  6. Do applied programming languages research at Jane Street!
  7. A look at OCaml 4.08
  8. Of Pythons and Camels
  9. Thoughts from AAAI 2019
  10. Learning ML Depth-First
  11. Machining the ultimate hackathon prize
  12. Accelerating Self-Play Learning in Go
  13. L2 Regularization and Batch Norm
  14. A tutorial for building web applications with Incr_dom

2018 9

  1. How to shuffle a big dataset
  2. Deep learning experiments in OCaml
  3. What the interns have wrought, 2018 edition
  4. Plans for OCaml 4.08
  5. Repeatable exploratory programming
  6. OCaml all the way down
  7. Putting the I back in IDE: Towards a Github Explorer
  8. Learn OCaml in NYC
  9. Proofs (and Refutations) using Z3

2017 19

  1. Work on the OCaml compiler at Jane Street!
  2. Does batch size matter?
  3. How Jane Street Does Code Review (Jane Street Tech Talk)
  4. Jane Street Tech Talk, Verifying Network Data Planes
  5. Real world machine learning (part 1)
  6. How to design a tree diffing algorithm
  7. Ironing out your development style
  8. Hiring an FPGA engineer
  9. What the interns have wrought, 2017 edition
  10. When Bash Scripts Bite
  11. Looking for a technical writer
  12. Caveat Configurator: how to replace configs with code, and why you might not want to
  13. This is not the performance you were looking for: the tricks systems play on us
  14. Trivial meta-programming with cinaps
  15. One more talk, two more videos
  16. What a Jane Street software engineering interview is like
  17. Jane Street Tech Talks: Verifying Puppet Configs
  18. How to Build an Exchange
  19. A brief trip through Spacetime

2016 14

  1. A solution to the ppx versioning problem
  2. Observations of a functional programmer
  3. What the interns have wrought, 2016
  4. Unraveling of the tech hiring market
  5. Do you love dev tools? Come work at Jane Street.
  6. Let syntax, and why you should use it
  7. ppx_core: context-free rewriters for better semantics and faster compilation
  8. Seven Implementations of Incremental
  9. OCaml 4.03: Everything else
  10. A better inliner for OCaml, and why it matters
  11. Self Adjusting DOM and Diffable Data
  12. Self Adjusting DOM
  13. Incremental computation and the web
  14. Why OCaml?

2015 15

  1. Testing with expectations
  2. Quickcheck for Core
  3. rsync rounds timestamps to the nearest second
  4. No (functional) experience required
  5. Introducing Incremental
  6. Converting a code base from camlp4 to ppx
  7. CPU Registers and OCaml
  8. Reverse web proxy in ~50 lines of BASH
  9. Building a lower-latency GC
  10. Faster OCaml to C calls
  11. Why GADTs matter for performance
  12. A lighter Core
  13. Centralizing distributed version control, revisited
  14. Making making better
  15. 13 Virtues

2014 29

  1. Inspecting the Environment of a Running Process
  2. How to choose a teaching language
  3. Interviewing At Jane Street
  4. What the interns have wrought: RPC_parallel and Core_profiler
  5. What is gained and lost with 63-bit integers?
  6. Clearly Failing
  7. The ML Workshop looks fantastic
  8. Simple top-down development in OCaml
  9. What's in a name?
  10. Inspecting Internal TCP State on Linux
  11. Making “never break the build” scale
  12. Notes on Naming
  13. Reading Lamport, again
  14. Iron out your release process
  15. Scrutinize your code in style
  16. Code review that isn't boring
  17. OCaml 4.02: everything else
  18. Pattern matching and exception handling, unite!
  19. Core_bench: better micro-benchmarks through linear regression
  20. Hiring a compiler engineer
  21. Why change is hard
  22. Better namespaces through module aliases
  23. Extension Points, or how OCaml is becoming more like Lisp
  24. How to fail -- introducing Or_error.t
  25. Disabling Chrome's x-webkit-speech vulnerability
  26. How Does Automount Work Anyway?
  27. Generic mapping and folding in OCaml
  28. Breaking down FRP
  29. Async Parallel

2013 8

  1. 10 tips for writing comments (plus one more)
  2. A module type equivalence surprise
  3. RWO tidbits: the runtime
  4. RWO tidbits: Benign effects
  5. The making of Real World OCaml
  6. What's 2013 + 50? 1969, of course!
  7. Patch review vs diff review, revisited
  8. Hackerschool tutorial at Jane Street

2012 20

  1. Maps, sets, and hashtables in core
  2. Bootstrapping OCaml/async on the Raspberry Pi
  3. Announcing OCaml Labs
  4. Jane Street at OUD
  5. Observer effect and YOU (NSLCD and GetPWNam()-a-plenty)
  6. Repos, RPMs, and bootstraps, oh my!
  7. Speed Up
  8. Finding references to lazily unmounted filesystems
  9. OCaml for the Sysadmins
  10. S-Expressions in ruby
  11. Linux disk crypto, now with ease
  12. ML workshop
  13. Do you solve real problems with FP? Then come talk about it at CUFP!
  14. The adventures in NIC bonding
  15. OpenLDAP, DBD, and you.
  16. Iterative email problem solving with python, Part 2
  17. Iterative email problem solving with python.
  18. Making staging explicit
  19. Fork Core!
  20. Moving files via rsync

2011 16

  1. OCaml, the ultimate refactoring tool
  2. Announcing Async
  3. +'a and -'a
  4. A mailing list for Core
  5. Coming to ICFP/CUFP? Propose a BOF!
  6. Using types to track defaults
  7. Rethinking Univ
  8. Time to register for CUFP!
  9. Dropping history with Mercurial
  10. Core Gems: many happy returns
  11. OCaml is smarter than I thought
  12. OCamlPro and the future of OCaml
  13. Effective ML Revisited (with videos)
  14. Core 0.7.0 is out!
  15. Do you use FP in anger? Then talk about it at CUFP this year!
  16. Effective ML Revisited

2010 10

  1. A trick: recursive modules from recursive signatures
  2. BOFs, Tutorials and Talks, oh my!
  3. Effective ML video
  4. More expressive GADT encodings via first class modules
  5. OCaml as a scripting language
  6. Ensuring that a function is polymorphic in Ocaml 3.12
  7. Making something out of nothing (or, why None is better than NaN and NULL)
  8. Another use for private type abbreviations
  9. Effective ML
  10. CUFP 2010 is coming!

2009 16

  1. Jane Street OCamldocs now available
  2. Core Gems: Time
  3. Optimizing List.map
  4. Core 0.6.0 release
  5. Another JSSP post
  6. Jane Street Summer Project round-up
  7. Designing a code-review tool, Part 2: Patches or Diffs
  8. Designing a code-review tool, Part 1
  9. OCaml in Japan, and its Meeting in Tokyo
  10. What do Haskellers have against exhaustiveness?
  11. Presenting the 2009 JSSP projects
  12. Proposals in, application period is closed
  13. Caml Trading talk at CMU
  14. Do you use FP as a means rather than an end?
  15. Private type abbreviations, what are they good for?
  16. Summer Project '09

2008 14

  1. Lightweight versioning for lightweight protocols
  2. The OSP meeting
  3. A Working Programmer's Guide to Type-Indexed Values
  4. Centralizing distributed version control
  5. Building a better compare
  6. Ask and ye shall receive
  7. The perils of polymorphic compare
  8. Better float unboxing
  9. Folding over fields
  10. The dangers of being too partial
  11. Ensuring that a function is polymorphic
  12. Core Principles: uniformity of interface
  13. Core has landed
  14. using with type on a variant type

Undated 18

  1. OCaml Annoyance #23: type declarations are implicitly recursive
  2. The ML sweet spot
  3. Bind without tears
  4. Variable-argument functions
  5. Typing RPCs
  6. Using let module for matching
  7. Extracting an exception from a module
  8. A universal type?
  9. Talking at Penn
  10. We've got a blog!
  11. HOWTO: Static access control using phantom types
  12. Where FP meets the real world. If you're interested in working at a place where functional programming meets the real world, then apply for a job at Jane Street. Learn more
  13. Who We Are
  14. The Latest
  15. Contact Us
  16. Disclosures & Policies
  17. Privacy
  18. Cookies