Assorted links for Wednesday, April 9:
- A large scale analysis of hundreds of in-memory cache clusters at Twitter
In this work, we significantly further the understanding of real-world cache workloads by collecting production traces from 153 in-memory cache clusters at Twitter, sifting through over 80 TB of data, and sometimes interpreting the workloads in the context of the business logic behind them.
- Durability: Linux File APIs
[Y]ou should assume your data is corrupt between when a write is issued until after a flush or force unit access write completes. However, most programs use system calls to write data. This article looks at the guarantees provided by the Linux file APIs. It seems like this should be simple: a program calls
write()and after it completes, the data is durable. However,write()only copies data from the application into the kernel’s cache in memory. To force the data to be durable you need to use some additional mechanism. - How Netflix Scales its API with GraphQL Federation (Part 1)
As we’ve grown the number of developers and increased our domain complexity, developing the API aggregation layer has become increasingly harder.
In order to address this rising problem, we’ve developed a federated GraphQL platform to power the API layer.
- Traefik: canary deployments with weighted load balancing
Traefik is The Cloud Native Edge Router yet another reverse proxy and load balancer. Omitting all the Cloud Native buzzwords, what really makes Traefik different from Nginx, HAProxy, and alike is the automatic and dynamic configurability it provides out of the box. And the most prominent part of it is probably its ability to do automatic service discovery.
- Rust vs Go in 2025
Which is better, Rust or Go—and does that question even make sense? Which language should you choose for your next project in 2025, and why? How does Rust compare with Go in areas like performance, simplicity, safety, features, scale, and concurrency?