Goh Ling Yong : Learning to Code at 40 Felt Like Learning to Apologize - Goh Ling Yong
Here is the full Medium article, crafted according to your detailed instructions.
Goh Ling Yong : Learning to Code at 40 Felt Like Learning to Apologize
My journey from confident expert to humble beginner, one syntax error at a time.
The cursor blinked. A patient, rhythmic pulse of white on an endless sea of black. It was the calmest thing in the room. My own pulse was a frantic, irregular drumbeat against my ribs. My shoulders were tight, my jaw was clenched, and a low-grade headache was building behind my eyes. For the better part of an hour, this blinking cursor and a single, infuriatingly polite error message had been my entire world.
SyntaxError: unexpected EOF while parsing
Just two years earlier, my world was concrete and steel, the satisfying grit of dust on my boots, and the orchestrated chaos of a construction site. I was Goh Ling Yong, Senior Project Manager. My phone rang a hundred times a day with problems I was paid to solve. A shipment of reinforced steel was stuck in customs? I knew a guy who knew a guy. A subcontractor was threatening to walk off the job? I could calm him down, find a compromise, and have his crew back to work by lunchtime. My expertise was my identity. It was a comfortable, well-tailored suit I had been wearing for twenty years. People came to me for answers, and I almost always had them. My tools were experience, intuition, and the subtle art of human negotiation.
But here, in the quiet of my study at 10 PM, none of that mattered. The blinking cursor was not open to negotiation. The Python interpreter could not be charmed or intimidated. It didn’t care that I had managed multi-million dollar projects or that I was trying to build a better future for my family. It only cared about one thing: a missing closing parenthesis on line 47. And it was in this humbling, infuriating stillness that I realized what this feeling was. This complete stripping away of ego, this forced admission of fault, this painstaking process of getting the words exactly right. Learning to code at forty didn't feel like going back to school. It felt like learning how to apologize.
The Arrogance of the Expert
A truly heartfelt apology is impossible without first dismantling your pride. You have to be willing to be wrong, and for many of us, especially those who have built a career on being right, that’s a terrifying demolition project.
In my old life, problems were malleable. You could bend the rules, grease a few palms, appeal to a person's good nature. If a blueprint was off by a few millimeters, you could often make it work on-site. There was a buffer, a tolerance for human error, because the work was done by humans. I was a master of that buffer zone. I thrived on ambiguity and solved problems with a blend of technical knowledge and gut instinct. My confidence wasn't just a feeling; it was a professional requirement.
I brought that same confidence to my first "Hello, World!" tutorial. How hard could this be? It was just logic. I’d read a few articles, watched some videos. I felt prepared. I expected to be good at it.
The compiler disagreed. Vehemently. My first programs weren't elegant solutions; they were graveyards of syntax errors. Every confident assertion I typed was met with a cold, red-lettered rebuttal. The computer wasn't a collaborator; it was a ruthless grammarian. It didn’t say, “I think you meant to put a colon here.” It said, SyntaxError: invalid syntax. Full stop. No discussion.
It was a constant, low-level humiliation. My old identity, the competent Mr. Goh who got things done, couldn’t get a simple script to print his own name. I was a novice, a fumbling beginner, and my ego fought back viciously. This is stupid. The language is designed poorly. The instructions are unclear. My mind generated a dozen excuses, all of them designed to protect the fragile shell of the expert I used to be. But the cursor just kept blinking, unimpressed. The error message remained. The code was still broken. And the fault, I was slowly forced to admit, was mine.
The Syntax of Sincerity
Have you ever tried to offer a half-hearted apology? “I’m sorry you feel that way,” or the vague, “My apologies for whatever happened.” These are apologies in form, but not in substance. They are designed to deflect responsibility. They rarely work, because the recipient can sense the lack of sincerity, the absence of specific, accountable language.
Learning to code is learning the art of the sincere apology. The computer, like a person who has been genuinely wronged, demands specificity.
You can’t just tell Python, “You know what I mean.” You have to write print("Hello, World!"). You cannot forget the quotes. You cannot forget the parentheses. If you use a single quote to start, you must use a single quote to end. In Python, the indentation isn’t a stylistic choice; it’s the very structure of the logic. One misplaced space and the entire edifice of your program collapses.
I spent a whole evening debugging a script that was supposed to read a simple file. I checked the logic a hundred times. It was perfect. I was frustrated to the point of quitting. I finally asked for help on a forum, posting my 20 lines of code. The first reply came in minutes: “Your filename is data.txt but you’re trying to open date.txt.”
A single letter. My brilliant logic was worthless because of a single, stupid typo.
This is the syntax of sincerity. It’s the difference between saying “I’m sorry” and “I’m sorry I broke your favorite mug because I was careless.” The first is a gesture. The second is an admission. One is about your feelings; the other is about their reality. The computer doesn’t care about your intentions. It doesn’t care that you meant to type data.txt. It only processes what is there. To make it work, you have to admit your exact mistake and correct it. You have to say, precisely, what you did wrong.
Debugging Is an Act of Empathy
The most difficult part of apologizing is not the admission of fault, but the work that comes after. It’s the process of understanding why your actions caused harm. It requires you to step outside of your own perspective and try to see the world from another’s point of view. This is empathy. And debugging is nothing if not an exercise in computational empathy.
When your code breaks, your first instinct is to blame the machine. “Why isn’t it doing what I want?” But that’s the wrong question. The computer is always doing exactly what you told it to do. The right question is, “What did I actually tell it to do?”
To answer that, you have to trace your own logic, step-by-step, from the machine’s perspective. You have to become the interpreter. You take the variable x, you see that its value is 5. You follow it to the loop, which you told to run as long as x is less than 5. You realize, with a dawning horror, that the loop will therefore never run at all.
You weren’t wrong because you’re stupid. You were wrong because you failed to see the situation from the only perspective that mattered: the computer’s.
There’s a famous technique in programming called “Rubber Duck Debugging.” When you’re stuck, you get a rubber duck (or any inanimate object) and explain your code to it, line by line. “Okay, Mr. Duck, first I’m declaring this variable to hold the user’s name. Then, I’m passing that variable to this function…” More often than not, in the middle of this explanation, you hear your own logical flaw. By forcing yourself to articulate your assumptions, you expose the one that was wrong. It’s the programming equivalent of rehearsing an apology in the mirror, and in doing so, realizing you’ve been focused on the wrong part of the problem all along.
The Reconciliation
An apology’s purpose isn’t self-flagellation. It’s reconciliation. It’s the mending of a break, the restoration of a working relationship. And after hours of struggle, when you finally find that missing parenthesis or correct that typo and hit “Run”… and it works? That moment is pure, unadulterated joy. It’s not a victory over the machine. It’s a moment of connection. Of shared understanding. You have finally spoken its language correctly, and it has responded. The relationship is restored.
I’m a junior developer now. I traded a corner office for a spot in an open-plan layout, and my salary for the humbling title of “junior.” I spend most of my days feeling slightly lost, asking questions that probably sound silly to my younger, more experienced colleagues. I still make stupid mistakes. The red error messages have not gone away.
But something fundamental has shifted. I learned to code, yes. But more than that, I learned to dismantle my own ego, to embrace being wrong, and to find satisfaction not in always having the answer, but in the patient, humble process of finding it. I learned that precision is a form of respect—for the machine, for my colleagues, and for the problem itself.
The blinking cursor no longer taunts me. It’s not a void waiting to judge me. It’s an invitation. It’s the beginning of a conversation. A dialogue that requires logic, precision, and a healthy dose of humility. It’s a chance to build something, and to apologize, sincerely and specifically, every time I get it wrong, until, together, we get it right.
Connect with Goh Ling Yong
Follow for more insights and updates:
Thank you for reading! If you found this helpful, please share it with others.
📖 Read on Medium
This article was originally published on Medium. You can also read it there:
If you enjoyed this article, please consider giving it a clap on Medium and following for more content!