Living Museum of Learning
Then You Open the Code
Situation
When I was young, words like **TCP/IP, socket, HTTP, network, four layers, seven layers** sounded mysterious.
And amazing.
I didn't fully understand them. That was precisely the attraction.
I wanted to know how one machine could talk to another machine. How could something typed here somehow appear over there? What exactly was traveling through the wires? Where did an address come from? What was a packet? What did a socket actually do?
I learned and experimented with very little help.
The mystery itself was an invitation.
Decades later, the world has changed completely.
Today, a child can casually send a message to someone on the other side of the planet. Video calls, online games, cloud services, and social networks are so ordinary that the machinery underneath them has almost disappeared.
The network has become invisible because it works so well.
But the questions are still there.
What actually happens between two devices?
And can a student still *touch* those questions with their own hands?
Turning Point
For about six years, my multiplayer games lived in the world of Nearby.
Nearby meant exactly what it sounded like.
Two players had to be close enough for their devices to discover and communicate with each other.
That was convenient, but it was also a boundary.
Then came Golden Xiangqi 1.6.
We built a tiny Internet Game Bridge.
The server knows almost nothing about Chinese chess.
It knows about rooms, players, senders, recipients, and messages.
A player creates a room.
The server returns four letters.
The player sends those four letters to someone else.
The other player enters the code.
And suddenly two devices that might be thousands of kilometres apart can play the same game.
The old boundary was:
Nearby.
The new boundary is:
Anywhere with an Internet connection.
Emergence
On September 24, 2026, I submitted Golden Xiangqi 1.6 to Apple's App Review.
On September 25, Apple sent back a message beginning:
“Congratulations!”
The submission had passed review and was eligible for distribution.
I saved the message.
Not because an App Store approval is extraordinary by itself.
But because this particular approval marked something larger.
A game that had spent years thinking about nearby devices had entered a new world.
The distance between players had expanded by millions of times.
And the same bridge is now being carried into the other games.
Golden 24.
Golden Junqi.
The other old apps.
And more games that have not yet left Donald's head. 😈
The screenshot from Apple is therefore more than a confirmation email.
It is a timestamp.
A small historical artifact marking the moment when Nearby became Global.
But the story goes deeper.
When I was young, networking concepts were mysterious because I couldn't see them.
Today, networking is almost the opposite.
It is everywhere, but because it is everywhere, children may have fewer reasons to wonder about it.
A student can use the Internet every day without ever writing a program that sends one message from one computer to another.
They may know that the Internet exists without ever experiencing the moment when:
“Wait... I made this machine talk to that machine.”
That moment matters.
Because once you can make the communication happen yourself, words like HTTP, JSON, Base64, socket, packet, server, and protocol stop being vocabulary.
They become things you can investigate.
The Game Bridge became our laboratory.
A game move starts as an ordinary object in Swift.
It becomes a packet.
The packet becomes JSON.
The JSON contains encoded data.
The message travels through HTTP.
The server receives it.
The server puts it into a room mailbox.
Another device polls the mailbox.
The message comes back.
The packet is decoded.
The game receives the move.
And a chess piece moves on the other screen.
That sounds complicated when written as a list.
But a student can actually build it.
And when something breaks, the network becomes visible.
We once had a three-player Golden 24 game in which the score changed, but the solved hand refused to advance.
The logs eventually revealed:
Base64 was corrupted.
Why?
Because the packet was being sent as form data.
A `+` inside the Base64 text was interpreted as a space.
One tiny character had crossed a protocol boundary and changed meaning.
We fixed it with `%2B`.
Suddenly the game worked again.
The mysterious network had become tangible.
Learning
This is what I loved about computer science when I was young.
The best concepts were not definitions.
They were doors.
TCP/IP was a door.
Sockets were a door.
HTTP was a door.
Packets were a door.
Layers were a door.
Behind every strange word was a machine waiting to be understood.
And perhaps the most powerful learning experience is not:
“Here is the explanation.”
It is:
“Here is something that doesn't work. Let's find out why.”
A game that freezes can teach more networking than a page of definitions.
A four-letter room code can introduce distributed systems.
A broken Base64 string can teach data encoding.
A server that knows nothing about Chinese chess can teach abstraction.
Two phones communicating across the world can make the Internet itself feel real.
And this is where the textbook changes.
There is nothing wrong with a textbook.
But sometimes the right textbook is the program in front of you.
A student asks:
“How does this message get to the other phone?”
We don't have to answer immediately.
We can follow it.
We can print it.
We can change it.
We can break it.
We can send another one.
We can build a tiny server.
We can watch what comes back.
And then, instead of opening a textbook...
you open the code.
Theme
Make the invisible tangible.
What Is Possible
Can a student build something that communicates across the Internet rather than merely use something built by someone else?
Can a four-letter room code turn two distant devices into one shared game?
Can an ordinary game become a laboratory for understanding networks?
Yes.
How Does It Happen
Follow one message.
Start with the game.
Then look at the packet.
Then the JSON.
Then the encoding.
Then HTTP.
Then the server.
Then the mailbox.
Then the other device.
The layers stop being mysterious when you can watch a message cross them.
Why Does It Matter
The Internet is one of the defining inventions of modern life.
Yet its deepest ideas can remain invisible to the people who use it every day.
Hands-on experimentation changes that.
A child who makes two machines communicate has crossed an important boundary.
The network is no longer magic.
It is something they can investigate.
Something they can question.
Something they can build.
Epilogue
Apple's email said:
Congratulations!
I saved the screenshot.
But what moved me was not merely that Apple had approved an app.
It was the realization that a question that fascinated me when I was young is still alive.
How do machines talk to each other?
Back then, I opened books and experimented with the strange new world of networks.
Today, I can hand that mystery to a student as a working game.
Here is a phone.
Here is another phone.
Here is a four-letter code.
Now make them talk.
And if the message disappears?
Don't worry.
Open the code. 😈