English version: scroll down

Een wereld zonder geheugen

Er was een tijd – nog niet eens zo heel lang geleden – waarin samenwerken aan software voelde als een estafette met geblindeerde ogen. Bestanden vlogen heen en weer via e-mail, versies lagen verspreid over gedeelde schijven, en iedereen hoopte maar dat hij de juiste variant in handen had. “final_v2_definitief_echtLaatste.docx” was geen grapje, maar dagelijkse realiteit. Het werkte, zolang teams klein waren en de veranderingen overzichtelijk bleven. Maar toen software groeide, teams internationaler werden en de snelheid toenam, begon het systeem te kraken.

Wat ontbrak was geen rekenkracht of opslagruimte. Wat ontbrak was iets fundamentelers: een betrouwbare manier om de verandering zélf vast te leggen. Niet alleen het eindresultaat, maar de volledige weg ernaartoe. Hoe herinner je je wat er precies veranderd is, zonder dat mensen elkaar voortdurend in de weg zitten?

De ontdekking van Git

In 2005 stond Linus Torvalds voor precies dat probleem. De Linux-kernel was uitgegroeid tot een van de grootste open-sourceprojecten ter wereld, maar de tools die werden gebruikt konden die schaal niet meer aan. Het was centraal, traag en bovendien ineens gedeeltelijk gesloten. Voor Torvalds was dat het moment waarop compromissen ophielden. In plaats van te wachten op een betere oplossing, besloot hij er zelf één te bouwen.

In een paar weken tijd ontstond Git. Niet als een revolutionaire uitvinding, maar als een logische ontdekking: geef iedereen een volledige kopie van het project, inclusief de complete geschiedenis. Maak elke wijziging uniek en verifieerbaar. Zorg dat niets ooit echt verloren gaat.

Wat Git zo bijzonder maakte, was niet het wat – een versiebeheersysteem – maar het waarom. Torvalds begreep dat verandering de natuurlijke staat van software is. In plaats van die verandering te proberen te beheersen met centrale controle, omarmde hij haar volledig. Elke commit werd een momentopname van de werkelijkheid op dat exacte tijdstip, vastgelegd met een cryptografische vingerafdruk.

De geschiedenis werd daarmee geen last, maar een tijdmachine. Je kunt altijd terug, zien wie wat waarom deed, en begrijpen hoe iets is geworden wat het is. Vertrouwen ontstaat niet omdat iemand zegt dat het klopt, maar omdat je het zelf kunt controleren.

Van gereedschap naar wereldwijde samenwerking

Een paar jaar later kreeg dat idee vleugels. In 2008 lanceerden vier jonge programmeurs GitHub. Waar Git vooral een lokaal en team-intern gereedschap was, maakte GitHub het zichtbaar voor de hele wereld. Projecten kregen een publieke plek, een gezicht en een verhaal.

Plotseling konden wildvreemden meekijken, meepraten en meebouwen. Wat begon als een technisch hulpmiddel groeide uit tot een sociaal platform, een ontmoetingsplek en uiteindelijk een cultuur. Ontwikkelaars deelden hun code niet meer alleen omdat het moest, maar omdat het kon – en omdat openheid sneller leidde tot betere software.

Toen Microsoft GitHub in 2018 overnam voor 7,5 miljard dollar, was dat geen overname van een tool. Het was de erkenning dat deze manier van werken het kloppend hart was geworden van de moderne softwarewereld.

Een parallelle ontdekking

Terwijl Git zijn weg vond in ontwikkelteams, speelde zich elders – bijna gelijktijdig – een ander verhaal af. In oktober 2008, hetzelfde jaar dat GitHub live ging, verscheen een mysterieus document onder de naam Satoshi Nakamoto. Het droeg de titel “Bitcoin: A Peer-to-Peer Electronic Cash System”.

De vraag die daarin werd gesteld was even eenvoudig als revolutionair: hoe maak je digitaal geld dat niet twee keer kan worden uitgegeven, zonder bank, zonder overheid en zonder centrale scheidsrechter? Het antwoord was de Blockchain.

Ook hier waren de bouwstenen niet nieuw. Zoals je eerder beschreef in Wie schonk de mensheid de blockchain?, was blockchain het resultaat van decennia aan cryptografisch onderzoek, waarin onder andere tijdstempels en hash-functies werden gecombineerd tot iets nieuws. 

Elke transactie werd vastgelegd in een blok, cryptografisch verbonden met het vorige blok, en verspreid over duizenden computers. Niemand kon achteraf iets veranderen zonder dat het zichtbaar werd. De geschiedenis werd daarmee niet alleen belangrijk, maar letterlijk onveranderbaar.

De kracht van geschiedenis

De gelijkenis tussen Git en blockchain is bijna ongemakkelijk precies. Zie mijn blog: Wie schonk de mensheid de blockchain? Ze ontstonden onafhankelijk van elkaar, in totaal verschillende contexten, maar ontdekten hetzelfde principe: een gedistribueerde, verifieerbare geschiedenis als fundament van vertrouwen.

In Git betekent dat dat programmeurs zonder centrale controle kunnen samenwerken, experimenteren en altijd kunnen herleiden hoe iets is ontstaan. In blockchain betekent het dat mensen elkaar kunnen vertrouwen zonder elkaar te kennen. In beide gevallen verschuift de macht van personen naar structuur. Van “ik vertrouw jou” naar “ik kan zelf zien dat het klopt”.

Wat deze ontdekking zo krachtig maakt, is dat ze een fundamenteel inzicht blootlegt: de huidige toestand is niet het belangrijkst. De weg ernaartoe is dat wel. Geschiedenis is geen archief dat je bewaart voor later. Geschiedenis is het enige dat je kunt vertrouwen als alles voortdurend verandert.

Een andere manier van kijken

Misschien raakt dit aan iets dat dieper gaat dan technologie alleen. In de natuur is het niet anders. In de blog De databloem: de schoonheid van datacentrisch denken wordt dat treffend beschreven: data vormt het hart, terwijl processen als bladeren komen en gaan. Wat blijft, is de kern. Wat groeit, is de geschiedenis.

Vandaag de dag gebruiken miljoenen mensen Git en GitHub, vaak zonder erbij stil te staan. Blockchain heeft zijn weg gevonden naar digitale valuta, slimme contracten en nieuwe vormen van eigendom. Maar onder al die toepassingen ligt hetzelfde inzicht dat steeds relevanter wordt. Als je echt wilt begrijpen wat iets ís, moet je kunnen zien hoe het geworden is wat het is.

Misschien is dat wel de grootste les van deze twee verhalen. Niet dat we slimmere tools hebben gebouwd, maar dat we eindelijk hebben geleerd om verandering niet langer te vrezen, maar te omarmen. Mits we haar vastleggen – zorgvuldig, eerlijk en voor iedereen zichtbaar.

Misschien is dat wel de grootste les van deze twee verhalen. Niet dat we slimmere tools hebben gebouwd, maar dat we eindelijk hebben geleerd om verandering niet langer te vrezen, maar te omarmen. Mits we haar vastleggen – zorgvuldig, eerlijk en voor iedereen zichtbaar.

Immers in het datakoninkrijk geldt één wet die nooit verandert: alles mag vergaan, zolang we maar onthouden hoe het geworden is wat het is.

Photo by RealToughCandy.com

——————-  Translated by ChatGPT ———————

The Discovery of Git and Blockchain

A World Without Memory

There was a time—not even that long ago—when collaborating on software felt like running a relay race blindfolded. Files flew back and forth via email, versions were scattered across shared drives, and everyone simply hoped they were working on the right one. “final_v2_definitief_echtLaatste.docx” was not a joke, but everyday reality. It worked, as long as teams were small and changes remained manageable. But as software grew, teams became more global, and the pace of change increased, the system began to crack.

What was missing was not computing power or storage. What was missing was something more fundamental: a reliable way to capture change itself. Not just the end result, but the entire journey leading up to it. How do you remember what exactly changed, without people constantly getting in each other’s way?

The Discovery of Git

In 2005, Linus Torvalds faced exactly that problem. The Linux kernel had grown into one of the largest open-source projects in the world, but the tools being used could no longer handle that scale. They were centralized, slow, and suddenly partly closed. For Torvalds, that was the moment compromise stopped being an option. Instead of waiting for a better solution, he decided to build one himself.

Within a few weeks, Git was born. Not as a revolutionary invention, but as a logical discovery: give everyone a complete copy of the project, including its full history. Make every change unique and verifiable. Ensure that nothing is ever truly lost.

What made Git special was not the what—a version control system—but the why. Torvalds understood that change is the natural state of software. Instead of trying to control that change through central authority, he embraced it completely. Every commit became a snapshot of reality at a precise moment in time, captured with a cryptographic fingerprint.

History was no longer a burden, but a time machine. You could always go back, see who did what and why, and understand how something became what it is. Trust no longer depended on authority, but on the ability to verify things yourself.

From Tool to Global Collaboration

A few years later, that idea took flight. In 2008, four young programmers launched GitHub. Where Git had been primarily a local and team-oriented tool, GitHub made it visible to the entire world. Projects gained a public place, a face, and a story.

Suddenly, complete strangers could observe, discuss, and contribute. What started as a technical tool evolved into a social platform, a meeting place, and eventually a culture. Developers no longer shared code simply because they had to, but because they could—and because openness consistently led to better software.

When Microsoft acquired GitHub in 2018 for $7.5 billion, it was not just buying a tool. It was recognizing that this way of working had become the beating heart of the modern software world.

A Parallel Discovery

While Git was finding its way into development teams, a parallel story was unfolding elsewhere—almost at the same time. In October 2008, the same year GitHub went live, a mysterious document appeared under the name Satoshi Nakamoto. It was titled “Bitcoin: A Peer-to-Peer Electronic Cash System.”

The question it addressed was both simple and revolutionary: how do you create digital money that cannot be spent twice, without a bank, without a government, and without any central authority? The answer was the Blockchain.

Here too, the building blocks were not new. Blockchain was the result of decades of cryptographic research, combining elements such as timestamps and hash functions into something fundamentally new. Each transaction was recorded in a block, cryptographically linked to the previous one, and distributed across thousands of computers.

No one could alter the past without it becoming visible. History was no longer just important—it became immutable. Trust did not come from authority, but from the simple ability for anyone to verify the chain for themselves.

The Power of History

The similarity between Git and blockchain is almost uncanny. They emerged independently, in entirely different contexts, yet discovered the same underlying principle: a distributed, verifiable history as the foundation of trust.

In Git, this allows developers to collaborate freely without central control, to experiment, and to always trace how something came to be. In blockchain, it allows complete strangers to exchange value without needing to trust one another. In both cases, power shifts from individuals to structure. From “I trust you” to “I can verify this myself.”

What makes this discovery so powerful is the fundamental insight it reveals: the current state is not the most important thing. The path that led to it is. History is not an archive to be stored away. It is the only thing you can truly rely on when everything else is constantly changing.

A Different Way of Seeing

Perhaps this touches something deeper than technology alone. In nature, it is no different. As described in The Data Flower: The Beauty of Data-Centric Thinking, data forms the core, while processes come and go like leaves.

What remains is the core.
What grows is the history.

Today, millions of people use Git and GitHub, often without realizing it. Blockchain has found its way into digital currencies, smart contracts, and new forms of ownership. But beneath all these applications lies the same insight, one that is becoming increasingly relevant.

If you truly want to understand what something is,
you need to see how it became what it is.

Perhaps that is the greatest lesson these two stories offer. Not that we have built smarter tools, but that we have finally learned not to fear change, but to embrace it—provided we record it carefully, honestly, and in a way that everyone can see.

Because in the data kingdom, one law never changes:
everything may fade, as long as we remember how it became what it is.