Phil Eaton

https://vikramoberoi.com

I started writing publicly late last year. It's been tons of effort but it's been tremendously fun and fruitful.

Some of my more-visited or favorite posts:

* A primer on Roaring bitmaps: what they are and how they work -- https://vikramoberoi.com/a-primer-on-roaring-bitmaps-what-they-are-and-how-they-work/. This one ended up on the front page of HN and gets hundreds of visits monthly. I wrote it because it's the post I would have liked to read instead of reading the papers themselves.

* An internship working on "Customers who bought this also bought" at Amazon 16 years ago -- https://vikramoberoi.com/an-internship-working-on-customers-who-bought-this-also-bought-at-amazon-16-years-ago/. I wrote this one as an addendum to throwaway tweet I posted that went viral.

* How I made atariemailarchive.org --
https://vikramoberoi.com/how-i-made-atariemailarchive-org/. I wrote this one when I open-sourced the dataset behind atariemailarchive.org. The dataset got featured in Data is Plural and in a podcast interview I did with Jeremy Singer-Vine.

---

My favorite personal blog to read this past year is Phil Eaton's (eatonphil on HN): https://notes.eatonphil.com/.

I enjoy the subject matter he posts about (a lot of systems work and research, primarily), but his other posts are great too.

His post, "Is it worth writing about?" is a nice inspirational one for folks who want to/have been thinking about writing:…

> What popular languages fall into this category ?

Not all, but many. Going down the list of most popular languages from https://www.tiobe.com/tiobe-index/ -

Python - CPython, PyPy, MicroPython

C - numerous (gcc, clang, msvc, tcc, etc.)

Java - https://en.wikipedia.org/wiki/List_of_Java_virtual_machines

C++ - gcc, clang, msvc, etc.

C# - Microsoft's version and mono

Visual Basic - probably only one implementation

JavaScript - https://notes.eatonphil.com/javascript-implementations.html

SQL - assorted dialects, not sure that counts

PHP - probably only one implementation

ASM - assorted dialects, not sure that counts

Classic Visual Basic - probably only one implementation

Go - only one version that matters, AFAIK

MATLAB - probably only one implementation

R - probably only one implementation

Groovy - probably only one implementation

Ruby - https://opensourcelibs.com/lib/ruby-implementations (Why are there so many in Go?)

Swift - probably only one implementation

Fortran - https://fortran-lang.org/compilers/

Perl - probably only one implementation

Delphi/Object Pascal - there are a decent number of Pascals historically, and FPC and Delphi are the big modern options

Not really. Here’s a comparison of different languages: https://notes.eatonphil.com/parser-generators-vs-handwritten-parsers-survey-2021.html

Most roll their own for three reasons: performance, context, and error handling. Bison/Menhir et al. are easy to write a grammar and get started with, but in exchange you get less flexibility overall. It becomes difficult to handle context-sensitive parts, do error recovery, and give the user meaningful errors that describe exactly what’s wrong. Usually if there’s a small syntax error we want to try to tell the user how to fix it instead of just producing “Syntax error”, and that requires being able to fix the input and keep parsing.

Menhir has a new mode where the parser is driven externally; this allows your code to drive the entire thing, which requires a lot more machinery than fire-and-forget but also affords you more flexibility.

There is work happening on keyword generics[0], which would let a function be generic over keywords like `async` and `const`.

For now the best option to write code that wants to live in both worlds is sans-io. Thomas Eizinger at Fireguard has written a good article about this[1] pattern. Not only does it nicely solve the sync/async issue, but it also makes testing easier and opens the door to techniques like DST[2]

I have my own writing on the topic[3], which highlights that the problem is wider than just async vs sync due to different executors.

0: https://github.com/rust-lang/effects-initiative

1: https://www.firezone.dev/blog/sans-io

2: https://notes.eatonphil.com/2024-08-20-deterministic-simulation-testing.html

3: https://hugotunius.se/2024/03/08/on-async-rust.html

I'm not sure about SRE specific or CI specific writing but at risk of answering another question, here's what comes to mind for me.

In the Operations space my favorite writer is Charity Majors, although a lot of what she talks about isn't OPs specific:

https://charity.wtf/

Rachel by the Bay is also great:

https://rachelbythebay.com/w/

Totally not related, but Phil Eaton's posts on how databases work are super interesting and lack fluff.

https://notes.eatonphil.com/

In terms of CI and builds, I try to write some on this topic for the Earthly Blog. My Bazel article was recently on Hn. Here are my posts:

https://earthly.dev/blog/authors/adam/

Warning though, I also write about lots of other stuff. Are there specific CI topics you'd like to see covered?

Reading books is great! And curating a list is useful and fun.

But you have to be pretty careful when you say things are a "must" since that's... pretty hard to prove (and can just make people feel bad). And the proof has already been pointed out as not true in this thread. Unless we all want to start evaluating eachother's programming ability virtually.

Again, lists and reading is great! And it's probably better to (try to) read any of these books than not.

But for the folks who try the books and can't get through them (like me and SICP), I'd say don't worry about it.

I have my own [0] list of books I think devs should read but I just try not to say "must read".

[0] https://notes.eatonphil.com/books-developers-should-read.html