Scalable, interactive data visualization
Mosaic is an extensible framework for linking databases and interactive views.
Il y a six mois presque jour pour jour, je quittait d’un poste à responsabilité chez un fournisseur cloud souverain afin d’explorer une idée qui avait fini par m’obséder.
Tous les fournisseurs de cloud existants, que ce soit les hyperscalers (AWS, Azure, GCP, Alibaba Cloud), ou les acteurs locaux/souverains (OVH, Scaleway, Outscale, Cloud Temple, Celeste, etc.), s’appuient sur des principes technologiques qui célèbrent leurs 20 ans cette année.
Le IaaS (Infrastructure as a Service) qui sert de couche de base à l’ensemble des autres services (VM évidements, base de données as a service, Kubernetes managé, API Gateway, Event manager, Function as a service, etc.), s’appuie systématiquement sur trois principes :
- La virtualisation du compute : on découpe un gros serveur en plus petites machines virtuelles,
- La virtualisation du stockage : les disques attachés à ces machines virtuelles proviennent en fait de systèmes de stockage mutualisés auxquels les gros serveurs accèdent via le réseau,
- La virtualisation du réseau : les clients doivent être isolés entre eux (multi-tenant), leurs VMs doivent pouvoir communiquer au sein d’un réseau isolé des autres clients. Cette isolation passe par la construction de réseaux virtuels au-dessus du réseau “physique”.
C’est AWS en 2006 qui a mis en pratique puis théorisé ce type d’architecture.
Bien qu’elle présente des avantages (que je détaillerai), elle n’est pas exempte d’inconvénients (que je vais aussi détailler).
À force de nager dans cet environnement, les limites et inconvénients ont fait naître en moi une frustration grandissante au point de me pousser à quitter mon poste pour répondre à cette question simple : aujourd’hui, 20 ans plus tard, compte tenu des progrès logiciels et matériels, compte tenu de l’évolution dans la façon dont les entreprises consomment le Cloud, y’aurait-il une autre façon de faire ?
Une façon plus efficace, plus performante, moins énergivore et moins coûteuse.
C’est pour tenter d’y répondre que nous avons fondé unStack avec mes deux associés : Tristan et Philippe.
Les limites des principes actuels
Avant d’essayer de répondre à la question, il est important de comprendre pourquoi elle se pose. On pourrait simplement se satisfaire de l’existant considérant qu’il représente une forme de consensus et de standard établi.
Commençons par en détailler un peu les principes et surtout les limites.
X11 display server written in x86_64 Linux assembly. No libc, no toolkits, no FreeType, no Mesa, no Xlib. Just NASM source, direct syscalls, the X11 wire protocol on a Unix socket, and the kernel's DRM/KMS + evdev interfaces.
Long-range goal: serve enough of the X11 wire protocol (core + SHAPE + RENDER + XKB + COMPOSITE + DAMAGE + RANDR + MIT-SHM + XInput2 + XVideo) to host the whole CHasm desktop plus arbitrary X clients — Firefox, VS Code, GIMP, Inkscape — all software-rendered, all on a stack written end-to-end in asm.
Modern software is 43x slower than it was twenty years ago, and the people building it cannot tell you why. This is the bill for forty years of "hardware will catch up." For two decades the industry traded performance for convenience and called it progress.
Wirth's Law became a roadmap. Dennard scaling died in 2005 and nobody on the team noticed.
A "Hello World" now ships with 1,847 dependencies, allocates 487 MB of memory, and takes three seconds to draw a window.
The de-bloating is what happens when the stopwatch finally wins the argument: Rust at Cloudflare, Zig under Bun, Mojo under the Python data stack, Go quietly eating the JVM.
The layer count is the bug. This video is the diagnosis.
━━━━━━━━━━━━━━━━━━ RELATED VIDEO ━━━━━━━━━━━━━━━━━━
If this was the diagnosis, the next one is the receipt. Watch it after this one: "Stop Buying RAM. Read This Instead. (The Tab Tax)"
━━━━━━━━━━━━━━━━━━ CHAPTERS ━━━━━━━━━━━━━━━━━━
- 0:00 Two Apps, Twenty Years Apart
- 0:35 The Abstraction Trap
- 2:19 The Benchmark Doesn't Lie
- 3:27 The Low-Level Mindset Returns
- 5:14 The Bill Is Due
━━━━━━━━━━━━━━━━━━ KEY CONCEPTS COVERED ━━━━━━━━━━━━━━━━━━
- Wirth's Law (Niklaus Wirth, 1995): software gets slower faster than hardware gets faster
- Dennard scaling and the end of single-thread CPU performance growth around 2005
- The abstraction trap: why component libraries on top of design systems on top of runtimes on top of browsers stopped being free
- The Chromium runtime tax and why excellent engineers inside Electron lose to the stopwatch
- "Clean Code" as superstition: when a style guide becomes a religion at the cost of an order of magnitude
- The low-level mindset returning as economics, not nostalgia
━━━━━━━━━━━━━━━━━━ TOOLS AND LANGUAGES MENTIONED ━━━━━━━━━━━━━━━━━━
- Electron and the Chromium runtime tax
- Rust, Cloudflare Pingora (one trillion requests a month), Discord read-states, the Windows kernel rewrite
- Zig and the Bun runtime
- Mojo and the Python data-science stack (NumPy, CUDA)
- Go: the quiet boring default that ate the JVM
- hyperfine for cold-start benchmarking
- npm and the 1,847-dependency baseline
━━━━━━━━━━━━━━━━━━ FREQUENTLY ASKED QUESTIONS ━━━━━━━━━━━━━━━━━━
What is Wirth's Law?
Wirth's Law, formulated by Niklaus Wirth in 1995, states that software gets slower faster than hardware gets faster. It was meant as a warning. The industry treated it as a roadmap for forty years.
Why is Electron so slow and memory-hungry?
Electron ships a full Chromium runtime with every app, which means each "native" desktop app is paying the cost of an entire web browser before the application code even runs. In the video, a Rust-based editor opens a 1 MB file 43 times faster and uses 22 times less memory than its Electron equivalent on the same machine.
Is JavaScript or the web stack dying?
No, but the assumption that hardware would keep absorbing software bloat for free is dying. Dennard scaling ended around 2005 and single-thread CPU performance stopped doubling. The "de-bloating" is the industry quietly rebuilding hot paths in Rust, Zig, Mojo, and Go because the layer count became the bottleneck.
What does "the layer count is the bug" mean?
It is the recognition that modern application slowness is not caused by any single bad framework, but by accumulating runtimes on top of runtimes until the abstraction tower itself becomes the dominant cost. Peeling layers, not adding them, is now the optimization.
What should I watch next? "Stop Buying RAM. Read This Instead. (The Tab Tax)" — same channel.
That video is the receipt: the most ordinary place on your machine where the bloat bill arrives first, and the one most people already opened today and forgot about. This one is the diagnosis. Watch them in that order.
What happens if we can't make another CPU...ever?
What fails first? How long would datacenters last? Does the Internet start to fracture?
Of course, it's a hypothetical thought experiment. But it's interesting to think what chips will stand the test of time, and which might fail sooner than you think!
Here are the other channels I mentioned, take a look:
@jeriellsworth made microchips at home, and is an excellent engineer + teacher, go check her out!
/ @jeriellsworth
@KazeN64 is doing wild optimizations with N64 hardware:
/ @kazen64
L'ancien CTO d'Oculus réagit à un «exercice de pensée» sur une «apocalypse des CPU»
John Carmack, une célébrité dans le monde du développement de jeux vidéo et de la technologie, s'est souvent présenté comme un défenseur de l'optimisation logicielle. Ancien directeur technique d'Oculus VR et cofondateur d'id Software (une entreprise américaine de jeux vidéo qu'il a quitté en 2013), Carmack a redéfini ce que nous attendons d'un moteur de jeu et d'une expérience immersive. Récemment, il a lancé un débat audacieux qui pourrait bien bouleverser notre vision de l’évolution technologique : et si, en réalité, nous n’étions pas si dépendants du matériel dernier cri ?
Réagissant à un « exercice de pensée » publié sur le réseau social X (anciennement Twitter), qui parlait d’une « apocalypse des CPU », Carmack a exprimé son point de vue selon lequel le véritable problème n’est pas un manque de puissance des processeurs modernes, mais plutôt l'inefficacité des logiciels actuels. Si l’optimisation logicielle était traitée comme une priorité, il soutient que beaucoup plus de systèmes dans le monde pourraient fonctionner efficacement sur du matériel plus ancien, et ce, sans sacrifier la performance. En d’autres termes, les pressions du marché pousseraient les entreprises à améliorer drastiquement l'efficacité des logiciels si l'innovation matérielle s’arrêtait.
