The Null Pointer Identity: Debugging the Architecture of the Chinese Self

Living as Middleware: Refactoring the Incompatible Self

🔴

The Glitch

The Untranslatable “Brother”

I first encountered this error while releasing Episode 02 of Script in the Audience, but I hesitated to document it. Because the “dead memories” started attacking me.

The plot was simple: The protagonist realizes that the noodles she just ate were actually her brother’s birthday longevity noodles.

She ate them unknowingly, and upon realizing this, she is devastated.

He comforts her by saying: “哥哥的东西就是你的”

Literally: “Brother’s things are yours.”

In Chinese, this line is perfectly normal. It’s intimate, spoiling, and loaded with affection.

But when I tried to port this line into English, the compiler threw an error.

It felt awkward. It didn’t sound like human speech.

That’s when I realized the underlying issue: English doesn’t speak like this.

In English, adults almost never refer to themselves in the third person. They use “I”.

They call people by names, not by function calls.

I tried to reverse-engineer the emotional logic and finally settled on: “What’s mine is yours, KiKi.”

He says “Mine”. He calls her “KiKi”. Staring at this sentence, I suddenly felt moved.

By stripping away the binding relational symbols and removing the implied pressure of duty, I saw two concrete human beings communicating.

There was love between them.

The “I” Outsourced Role

Initialization Differences

Even though I am highly vigilant about language, I still unconsciously release the “scent” of Chinese syntax.

In Chinese, “I” is often not “I”.

• “What do you like? Brother will buy it for you.”

• “Leave the clothes there, Mom will wash them.”

• “When do you arrive? Dad will pick you up.”

• “Teacher is telling you...”

In these sentences, “Mom / Dad / Brother / Teacher” are all functionally “I”.

The speaker is constantly outsourcing the “I” to a relational role.

System Logic:

Role.give(you) Subject = Mutable Variable. Whether the subject is “Your Mom,” “Your Brother,” or “Your Aunt” depends entirely on who the Receiver is.

This is not a figure of speech. It is not pronoun substitution. It is not even intentional choice. It is the default grammatical device.

The initiator of an action is merely a symbol positioned within a relationship, a subject that has already been downgraded (demoted).

Runtime Output:

• “I” is not the starting point.

• “Who am I” is not confirmed via Self-Reference.

• “I” is calculated through the relationship between “Me + Someone”.

From this very first step, the Chinese OS has already completed a process of De-egoization at the hardware level.

The Self is not encouraged to be repeatedly confirmed; it isn’t even stably named.

In contrast, look at the English architecture:

• “That is your teacher, Mary.”

• “You can call your father by his name.”

• “I bought this for you.”

• “I want you to...”

In English, the Identity/Role (mother, teacher, brother, etc.) cannot replace the Subject “I”.

System Logic:

this.give(you) Subject = Immutable Constant. Name = Me. Role = Optional Attribute.

This linguistic structure is critical. The name here acts as an early-binding self-identifier.

Runtime Output:

• “I” is established first.

• Relationships are lazy-loaded modules (loaded later).

• A person maintains the same “I” across any relationship instance.

Code Comparison:

In English:

Self = new Person("Name") “I” is an object instantiated at language boot sequence. The Self is enforced as a Singleton, named, and directly referenceable.

In Chinese:

Self = getRelation(context) “I” is calculated during runtime based on the relationship. The Self was never designed to be returned as a standalone object.

Architecture Summary:

• Chinese: Allows “Relation to swallow the Subject.”

• English: Demands “Subject to remain Independent.”

These are not just cultural habits; they are differences in the Runtime Model Initialization.

This is an incompatibility in the underlying architecture.

About 'Self

The Compatibility Error

In the Chinese context, “Self” is a post-processed concept, imported via modernity.

When this generation tries to emphasize “Self” (Ego, Independence) within a language environment that fundamentally discourages these very modules, Compatibility Errors are inevitable.

System instability—chaos and pain—is guaranteed.

The underlying source codes of Chinese and English are incommensurable.

They release information at different rhythms; their definitions of the same variable are fundamentally different.

I opened VS Code. I tried to define “Self”.

What does this variable actually mean?

I queried the database: Psychology says it’s cognition; Sociology says it’s a construct; Philosophy says it’s consciousness.

The software layer is busy discussing OS features, but I got stuck on the hardware level: What is the prerequisite for owning a Self? What is the Boot Sequence?

I found the bootloader in Hegel: Mutual Recognition.

You and I are independently running processes. We ping each other to confirm existence.

It cannot be—and must not be—that I am a Child Process of someone else, where my runtime depends entirely on their execution.

Hegel’s key protocol is: I see you, I acknowledge your standalone status, and we interface as equals.

When parents name a child, they are supposed to acknowledge a complete entity, anticipating an independent kernel.

The Correct Parsing Order:

1. Unit Initialization: First, I exist as a physical entity.

2. Coordinate System Setup: I establish “I” as the Origin (0,0,0). I have an independent personality.

3. Outward Connection: Only then can I send signals outward (Relationships).

4. Feedback Loop: The signal bounces back, and I realize “Who I am.”

The Geometry of Existence:

It is like rendering a circle. Definition: A set of points equidistant from a Center.

1. You must first have the Center (The Self).

2. Only then can you draw the Radius (My distance from the world).

3. Finally, you form the Circumference (The Boundary).

Relation vs. Boundary

Encapsulation vs. Pointers

I found a polite summary in the software layer: “Relational Self” vs. “Bounded Self.”

As if we actually have a choice.

Here is my decompilation of these two types:

English: I think, therefore I am.

• Initialization: “Encapsulation”.

• Structure: The Self is a Fortress (Encapsulated Object).

• Logic: Internal State is Private; interaction with the outside world only happens via public Interfaces.

Chinese: I relate, therefore I function.

• Initialization: “Reference”.

• Structure: The Self is a Hub (Pointer).

• Logic: It points to wherever the Context dictates. It has no local storage for entity data.

If a language’s narrative categories lack “Self-concept” and “Self-esteem”—containing only Identity and Relation, can a “Self” actually form?

The Chinese system does not possess this consciousness. It doesn’t know if you are whole; it does not encourage or acknowledge independent personhood.

In the Chinese model, relationship is the prerequisite condition.

If you call your parents by their names, or address elders directly, it triggers a “Disrespect” error (没大没小 - No Big, No Small = lacking hierarchy, uneducated).

Because:

• You violated the Initialization Order.

• You bypassed the Handshake Protocol.

• You attempted Direct Access to the Object Instance.

This is called an Abstraction Layer Error.

Does language shape thought? Can it reverse-engineer the mind?

From my User Experience: Yes.

Language is the unconscious. It is not a tool; it is the environment.

It is a Pre-compiled Library hard-coded into the ROM. The user cannot uninstall it.

When I call the function Brother(), I automatically load an entire library of hierarchy and duty. I don’t need to write this logic in the main() program; it is inherited system-wide.

The Occupied Origin

Null Pointer

“Relational Self” is a pseudo-proposition. It does not exist.

If language invades before a person’s Origin Coordinate is established, injecting code via titles—Baby, Sister, Big Brother, Beauty, Master, Boss—what happens?

Before you can realize “Who am I,” your Coordinate Position has already been locked by language.

The Hijack:

• English Names: Static Binding. Determined at compile-time (Birth = Independent).

• Chinese Titles: Dynamic Binding. Determined at runtime (I become who I meet).

The language system directly hijacks your coordinate system.

From hardware initialization, the “Origin” is denied.

You are told, subliminally, that you are not yourself; you are a distributed node in a network.

You are not (0,0,0). You are (Daughter, Father, Son, Boss).

These nodes only function when connected.

Before establishing (0,0,0), all identities (Daughter, Father) are just Pointers pointing outward.

If there is no Entity Object to anchor these pointers... Once the external object moves or vanishes, the pointer becomes a Null Pointer.

The system Crashes.

This explains why many people fall into abnormal tempers or life collapse after retirement or losing a loved one. This explains the total loss of vitality after unemployment or divorce. The coordinates cannot be calculated.

Their Origin is empty.

They vanish.

»»»If you can read the underlying code of my Null Pointer Hypothesis, you can understand the malicious apps running on top of it. (System Broadcast Complete. OVER.)»»»

So, can relationships actually generate a Self? Or is that thing even a “Self”?

My calculation result is: FALSE.

That is merely an “Interface Implementation without State”.

The so-called “Relational Self” is nothing but a Dangling Pointer pointing to the Void.

If the “Relational Self” were truly a Self, then when relationships change, the Self should merely transform. It should not vanish.

But we are used to these titles, and thus we are used to having our coordinates defined by others.

We think we are speaking, but in reality, Language is speaking us.

“I” can be any node in the relationship graph, but “I” cannot be Myself.

Late at night, sitting on the sofa in pitch darkness: who am I?

I only feel the loss of gravity.

However, this does not mean one must sever relationships. It does not mean relationships are unimportant.

On the contrary, relationships and community are vital. But the prerequisite is: Finding the Origin (0,0,0) and holding the Origin.

Only when one decides to exist as an Isolated Singularity can one re-decide to whom to transmit signals.

The difference lies in:

• Active Connection vs. Passive Loading

• Having a Kernel vs. No Kernel

• Existing vs. Being Occupied

The Fog

Runtime Uncertainty

My friends and I, for about 3-4 years after graduation, were stuck in a strange Loop. We couldn’t break out.

I was switching jobs. Every 10 months, I’d ping the industry ceiling and immediately search for the next instance.

A friend of mine was in a relationship loop. Refreshing a new partner every 6 months.

Another friend was handling the Mother Protocol. Triggering a crash/rebound every month. Every attempt to establish a boundary was flagged as a System Bug—labeled as cold, emotionless, “not human.”

We didn’t know what process we were running.

What was causing this latency?

What problem were we trying to solve?

Later, I realized: We lacked Value Coordinates. The core issue was that we didn’t know who we were.

We had no Origin (0,0,0).

We were all doing the same thing: Reverse-Engineering our proof of existence via External Feedback.

We thought we were “exploring,” but in fact, we were blind. We were “Drifting” in other people’s coordinate systems.

Language, education, relationships, environment, all these factors combined to strangle self-consciousness.

The phenomena we see: “Cutting off relatives”, “Escaping,” “Aphasia”, are essentially desperate queries for the same question: “Who am I?”

The phenomenon IS the answer.

I can now write “What’s mine is yours, KiKi,” but my underlying code will still unconsciously output that sticky, viscous relational network.

The fate of our generation might be to function as Middleware.

We are forced to adapt and transcode between two Incompatible Systems, unable to fully belong to either side.

And our ultimate destination might be simply to identify this Bug, and then decide whether to fix it.

Of course, my choice is to fix it. To See is to Repair.

— Wider. Freer. Suggger

Debug Log:

。