Engineering-Philosophie: Salvatore Sanfilippo (antirez)

Wichtigste Erkenntnisse

• Sein prägendes Prinzip lautet, weniger zu tun — ein kleines, einfaches System, das man im Kopf behalten kann, schlägt ein großes, funktional vollständiges. Salvatore Sanfilippo, online bekannt als antirez, baute Redis als bewusst kleinen Speicher: single-threaded, im Arbeitsspeicher gehalten, in sauberem C geschrieben und rücksichtslos resistent gegen Funktionen, die das Verständnis erschweren würden. Seine Essays kehren immer wieder zum selben Ziel zurück — der Komplexität, die wir hinzufügen, ohne ihre Kosten zu berücksichtigen.¹⁵
• Er schuf Redis im Jahr 2009, und es wurde zu einer der meistgenutzten Datenbanken der Welt. Redis — der In-Memory-Datenstrukturspeicher — wurde erstmals am 26. Februar 2009 veröffentlicht, entstanden aus seinem Versuch, sein italienisches Startup LLOOGG, einen Echtzeit-Analysator für Webserver-Logs, zu skalieren. Elf Jahre lang war er dessen alleiniger Maintainer und „Benevolent Dictator for Life”.¹²
• Redis ist von Grund auf single-threaded, und das ist eine Stärke. Statt dem Durchsatz mehrerer Kerne nachzujagen, führt Redis Befehle nacheinander auf einem einzigen Thread aus — was Race Conditions und Sperr-Overhead beseitigt, das Modell einfach hält und schnell genug ist, denn, wie es die Redis-FAQ formuliert, „it’s not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound”.⁷
• Er behandelt Code als etwas, das von Menschen für andere Menschen geschrieben wird. In seinen Essays „Writing system software” argumentiert er, dass Quelltext „should be read other than being executed, since is written by humans for other humans”, und dass das Ziel lesbaren Codes darin besteht, „to lower the amount of effort and the number of details the reader should take into her or his head”.⁴

Das Prinzip

„We are destroying software by no longer taking complexity into account when adding features or optimizing some dimension… We are destroying software with an absurd chain of dependencies, making everything bloated and fragile… We are destroying software by making systems that no longer scale down: simple things should be simple to accomplish, in any system.” — Salvatore Sanfilippo, „We are destroying software”⁵

Die meiste technische Arbeit besteht im Hinzufügen. Eine Funktion wird gewünscht, also fügt man sie hinzu. Eine Abhängigkeit würde eine Woche sparen, also zieht man sie hinein. Eine Optimierung würde einem Benutzer helfen, also backt man sie in den Kern ein. Jeder Schritt erscheint für sich genommen vernünftig — und die Summe ist ein System, das keine einzelne Person mehr im Kopf behalten kann. Sanfilippos Instinkt läuft in die andere Richtung. Die gefährlichste Zeile Code ist in seiner Philosophie diejenige, die man schreibt, ohne zuerst zu fragen, ob man sie überhaupt vermeiden könnte. Tu weniger. Die Frage lautet nie „was kann das noch”, sondern „was kann das weglassen und trotzdem noch der Nutzung wert sein”.⁵

Der klarste Ausdruck des Prinzips ist Redis selbst. Es ist bei der Befehlsausführung single-threaded — eine Wahl, die 2009 beinahe widersinnig wirkte, als die Branche darum wetteiferte, mehrere Kerne auszunutzen.¹⁷ Doch die Begründung ist das Prinzip, in Architektur gegossen. Ein einzelner Thread, der jeweils einen Befehl ausführt, kennt keine Race Conditions, keine Sperren, keine zerrissenen Lesezugriffe, keine Fehler, bei denen zwei Threads denselben Schlüssel verändern. Das mentale Modell schrumpft auf etwas, worüber ein Mensch tatsächlich nachdenken kann: Befehle geschehen nacheinander, der Reihe nach, atomar. Und es gibt in der Praxis fast nichts auf, denn Redis ist „either memory or network bound”, lange bevor die CPU zur Grenze wird.⁷ Die Komplexität der Nebenläufigkeit war ein Preis, den antirez für einen Nutzen, den die meisten Workloads nie brauchten, zu zahlen sich weigerte.

Diese Weigerung reist mit zwei Begleitern, die sie erschwinglich machen. Der erste sind reichhaltige Primitive: Statt jedes Problem durch ein einziges Schlüssel-Wert-Modell zu zwingen, liefert Redis Strings, Hashes, Listen, Sets, Sorted Sets und Streams als native Datenstrukturen mit, sodass das richtige Werkzeug meist schon im Kasten liegt.¹ Der zweite ist Code, der für Menschen geschrieben ist: Er besteht darauf, dass Quelltext „written by humans for other humans” sei und dass guter Code „the number of details the reader should take into her or his head” senke.⁴ Gib den Leuten ein paar mächtige Primitive, tu weniger, als sie verlangen, und schreibe das Ganze so, dass eine Person es noch verstehen kann. Das ist das Prinzip, und Redis ist der Beweis.

Kontext

Salvatore Sanfilippo wurde am 7. März 1977 in Campobello di Licata, Sizilien, Italien, geboren.¹ Er wuchs in einer benachteiligten Gegend Südsiziliens nahe Gela auf und zog mit siebzehn nach Palermo, um Architektur zu studieren — einen Abschluss, den er nie beendete, da er seinen Schwerpunkt auf Informatik verlagerte und sich das Programmieren weitgehend selbst beibrachte.¹ Festzuhalten ist, dass er Autodidakt ist, ohne abgeschlossenes Universitätsstudium der Informatik; das Handwerk kam aus der Arbeit selbst, nicht aus einem Zertifikat. Das ist eine wiederkehrende Gestalt in dieser Reihe — der tiefe Praktiker, dessen Autorität auf dem ruht, was er gebaut hat, nicht auf dem, was ihm beigebracht wurde.

Seine erste Spur auf dem Feld hinterließ er in der Sicherheit, nicht bei Datenbanken. Er schrieb hping, einen quelloffenen Paketgenerator und -analysator für das TCP/IP-Protokoll, der für Sicherheitstests verwendet wird.¹ Folgenreicher war, dass er 1998 den Idle Scan veröffentlichte — eine getarnte Port-Scan-Technik, ursprünglich „dumb scan” genannt, die ermittelt, welche Dienste auf einem Ziel offen sind, „without leaving traces pointing back at oneself”.⁶ Sie funktioniert, indem sie einen Seitenkanal ausnutzt: einen untätigen „Zombie”-Drittrechner mit vorhersagbaren IP-ID-Zählern, den der Angreifer als blinden Proxy verwendet, um die Antworten des Ziels zu erschließen.⁶ Die Technik war raffiniert genug, um in nmap und hping aufgenommen zu werden, wo sie bis heute steckt.⁶ Es ist derselbe Instinkt, der später Redis prägte — den eleganten Mechanismus zu finden, der sich unter einem scheinbar schwierigen Problem verbirgt.

Redis selbst entstand aus einem praktischen Skalierungsproblem. In den späten 2000er-Jahren betrieb Sanfilippo LLOOGG, ein italienisches Startup, das einen Echtzeit-Analysator für Webserver-Logs entwickelte, und die vorhandenen Datenbanken kamen mit den Schreibraten, die er brauchte, nicht mit.¹ Also baute er 2009 seinen eigenen In-Memory-Speicher und veröffentlichte Redis am 26. Februar 2009.¹² Es verbreitete sich rasch, und die Sponsorings folgten seinem Aufstieg: VMware stellte ihn im März 2010 ein, Pivotal Software (eine VMware-Ausgründung) übernahm im Mai 2013 das Sponsoring, und Redis Ltd. trat dieses im Juni 2015 an.¹ Elf Jahre lang war er der alleinige Maintainer und BDFL des Projekts, dann trat er am 30. Juni 2020 zurück, gefolgt von Yossi Gottlieb und Oran Agra.¹ Im Dezember 2024 kehrte er zu Redis zurück als Evangelist und aktiver Mitwirkender — der seltene Schöpfer, der auf dem Höhepunkt ging und zurückkam.¹

Das Werk

Redis und seine Datenstrukturen: mächtige Primitive, kein leerer Schlüssel-Wert-Speicher

Beginnen wir mit dem, was Redis anders macht, denn es ist das Prinzip, in ein Produkt gegossen. Die meisten Schlüssel-Wert-Speicher geben einem genau das — einen Schlüssel, einen undurchsichtigen Datenklumpen als Wert und die Last, alles Übrige selbst zu bauen. Redis hingegen liefert reichhaltige Datenstrukturen als Primitive mit: Strings, Hashes, Listen, Sets, Sorted Sets und — seit Redis 5.0 — Streams.¹ Jede ist ein nativer, serverseitiger Typ mit eigenen Befehlen, sodass die Datenstruktur, die man im Anwendungscode von Hand gebaut hätte, bereits in der Datenbank lebt und von jenem einzelnen Thread atomar bearbeitet wird.¹⁷ Der Lohn besteht darin, dass schwierige Anwendungsfunktionen auf eine Handvoll Befehle zusammenfallen, weil das richtige Primitiv schon da ist.

Das schärfste Beispiel ist das Sorted Set (ZSET). Es ist eine Sammlung eindeutiger Mitglieder, die jeweils einen Gleitkomma-Score tragen, und Redis hält die Mitglieder „taken in order” — die Ordnung ist eine Eigenschaft der Datenstruktur selbst, nicht etwas, das auf Anfrage berechnet wird.³ Unter der Haube ist es eine doppelt verkettete Struktur, eine Skip-Liste gepaart mit einer Hashtabelle, was Einfügungen in O(log(N)) und keine zusätzliche Arbeit ermöglicht, um Ergebnisse sortiert zurückzulesen.³ Man fügt den Score eines Mitglieds mit ZADD hinzu oder aktualisiert ihn und liest den Rang eines Mitglieds mit ZRANK (niedrigster zuerst) oder ZREVRANK (höchster zuerst).³ Der kanonische Anwendungsfall ist der, den jedes Spiel braucht und jede klassische Datenbank fürchtet: die Bestenliste. Wie die Redis-Dokumentation es formuliert: „you can use sorted sets to easily maintain ordered lists of the highest scores in a massive online game”.³

Warum es als Ingenieurkunst zählt: Eine Bestenliste in einer relationalen Datenbank ist eine echte Plage. Jede Score-Änderung bedeutet ein UPDATE, und jede Abfrage „welchen Rang hat dieser Spieler” bedeutet ein ORDER BY über die gesamte Tabelle oder einen gepflegten Index — Arbeit, die mit der Zahl der Spieler wächst und unter Last in Konflikt gerät. In Redis ist die Rangfolge der Struktur immanent. ZADD kostet O(log(N)) und ZREVRANK kostet O(log(N)), und das Set ist bereits sortiert, sodass das Lesen der obersten zehn trivial ist.³ Die Funktion wurde nicht leichter, weil Redis bei derselben Arbeit schneller wäre — sie wurde leichter, weil Sanfilippo sich entschied, ein Primitiv auszuliefern, dessen Form die Lösung ist. Das ist „tu weniger” aus Sicht des Benutzers: Die Datenbank hat den schweren Teil einmal erledigt, sodass tausend Anwendungen es nie tun müssen.

Single-threaded und im Arbeitsspeicher: Einfachheit als Gestaltungsmittelpunkt

Redis trifft zwei Entscheidungen, die wie Einschränkungen aussehen und in Wahrheit die Quelle seiner Stärke sind. Es ist im Arbeitsspeicher gehalten — der Arbeitsdatensatz lebt im RAM, mit Dauerhaftigkeit, die durch Snapshots und eine Append-only-Datei darübergelegt wird — und es ist bei der Befehlsausführung single-threaded und verarbeitet Anfragen einzeln auf einem einzigen Kern.¹⁷ Beide Entscheidungen sind verkapptes „tu weniger”.

Die Single-Thread-Entscheidung ist die kontraintuitivere, und der Begründung lohnt es zu folgen. Ein mehrfädiger Speicher muss den nebenläufigen Zugriff auf gemeinsame Daten koordinieren — Sperren, atomare Operationen, sperrenfreie Strukturen, Speicherbarrieren — und in dieser Maschinerie steckt ein erschreckender Anteil der Datenbankfehler und der unvorhersagbaren Latenz. Indem es jeweils einen Befehl ausführt, macht Redis jeden Befehl konstruktionsbedingt atomar: Es gibt keine Verschachtelung, über die nachzudenken wäre, keine Sperre, die zu vergessen wäre, kein Wettrennen, das zu debuggen wäre.⁷ Die offizielle FAQ ist unverblümt darüber, warum dies so wenig kostet: „It’s not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound”, und Single-Threading „avoids race conditions and CPU-heavy context switching associated with threads”.⁷ Der Durchsatz, den der Entwurf aufgibt, ist Durchsatz, den die meisten Workloads ohnehin nie genutzt hätten; die Einfachheit, die er erkauft, zahlt sich bei jeder Zeile Code und jeder Debugging-Sitzung um drei Uhr morgens aus.

Das ist dasselbe Temperament wie seine kompromisslose Weigerung in den Essays, Komplexität hinzuzufügen. Er benennt den Fehlermodus präzise: „We are destroying software by no longer taking complexity into account when adding features or optimizing some dimension.”⁵ Mehrfädigkeit ist genau die Art von Optimierung — einer einzigen Dimension, des reinen CPU-Durchsatzes — die die Komplexität des Systems für einen Nutzen, den die meisten Benutzer nie brauchten, vervielfacht hätte. Ihr Nein hielt Redis zu einem System, das eine Person im Kopf behalten konnte, was die Eigenschaft ist, die es einer Person erlaubte, es elf Jahre lang zu warten.¹

Das Handwerk: C, für Menschen geschrieben, und das Plädoyer für Kommentare

Der dritte Werkkomplex ist keine Funktion, sondern eine Haltung dazu, wie Code geschrieben werden sollte. Sanfilippo schreibt Redis in C — einer Sprache ohne Leitplanken, in der der Programmierer für jedes Byte verantwortlich ist — und er behandelt die Lesbarkeit dieses C als Anliegen erster Ordnung, nicht als nachträglichen Einfall. Sein Essay „Writing system software: code comments” ist ein ungewöhnlich direktes Plädoyer dafür, dass Quelltext in erster Linie als Kommunikation existiert. Code, schreibt er, „should be read other than being executed, since is written by humans for other humans”.⁴ Das ausführbare Verhalten ist nur die halbe Arbeit; die andere Hälfte ist die nächste Person — oft ein künftiges Du — die ihn verstehen muss.

Aus dieser Prämisse leitet er eine Arbeitstheorie der Kommentare und der Klarheit ab. Das Ziel lesbaren Codes, argumentiert er, sei „to lower the amount of effort and the number of details the reader should take into her or his head while reading some code”.⁴ Ein Kommentar verdient seinen Platz, wenn er ein Detail entfernt, das der Leser sonst rekonstruieren müsste — das Warum hinter einer nicht offensichtlichen Wahl, die Invariante, die eine Funktion voraussetzt, der Grund, weshalb ein schneller Pfad existiert. Das ist Handwerk im tiefsten Sinne: nicht Cleverness, sondern Sorge um den Menschen, der danach kommt. Es passt genau zum „tu weniger”-Prinzip, denn je kleiner und einfacher das System, desto weniger Details gibt es zu tragen und desto ehrlicher kann der Code über die verbleibenden sein.

Dieselbe Überzeugung treibt seine weiter gefasste Kritik daran, wohin sich Software entwickelt. Er warnt vor „an absurd chain of dependencies, making everything bloated and fragile” und vor Systemen, „that no longer scale down: simple things should be simple to accomplish, in any system”.⁵ Redis ist sein Gegenargument, ausführbar gemacht — ein System mit wenigen Abhängigkeiten, einem kleinen begreifbaren Kern und einem Entwurf, in dem das Einfache einfach bleibt. Das Handwerk ist keine Verzierung obenauf auf der Ingenieurkunst; es ist die Ingenieurkunst.

Die Methode

Liest man quer durch Redis, den Idle Scan, die Essays über Kommentare und Komplexität und den einen Thread, kehren dieselben Verpflichtungen wieder. Sanfilippos Methode ist weniger ein Slogan als eine Reihe stehender Gewohnheiten.

Tu weniger — der gefährlichste Code ist der, den du nicht schreiben musstest. Die prägende Gewohnheit ist die Subtraktion: Bevor man eine Funktion, eine Abhängigkeit oder eine Optimierung hinzufügt, frage, ob das System ohne sie überleben kann. Er benennt den Fehlermodus direkt — Komplexität, hinzugefügt „without taking it into account”.⁵ Die Lehre überträgt sich weit über Datenbanken hinaus: Jede Zeile, die du nicht schreibst, ist eine Zeile, die nicht brechen, den nächsten Leser nicht verwirren und nicht ein Jahrzehnt lang gewartet werden muss. Es ist minimum worthy product auf der Ebene des Systemkerns — liefere das kleinste Ding, das wirklich der Nutzung wert ist, und verteidige seine Kleinheit gegen den stetigen Druck zu wachsen.

Liefere mächtige Primitive, keine vorgefertigte Policy. Redis reicht dir Sorted Sets, Streams und Hashes — allgemeine Strukturen, aus denen du Bestenlisten, Warteschlangen und Rate Limiter baust — statt einer maßgeschneiderten Funktion für jede.³ Die stehende Gewohnheit besteht darin, den zugrunde liegenden Mechanismus zu finden, der eine ganze Problemklasse löst, und diesen auszuliefern, sodass die Datenbank den schweren Teil einmal erledigt. Es ist dieselbe Wette, die Roberto Ierusalimschy mit Luas Tables und Metatables einging — gib den Leuten scharfe, allgemeine Hebel und lass sie den Rest bauen — und die Verwandtschaft ist kein Zufall, denn Redis bettet Lua ein, um genau das zu tun.

Wähle Einfachheit, selbst wenn sie Durchsatz kostet. Der single-threaded Entwurf ist der klarste Fall: Redis verzichtet bei der Befehlsausführung auf Mehrkern-Parallelität, weil die Einfachheit — keine Wettrennen, keine Sperren, konstruktionsbedingt atomar — mehr wert ist als die Kerne, und die CPU ohnehin selten der Engpass war.⁷ Die Disziplin besteht darin, zu wissen, welche Dimension dich tatsächlich einschränkt, und sich zu weigern, Komplexität zu zahlen, um eine Dimension zu optimieren, die es nicht tut. Das ist die Beweis-Schranke, angewandt auf Leistung: Füge keine Nebenläufigkeit hinzu, weil sie schnell klingt; miss, wo der Engpass wirklich liegt, und meist ist es nicht die CPU.

Schreibe Code für den Menschen, der ihn als Nächster liest. Quelltext „is written by humans for other humans”, und die Aufgabe eines Kommentars besteht darin, die Details zu senken, die der Leser tragen muss.⁴ Die Gewohnheit besteht darin, Lesbarkeit und erläuternde Kommentare als Teil der Korrektheit zu behandeln, nicht als Annehmlichkeit, die man später hinzufügt — denn ein System, das niemand verstehen kann, ist ein System, das niemand gefahrlos ändern kann. Es ist dasselbe menschenzentrierte Handwerk, das Donald Knuth mit literate programming an seine Grenze trieb: Das Programm ist ein Stück Schreiben, das sich an einen Menschen richtet.

Halte das ganze System in einem Kopf. Redis blieb elf Jahre lang von einer Person wartbar, weil es klein genug gehalten wurde, um von einer Person begreifbar zu sein.¹ Die stehende Verpflichtung besteht darin, die Begreifbarkeit-durch-ein-Individuum als harte Entwurfsbeschränkung zu behandeln — wenn das System über das hinauswächst, was ein Geist halten kann, hast du das verloren, was es vertrauenswürdig machte. Es ist der Solo-Handwerks-Instinkt, den Linus Torvalds und die Unix-Tradition teilen: ein Werkzeug mit einer klaren, begrenzten Aufgabe, das man besitzt und tief versteht, statt es ausufern und delegieren zu lassen.

Einflusskette

Wer ihn prägte

Die Unix- und C-Tradition. Sanfilippo schreibt Systemsoftware in C, von Hand, mit Sorgfalt für jedes Byte — die Linie von Thompson und Ritchie, in der kleine Werkzeuge eine Sache gut tun und die Sprache einem volle Kontrolle und volle Verantwortung gibt.⁴ Sein Beharren darauf, dass Code geschrieben wird, damit Menschen ihn lesen, ist die Ethik des lesbaren C jener Tradition, in die Datenbank-Ära getragen. (Prägender Einfluss)

Die Sicherheits- und Netzwerk-Hackerkultur der späten 1990er. Vor Redis gab es hping und den Idle Scan — Low-Level-Paketarbeit, die ein präzises mentales Modell von TCP/IP und das Auge eines Hackers für den eleganten Seitenkanal verlangte, der sich in einem Protokoll verbirgt.¹⁶ Jene Gewohnheit, den cleveren Mechanismus unter einem scheinbar schwierigen Problem zu finden, ist dieselbe, die Redis’ Datenstrukturen hervorbrachte. (Direkter Einfluss)

Der Zwang eines echten Produkts. Redis wurde nicht im Abstrakten entworfen; es wurde durch LLOOGGs Bedarf, Webserver-Logs schneller aufzunehmen, als vorhandene Datenbanken es erlaubten, ins Dasein gezwungen.¹ Der Druck eines konkreten, dringenden Problems — nicht der Wunsch, eine Datenbank um ihrer selbst willen zu bauen — formte Redis dahin, genau das zu tun, was nötig war, und wenig mehr. (Prägender Einfluss)

Wen er prägte

Eine Generation von Anwendungsarchitekturen. Redis wurde zum Standard für Caching, Sitzungsspeicherung, Rate Limiting, Echtzeit-Bestenlisten und Pub/Sub — so allgegenwärtig, dass „setz Redis davor” reflexhafter Ingenieurrat ist, und seine Datenstrukturen formten um, wie Entwickler darüber denken, was eine Datenbank bieten kann.¹³

Die „reichhaltige Primitive”-Schule der Datenspeicher. Indem es bewies, dass ein Speicher Sorted Sets und Streams als erstklassige Typen statt als undurchsichtige Werte ausliefern kann, drängte Redis das ganze Feld hin zu reichhaltigeren serverseitigen Datenstrukturen und weg vom leeren Schlüssel-Wert-Modell. (Feldprägender Einfluss)

Das Plädoyer für kleine, meinungsstarke Systeme eines einzelnen Autors. Redis steht als handfester Beweis dafür, dass ein bewusst kleines System, gewartet von einer Person mit Geschmack, zu globaler Infrastruktur werden kann — ein Argument, das durch jeden „tu weniger”-, abhängigkeitsarmen, begreifbar-im-Kern entworfenen Ansatz seither widerhallt.⁵

Der rote Faden

Sanfilippo sitzt bei den Minimalisten dieser Reihe — den Erbauern, die glauben, die höchste Form der Ingenieurkunst sei die Subtraktion. Rich Hickey zog die Linie in „Simple Made Easy”: Einfach bedeutet un-verflochten, eine Faltung, ein Anliegen, und Komplexität ist die Verschachtelung, die wir der Bequemlichkeit halber hinzufügen und für immer bezahlen. Redis ist dieses Argument, zu C kompiliert — ein einzelner Thread, damit es ein Anliegen gibt, nicht das Geflecht der Nebenläufigkeit; reichhaltige Primitive, damit die Datenstruktur nicht mit dem Anwendungscode verflochten ist.⁵⁷ Und Roberto Ierusalimschy baute Lua klein genug, dass eine Person es begreifen kann, und lieferte Mechanismen statt Policy aus — dieselbe Wette, die Redis mit seinen Primitiven eingeht, weshalb Redis Lua einbettet, um Benutzern atomares Skripting gegen sie zu erlauben. Beide stammen ab von der Unix-Ökonomie von Thompson und Ritchie: ein Werkzeug mit einer klaren Aufgabe, in lesbarem C geschrieben, klein genug, um es ganz zu verstehen. Wo Hickey sagt halte es einfach, nicht bloß bequem und Ierusalimschy sagt liefere den Hebel, nicht die Regel, sagt Sanfilippo: tu weniger — gib den Leuten mächtige Primitive, führe sie einzeln aus, damit das Modell in deinem Kopf bleibt, und schreibe jede Zeile für den Menschen, der sie als Nächster liest. (Reihen-Brücke)

Was ich daraus mitnehme

Die Lehre, die ich von antirez behalte, ist, dass der Code, den ich nicht schreibe, der wertvollste Code im System ist. Mein Instinkt, wie der der meisten Erbauer, besteht darin, ein Problem durch Hinzufügen zu lösen — eine Funktion, eine Abhängigkeit, einen Thread, eine clevere Optimierung. Redis ist ein elfjähriges Argument dafür, dass das Hinzufügen meist der Fehler ist. Der single-threaded Entwurf ist der, über den ich am meisten nachdenke: Er verzichtete auf das, von dem alle sagten, man müsse es tun — die Kerne ausnutzen — weil die Komplexität, die es brachte, einen Nutzen, den seine Workload nie brauchte, nicht wert war.⁷ Wenn ich heute etwas baue, ist die Frage, die ich mir borge: „Was kann ich mich weigern hinzuzufügen und trotzdem etwas der Nutzung Wertes ausliefern?” Denn jede Zeile, die ich auslasse, ist eine Zeile, die nicht brechen, nicht verwirren und im nächsten Jahrzehnt keine Wartung verlangen kann. Weniger zu tun ist schwerer, als mehr zu tun, und weit dauerhafter.

Die zweite Lehre ist, dass Code Schreiben ist und der Leser ein Mensch. Es ist leicht, Quelltext als Anweisungen für eine Maschine zu behandeln und in dem Moment aufzuhören, in dem die Tests bestehen. Sanfilippo behandelt ihn als Kommunikation — „written by humans for other humans” — und beurteilt ihn danach, wie wenige Details der nächste Leser im Kopf tragen muss.⁴ Das hat Kommentare für mich neu gerahmt: nicht Lärm, der zu minimieren wäre, nicht eine Entschuldigung für unklaren Code, sondern der Ort, an dem ich der nächsten Person das Warum übergebe, das sie aus dem Was nie rekonstruieren könnte. Die Disziplin, für den Leser zu schreiben, ist untrennbar von der Disziplin, weniger zu tun, denn je kleiner und einfacher das System, desto ehrlicher kann sein Code sein — und desto wahrscheinlicher, dass eine Person Jahre später noch das Ganze im Kopf halten kann. Das ist quality is the only variable, gelesen als Zurückhaltung: Das richtige kleine Ding, für Menschen geschrieben und gegen Aufblähung verteidigt, wird zu Infrastruktur, auf der die Welt stehen kann.

FAQ

Was ist Redis?

Redis ist ein quelloffener In-Memory-Datenstrukturspeicher, geschaffen von Salvatore Sanfilippo (antirez) und erstmals am 26. Februar 2009 veröffentlicht.¹² Statt undurchsichtige Werte wie ein einfacher Schlüssel-Wert-Cache zu speichern, bietet er reichhaltige native Datenstrukturen — Strings, Hashes, Listen, Sets, Sorted Sets und Streams — die vom Server atomar bearbeitet werden.¹ Weil der Arbeitsdatensatz im RAM lebt (mit Dauerhaftigkeit über Snapshots und eine Append-only-Datei), ist er extrem schnell, weshalb er zu einer der weltweit meistgenutzten Datenbanken für Caching, Sitzungsspeicherung, Warteschlangen, Rate Limiting, Echtzeit-Bestenlisten und Pub/Sub wurde.¹⁷

Wer ist antirez?

antirez ist das Online-Pseudonym von Salvatore Sanfilippo, einem italienischen (sizilianischen) autodidaktischen Programmierer, geboren am 7. März 1977 in Campobello di Licata, Sizilien.¹ Am bekanntesten ist er als Schöpfer von Redis (2009), das er elf Jahre lang als alleiniger Entwickler und BDFL betreute, bevor er am 30. Juni 2020 zurücktrat und im Dezember 2024 zum Projekt zurückkehrte.¹ Vor Redis leistete er bemerkenswerte Sicherheitsarbeit — er schrieb das hping-Pakettool und erfand 1998 den Idle Scan, eine getarnte Port-Scan-Technik, die später in nmap aufgenommen wurde.¹⁶ Über Einfachheit, Code-Kommentare und das Handwerk der Systemsoftware schreibt er bedacht auf seinem Blog unter antirez.com.⁴⁵

Warum ist Redis single-threaded?

Redis führt Befehle nacheinander auf einem einzigen Thread aus, weil die Einfachheit für seine Workloads mehr wert ist als der Mehrkern-Durchsatz. Ein einzelner Thread macht jeden Befehl konstruktionsbedingt atomar — es gibt keine Race Conditions, keine Sperren und keine zerrissenen Lesezugriffe, über die nachzudenken wäre.⁷ Und es kostet in der Praxis wenig: Wie die Redis-FAQ erklärt, „it’s not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound”, und Single-Threading „avoids race conditions and CPU-heavy context switching associated with threads”.⁷ Es ist Sanfilippos „tu weniger”-Prinzip als Architektur — verzichte auf die Komplexität, die eine Dimension (CPU) optimiert, die selten die Beschränkung war.⁵⁷

Was ist ein Redis Sorted Set?

Ein Redis Sorted Set (ZSET) ist eine Sammlung eindeutiger String-Mitglieder, jedes mit einem Gleitkomma-Score verknüpft, wobei die Mitglieder automatisch in Score-Reihenfolge gehalten werden.³ Man setzt oder aktualisiert den Score eines Mitglieds mit dem ZADD-Befehl und liest seine Position mit ZRANK (niedrigster Score zuerst) oder ZREVRANK (höchster zuerst); die Struktur bleibt jederzeit sortiert, sodass das Lesen gerankter Ergebnisse keine zusätzliche Sortierarbeit erfordert.³ Intern verwendet es eine Skip-Liste gepaart mit einer Hashtabelle, was Einfügungen in O(log(N)) und Rang-Abfragen in O(log(N)) ergibt.³ Der klassische Einsatz ist eine Echtzeit-Bestenliste — eine Funktion, die in einer relationalen Datenbank mühsam ist, aber in Redis auf ein paar Befehle zusammenfällt, weil das richtige Primitiv bereits existiert.³

Quellen