ApacheBench (ab) pour lancer un nombre de requêtes: ab -n 5000 -c 100 http://tested.example.org/. Le logiciel donne les p50, p66, ... p95, p98, p99 et p100.

Siege : siege -c 100 -r 50 http://tested.example.org/
donne:

Transactions:               5000 hits
Availability:             100.00 %
Elapsed time:               5.09 secs
Response time:              0.07 secs
Transaction rate:         982.32 trans/sec
Concurrency:               66.82
Successful transactions:        5000
Failed transactions:               0
Longest transaction:            3.05
Shortest transaction:           0.00

JMeter en Java nécessite un test plan.

Cassowary en go, mais ils n'affichent pas les erreurs.

k6 de Grafana

Gatling plus complet, mais il faut écrire du code pour chaque tests.

Locust est aussi plus complet avec une UI, mais le programme devient rapidement limité par le CPU.

Conclusion: il n'y a pas un logiciel idéal, autant en essayer plusieurs.

data:text/html can embed things directly in the URL actually.

The bandwith (with linear data) is more efficient than RAM.

Part 1 showed that computers are getting wider, not faster, and that PCIe bandwidth is outpacing DRAM bandwidth.
Part 2 showed that streaming from disk can beat streaming from the page cache.
Part 2.5 showed that with the right hardware and software, streaming from disk can beat a buffer in DRAM. So far I've shown how a sequential read from NVMe is fast, which is a cool trick but not controversial enough.

Big O notation assumes every step costs the same. They don't. The notation defines the shape of the performance curve but not it's slope or magnitude.

Big O notation can't see some limits such as AVL search drops from 4.0M/S to 2.3M/s between 512K and 1M nodes

Better than AVL tree:

• an adaptive Radix tree: walks the bits of the key instead of comparing
• A B+tree: (fat nodes with many keys each, so far fewer levels
• NextArray: extensible array using a specific amount of RAM for pagination such as 1 KiB in RAM

Pour les fonts, je viens d'apprendre qu'il est possible de forcer l'utilisation de la police en local via le src: local("Verdana")".

Le site doit fonctionner sans JS; utiliser le CSS au lieu du JS quand c'est possible; diminuer le poids des images en servant des images plus petite en taille pour le mobile;

Keep public functions for public use. Internal use of public functions should be avoided because they are not meant for these cases. "By proactively making the shared implementation private, the tension is defused. "

Rationale: the goal of a public API is to provide an interface that works best at the call site. If parts of public API are re-used to implement the rest of the API, then there’s a tension between making the interface convenient for the outside user and making it convenient to use from within abstraction itself.

Math.random() is 5 times faster to generate a byte than crypto.getRandomValues().

The 128 bits benchmark shows an increased difference. M̀ath.random() seems 10 times faster with 2 030 250 ops/s compared to 232 590 ops/s.

Wow it's impressive.

Webhooks should be considered ordered logs.

Webhooks spread because they were the cheapest thing a provider could ship (one HTTP POST) and the cheapest thing a consumer could receive (you already had a web server, so you just added a route).

Webhooks-for-replication are a local optimum, and the proof is the pile of workarounds on the valley floor: signature schemes, dedup stores, idempotent handlers, retry queues with exponential backoff on the provider side and dead-letter queues behind them, webhook logs with replay tooling because consumers keep asking for replays, and my 3 a.m. cron. [...] The pile has an economy on top of it. Svix exists so providers don’t have to build webhook delivery; Hookdeck exists so consumers don’t have to build webhook ingestion.

So here’s the thought experiment. What if instead of the provider telling us when there is new information, we ask the provider what new information it has for us since we last checked?

So it's a pull-strategy again.

Send Prefer: stream and the response never ends: each change arrives as it commits, over a connection you opened

Ok that's the strategy: an active connexion streaming the changes.

The draft is available at https://welidev.github.io/scroll/.
It pins down the feed, the cursors, the streaming and polling modes, the checkpoints, tombstones, and retention, and it marks the places where my own confidence is lowest.

Another classless CSS framework

The optimization is there in the standard library and it's hidden behind wrapper types so it doesn't depend on an exact syntax.

I find it completely overkill but maybe I am missing something. The use case for the posts is relevant, because it allows recursion (replies of replies). I don't see a potential widespread usage though.

Using icons as design tokens can be a great idea to switch icon names.

This site lets you rank the Interop 2027 proposals you care about, giving us (the Firefox team) data we can use when reviewing which proposals should be taken on.

The technique is to use:

.example,
.sample {
  display: flex;
}

instead of

.example {
  display: flex;
}

.sample {
  display: flex;
}

Gaining 1-3% on the bundle size is few IMHO. The tool to make it happen is available at https://github.com/j9t/css-dedup

Examples to leverage rust designs to write better code

(from https://flaviocopes.com/download/)