Anil Madhavapeddy

An extremely random fact I noticed when writing the companion article [1] to this (an OCaml experience report): "Docker, Guix and NixOS (stable) all had their first releases during 2013, making that a bumper year for packaging aficionados." Now we get coding agent updates every week, but has there been a similar year since 2013 where multiple great projects all came out at the same time? [1]: https://anil.recoil.org/papers/2025-docker-icfp.pdf

Hi! I'm from the EC2 team. This is a great tool to help uncover if CPU and memory NUMA within a VM aligns to the physical host or not: https://www.cl.cam.ac.uk/research/srg/netos/projects/ipc-bench/ Paper from the USENIX 2012 conference: http://anil.recoil.org/papers/drafts/2012-usenix-ipc-draft1.pdf EC2 instances have been NUMA optimized since we launched our CC1 instances in 2010. I encourage you to try ipc-bench on your cloud provider of choice, if CPU and NUMA affinity is important to your workload.

Unfortunately, SML has no industrial users. At least, that I've heard of. It's a language that's used mostly in teaching and academic research. First ML I used was SML/NJ in my intro CS class, and haven't seen it since. Whereas OCaml has a many industrial users and is widely deployed. My favorite example is of course management layer for the Xen hypervisor[0][1], but there are more as well[2]. Adam Chlipala has a writeup[3] on comparing SML and OCaml that may be of interest to the discussion. [0]: https://github.com/xapi-project [1]: http://anil.recoil.org/papers/2010-icfp-xen.pdf [2]: http://ocaml.org/learn/companies.html [3]: http://adam.chlipala.net/mlcomp/

I think it's already taking off and the key difference between now and then is virtualisation. This provides a stable target and avoids the pain of having to deal with device drivers while also providing good isolation. Another way of looking at it is that the libOS's time has come. Early versions like Exokernel and Nemesis were ahead of their time but the wider ecosystem is now ready to make use of new implementations. Also, Unikernel is a more general term, whereas Exokernel was largely for a specific project. You might find the following two references useful. http://queue.acm.org/detail.cfm?id=2566628 http://anil.recoil.org/papers/2013-asplos-mirage.pdf

You can read the original paper about Mirage here: http://anil.recoil.org/papers/2013-asplos-mirage.pdf (it's a pretty easy read for something with an abstract). I love this idea so much. There's also OSv which targets the JVM instead of OCamL. It's an open source commercial enterprise. https://github.com/cloudius-systems/osv

https://anil.recoil.org/papers/2011-cufp-scribe-preprint.pdf > Mu is a true Haskell dialect in that code written in Mu may be compiled with a Haskell compiler. > [...] > Their experience with strict semantics has been positive. Particularly useful is the ease of obtaining meaningful stack traces, tracking resource usage, […] My point was that "if S&C is to count as a Haskell success story (which it's often touted as), then it's fair to point out that it's a codebase where eager evaluation is used throughout." Please note the 'if'. The article presents S&C's large Mu codebase as a Haskell success story. In this context it's perfectly fair to point out that Mu has a strict semantics. If you want to insist that Mu is an 'entirely different' language to Haskell then that's fine. As with natural languages, there's no objective line to be drawn between 'different dialect' and 'different language'. However, anyone who holds to this view obviously cannot follow the article in presenting a large Mu codebase as an example of Haskell in production.

If you find this interesting you may want to read about this more current research: http://www.openmirage.org/ To quote from the vision paper http://anil.recoil.org/papers/2010-bcs-visions.pdf Mirage is written in the spirit of vertical operating systems such as Nemesis [17] or Exokernel [10], but differs in certain aspects: (i) apart from a small runtime, the operating system and support code (e.g., threading) is entirely written in OCaml; and (ii) is statically specialised at compile-time by assembling only required components (e.g., a read-only file system which fits into memory will be directly linked in as an immutable data structure). These features mean that it provides a stronger basis for the practical application of formal methods such as model checking; and the removal of redundant safety system checks greatly improves the energy efficiency of the system.

To be completely honest, I currently only use LLMs to assist me in writing documentation (and translating articles), but I know that other people are looking into it: https://anil.recoil.org/wiki?t=%23projects

This is good though it's not clear whether these papers will appear in the PMC Open Access subset (https://pmc.ncbi.nlm.nih.gov/tools/openftlist/) and be bulk downloadable. I've been doing some work with colleagues at Cambridge and Imperial over the last year on using LLMs to improve evidence synthesis, primarily trying to find papers on the effectiveness of certain Conservation interventions. It's becoming clear that you really need to move beyond screening papers only by title and abstract - there's often information buried deep within papers that can only be found with access to full text. My colleague Anil Madhavapeddy has written a bit about our adventures in trying to ingest full-text academic papers: https://anil.recoil.org/notes/uk-national-data-lib

Signals and Threads had an interview with Anil Madhavapeddy last year: https://signalsandthreads.com/what-is-an-operating-system/ He talked about the work to put a multicore-ready memory model[1] and GC[2] under OCaml. [1] https://anil.recoil.org/papers/2018-pldi-memorymodel.pdf [2] https://arxiv.org/abs/2004.11663

I was basing off of this CUFP report regarding Standard Chartered's use of Haskell. http://anil.recoil.org/papers/2011-cufp-scribe-preprint.pdf > Their experience with strict semantics has been positive. Particularly useful is the ease of obtaining meaningful stack traces, tracking resource usage, debugging and exception propagation. The chief downside of strict semantics, in their experience, is the increased difficulty of modular composition FWIW, I am a bit jealous of how laziness makes it easier to achieve function composition, and that was something that I wish was easier in strict semantics.

Like this awesome guy from CompSci: http://anil.recoil.org/projects/

>>But in Haskell you can get anything done :-) Yeah, only if you are willing to spend anything (e.g. insanely large amounts of time) on it :( Please correct me if I am wrong, but for any large project, Haskell actually adds more woes (e.g. laziness induced problems, no good debugging support) than the ones it addresses. The Standard Chartered people had to invent a new language (mu) [1] which doesn't have laziness and the horrors associated with it. BTW, you can get anything done even in (any Turing complete) assembly language too! [1] http://anil.recoil.org/papers/2011-cufp-scribe-preprint.pdf Edit: added the Standard Chartered example

That's what I'm thinking. Take a look at http://spin.atomicobject.com/2014/09/27/reimagining-operating-systems/ for an overview of what's going on in this area. If you're running containers on a hypervisor, with files on storage servers elsewhere, most of the Linux kernel is dead weight. Most of the kernel can be replaced by a modest glue library. Here's one, written in OCaml: http://anil.recoil.org/papers/2013-asplos-mirage.pdf As containers catch on, we'll see more systems specialized to run nothing but containers. They will be much simpler than Linux or Windows. System administration will be external, as it is for cloud systems like Amazon AWS now.

Responding to pjmlp, a cool project I saw recently that's related to the ones you mentioned is Unikernels [1]. They noticed that a challenge faced by a lot of those projects is hardware support--each OS has to ship with a huge set of drivers to be widely usable. They sidestep this by targeting a VM, which exposes a single hardware interface no matter what it's running on. [1]: http://anil.recoil.org/papers/2013-asplos-mirage.pdf

also, there's Real World Ocaml beta, publically available. In this case, beta means manuscript has been commented on by many qualified reviewers already, http://anil.recoil.org/2013/06/17/real-world-ocaml-beta-available.html

At a guess I'd say it's because this pathway has already been mapped out by some OCaml researchers: http://anil.recoil.org/papers/2010-hotcloud-lamp.pdf

It's back up now; the ML TCP stack was running a pcap dumper for debugging, which didn't cope well with a hackernews link. Hacking is going pretty well on Mirage. The longer-term plan is to generalise the support libraries to work with other languages (particularly HalVM and GuestVM for Java), but it's far simpler to work with just OCaml for getting the first cut out. The Xen Cloud toolstack (also written in OCaml) is currently being adapted to support low-latency microkernel establishment, which will remove much of the hassle of coordinating multiple Mirage 'processes'. Another interesting performance-related aspect has been the heavy IPC workloads that result from using many VM-VM interconnects. Some early benchmarks in http://anil.recoil.org/papers/2012-resolve-fable.pdf .

In a similar (albeit higher-level) vein, see https://github.com/avsm/melange, @avsm's type-safe network applications in OCaml. Edit: more details at http://anil.recoil.org/papers/2007-eurosys-melange.pdf.

Ocaml is simple, expressive and fast. While it suffers in terms of libaries and community support it makes a good systems language and is fantastic for expressing complex algorithms and data structures. If that doesn't interest you, try some of these: http://anil.recoil.org/papers/2010-hotcloud-lamp.pdf http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.64.1016&r… http://perso.eleves.bretagne.ens-cachan.fr/~dagand/opis/opis_presentat… http://linkinghub.elsevier.com/retrieve/pii/S0167642306000712 http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.156.7722&…

I think the AI portion is not just something that ought have a toggle, but it should not be part of the platform. Somewhat recently, the ACM (one of the premier publishers for computer science) integrated AI-generated summaries for all papers, and it made these summaries appear in place of author-written abstracts; to find the abstract, users had to use a toggle. The ACM argued that this was a benefit. After significant community pushback, the ACM has swapped things: author-written abstracts now appear first, but users are still offered a toggle to access AI-generated summaries instead. As highlighted by professor Anil Madhavapeddy [1], the AI summaries are often factually incorrect, sometimes obviously, but often subtly. This sentiment was corroborated by numerous colleagues of mine less publicly: they checked the AI-generated summaries of their own papers, and for almost every paper were able to identify at least one factually incorrect or significantly misleading statement. Some people argue that AI-generated summaries help to democratize academia; I think instead they are democratizing misunderstanding. The models fundamentally lack the capacity to "understand" when what they say is wrong or misleading. It is not uncommon that I have students in office hours with severe misgivings about our course material because they asked an LLM some innocuous question to which they thought surely the LLM would generate an accurate response. The course material is, of course, drawn…