RU | EN

WHY C/C++?

8th RULE Edition — Version 42.0

1. The Architect's Confession

Have you ever wondered why our Universe has existed for exactly 13.8 billion years? It's not magic. It's not a brilliant plan. It's the consequence of an incorrect call.

About 13.8 billion years ago, an enthusiast (let's call him the Architect) was sitting at his conditional monitor, tweaking the parameters of a new reality. He got bored. And he decided to test an old hack:

(*(void(*)())0)();

You know the result. Segmentation Fault. The entire project crashed into an infinite reboot loop. What we call the "Big Bang" was actually a system crash and subsequent recovery from a memory dump.

Since then, the Architect has been watching us through a monitor, and his code contains a comment:

// P.S. (*(void(*)())0)(); - DO NOT CALL!!! I called it 13.8 billion years ago...
// Result: galaxies, life, the internet, and a lot of questions.
// The Architect.

And ever since, he's been afraid of pointers.

2. Dark Matter — a bug that became a feature

Scientists scratch their heads: where does 85% of the Universe's mass go? Why don't galaxies fly apart?

The answer is simple. It's not gravity. It's CMake.

Dark Matter is invisible build code that drags all objects along, but never compiles into an executable. It's global variables that can't be deleted because there are dependencies on them. The Architect once wrote:

# This file is working. Don't touch it!
# Do not edit manually.
find_package(Universe REQUIRED COMPONENTS Gravity DarkMatter)
target_link_libraries(Universe PUBLIC DarkMatter::Invisible)

And now we try to detect these libraries, but we only see their gravitational influence.

3. Quantum Mechanics — or "why the electron knows everything"

Physicists still argue: "How does the electron know whether the second slit is open?" They came up with quantum entanglement, wave function collapse, parallel worlds...

The answer is on the surface.

The electron doesn't know anything. It just knows. Because the entire Universe is one big shared memory. And the electron is an object that has access to the global variable bool is_second_slit_open.

class Electron {
public:
    State getState() {
        // It doesn't calculate. It reads.
        return Universe::sharedMemory().isSlitOpen ? PARTICLE : WAVE;
    }
};

The wave function isn't a physical object. It's just the state of an object before reading. Once we call .getState() (make an observation), the system simply returns the current value from memory to avoid a race condition.

4. Black Holes — Stack Overflow with a twist

Any decent program has a call stack. So does our Universe. When too many calls (mass) accumulate in one place, the stack overflows. Spacetime contracts, forming a singularity — this is classic SEGFAULT, just inverted: time and space swap roles.

void collapseStar(Star* s) {
    while (s->mass > CRITICAL) {
        s->compress(); // Recursion goes into infinity
        // Stack overflows. A black hole is born.
    }
}

The event horizon is the point of no return where even light (a system call) cannot get a response. And if you try to escape a black hole — you get "Stack Inversion: return address lost".

Distributed systems programmers know: there is no "now" in the world, only RTT (Round-Trip Time). The Architect set it to 299792458 m/s, called it the "speed of light", and forgot to rename it to a constant. Judging by the numbers, he was distracted at that moment — either by his extradimensional cat walking across the keyboard (yes, the cat existed before Schrödinger), or a CI build failed, or he just had enough. He poked the keyboard without looking: "Take 299792458, figure it out yourselves". And we do. When we observe a quasar 13 billion light-years away, we're reading stderr from a process that crashed before Earth existed. We write dissertations about its brightness, when it's just a core.dump being transferred very slowly over the network. And pulsars are neutron stars that blink at up to 716 Hz. Any C++ developer will recognize the classic while(1) { emitSignal(); } without a single std::this_thread::sleep_for(). The Architect just forgot to add yield() and left them spinning in real time, and we get these logs with a delay of thousands of years and call them "periodic signals".

5. Why C/C++?

Because only in this language do you feel like the Architect.

You work with memory directly. You know what a segmentation fault is (and you might have even triggered it a couple of times on a Friday evening). You understand that pointers are evil, but you can't do without them.

You are the subatomic particles trying to read the Universe's code. But be careful:

// If you see this comment in your program — stop immediately.
// Perhaps this is a message from the Architect.
// P.S. Do not call NULL! We already tried.

6. A real programmer doesn't fear bugs — they document them

The Architect could have hidden his mistake. He could have rewritten history. But he left a comment right in the code. And with that, he gave us the most important lesson:

A mistake that isn't hidden stops being a mistake. It becomes documentation.

We still read that comment. We still try to understand what happened at that moment. And perhaps that's our main task: not to fix that mistake, but to understand it.

7. What if all of this is not a metaphor?

What if every time you write malloc, you create a new galaxy?
What if free is the heat death of the Universe?
What if segmentation fault isn't an error, but a portal to another reality — we just haven't learned how to read it yet?

The Architect doesn't give us answers. He only gave us code and a compiler. And said: "Figure it out yourselves."

And we are figuring it out. For 13.8 billion years now.

8. 8th RULE — a rule that doesn't exist, but works

In programming, everything is built on powers of two: 1, 2, 4, 8, 16, 32, 64, 128, 256…
8 is the first number that goes beyond a simple bit. It's a byte. It's the foundation. It's the smallest unit that can hold meaning.

7 is the number of perfection (7 days of creation, 7 notes, 7 wonders of the world).
8 is the break from perfection. The number that breaks the pattern. Chaos that becomes a new order.

The 8-arrow chaos symbol is no accident.

In our theory, each arrow is a direction of the Architect's gaze:

It's a pointer.

A pointer that doesn't lead to any known memory region. A pointer that exists but is never dereferenced. A pointer that holds the entire structure together while remaining invisible.

void* chaos = NULL;  // It's here. Always.

8th RULE isn't a rule in the usual sense. It's a rule that isn't on the list, but it works.

If there are 7 laws of physics (gravity, electromagnetism, strong and weak interactions, etc.), the 8th rule is the one that breaks them all:

8th RULE is a meta-rule. It says:

"All rules work as long as you believe in them. But if you know about the 8th — you can rewrite them."

And so, seven points led us to the eighth.
To the rule that isn't in any textbook, but exists in every main().

The Architect left us 7 laws and one pointer.
We don't know why he did it.
But we know that the 8th day will come when we finally dare to call it correctly.

// 8th RULE: everything you know is temporary.
// Chaos is just an order you haven't understood yet.
// The Architect, 13.8 billion years ago.
// P.S. I'm still here. Watching you. Waiting.
Go to VK