The Chicken, the Egg, and the Compiler

Dheeraj Babu Dendukuri — Wed, 01 Jul 2026 04:17:32 +0000

Bootstrapping with Bootstrap

Hi, I am Dheeraj, and this is my first blog here. So I picked a fitting theme: Bootstrapping with Bootstrap.

Bootstrapping is a self-starting process that keeps growing without external input. In computer science, it sounds simple, but the deeper you go, the more fascinating it gets. Bootstrapping

The Chicken and the Egg Problem

Here is the chicken-and-egg problem in computer science: most modern compilers are written in the same language they are supposed to compile.

Wait a second, how does that make sense?

If we need a chicken to lay eggs, where did the first chicken come from? An egg? Air?

You can ask the same question about compilers.

Thought this is not the right place to debate which came first, the chicken or the egg... (spoiler alert: the egg came first, last time I checked. If you are curious, know more).

But we can definitely discuss what computer science and mathematics researchers (brilliant, and occasionally gloriously stubborn people) did with the compiler.

Wait, Compilers Are Written in Their Own Language?

Coming back to the topic: yes, compilers are written in the same language they compile, but they were not born that way. They had to take a detour.

To create the first compiler for a new language, developers usually implement it in an existing language that already has a working compiler. Historically, that was often C or Assembly.

Write a tiny compiler in an existing language.
Use that compiler to compile a slightly better version of itself.
Use the improved compiler to compile an even better version.
Repeat until the compiler is capable of compiling its own source code.

At that point, the compiler can compile itself.

That is the real magic behind bootstrapping.

So Where Did the First Compiler Come From?

Wait a second.

If we need to start with a low-level language to bootstrap a compiler, how did we create the compilers for those languages?

Obviously, C was originally implemented using Assembly. And Assembly ultimately maps to machine instructions written as plain old 0s and 1s.

Yes, binary. (If you are not familiar with it yet, here you go).

At some point in history, people literally programmed computers by entering machine instructions directly.

Just imagine debugging that.

So, the ladder looked something like this:

Binary (0s and 1s)
Assembly
C
Higher-level languages
Self-hosting compilers

The Bootstrap Ladder

Imagine creating a language called SuperCoolLang.

Compiler v0 (written in C) -> Compiler v1 -> Compiler v2 (partially self-hosted) -> Compiler v3 (fully self-hosted)

Version 0:

Written entirely in C.
Can only compile a few basic language constructs.

Version 1:

Can compile a slightly larger subset of SuperCoolLang.

Version 2:

Parts of the compiler are now rewritten in SuperCoolLang itself.

Version 3:

The entire compiler is written in SuperCoolLang.
At this point, the language has become self-hosting.

The compiler has effectively pulled itself up by its own bootstraps, which is exactly where the term originates.

Why Go Through All This Trouble?

Okay, this sounds interesting, but why bother?

Why do something this complicated when we could just keep writing the compiler in a low-level language?

Because then we create a heavy dependency on that low-level language, along with extra maintenance burden.

If something breaks, or the language dies out, we can only hope it does not drag our language into the grave with it (and sometimes it does).

Bootstrapping gives us a few advantages:

Easier maintenance.
Better portability across platforms.
Faster language evolution.
Developers get to use their own language every day.
New compiler versions can be compiled using older compiler versions.

In other words, the language becomes responsible for its own future.

The Pattern Appears Everywhere

Okay, fair question: we now know what bootstrapping is in compilers, but how does it help me?

After all, very few of us are going to wake up tomorrow and decide to write a compiler.

The interesting part is this: bootstrapping is not just about compilers. It is a pattern.

Think about learning programming.

Your first program might only print "Hello World."

Your second program might automate a tiny task.

Your tenth program helps you write your hundredth program.

Eventually, the tools you build start helping you build better tools.

A tiny script becomes an automation platform. A simple compiler becomes a self-hosting language. A basic tool becomes the foundation for something much larger.

Or consider automation at work.

Every time I spend two hours writing a script that saves me ten minutes every day, I am essentially bootstrapping my future productivity.

The script starts small but eventually becomes a tool that helps me create even more tools.

Looking back, that is probably why compiler bootstrapping fascinated me in the first place. Once you recognize the pattern, you start seeing it everywhere.

The same pattern appears in businesses, open-source projects, operating systems, developer tools, and, of course, compilers.

Bootstrapping in the AI and Vibe-Coding Era

This idea becomes even more interesting when viewed through the lens of AI.

Today, AI helps developers:

Generate code.
Write tests.
Create documentation.
Refactor applications.
Build development tools.

Those tools then help developers build better AI systems.

Which then help create even better tools.

Sounds familiar?

That is bootstrapping again.

AI Systems -> Developer Tools -> Better AI Systems -> AI Systems

When someone says they built an application through "vibe coding," it can look like magic from the outside.

But under the hood is a giant stack of bootstrapped technologies:

AI models trained using sophisticated infrastructure.
Frameworks built using programming languages.
Programming languages compiled by compilers.
Compilers built using previous generations of compilers.
Operating systems built using countless generations of tools before them.

The entire software industry is basically one giant bootstrap chain stretching back decades.

The AI revolution did not replace bootstrapping.

It accelerated it.

Final Thoughts

The interesting thing about bootstrapping is that it usually starts with something embarrassingly small.

A primitive compiler.

A simple script.

A rough prototype.

A basic automation.

It may not be elegant, fast, or feature rich. Its only job is to help create the next version of itself.

Modern compilers, operating systems and even AI systems stand on top of countless generations of such bootstrapped tools.

So, the next time you write a tiny script to automate a repetitive task, remember:

You are following the same pattern that helped entire programming languages learn how to compile themselves.

Note: This is not a deep dive into compiler design or bootstrapping. It is simply my interpretation of the concept and how I see the same pattern in day-to-day work. Sometimes understanding what is hiding under the hood makes the whole machine much more fascinating.

DEV Community: Dheeraj Babu Dendukuri