Thursday, May 23, 2019

Picture that makes you touched; The Dawn of Code: MASM, BASIC, and the Birth of Logic


It was 1981.

I was not yet a programmer — only a curious boy watching his father work in an office filled with the rhythmic hum of typewriters and a strange new machine called a dedicated word processor. On the far side of that desk stood something even more mysterious: a terminal linked to a computer that spoke a language known as MASM — Microsoft Macro Assembler.

I didn’t have my own computer yet, but I was already fascinated by how those short cryptic lines — MOV, INT, JMP — could make a screen respond. That was the moment the seed was planted: logic had a rhythm, and electricity had a soul.

Then came 1984.

My father brought home a miracle — an IBM 5150 with a starting RAM of 128 KB. Later we expanded it to the mythical 640 KB, and added a Seagate 5 MB hard disk that clicked like a heartbeat each time it spun. The system booted with PC-DOS and carried the serene simplicity of IBM BASIC.

For the first time, I could speak to a machine without borrowing time from my father’s office. I wrote small programs: plotting sines, counting loops, printing names that appeared like echoes on the green monitor. Each FOR–NEXT loop was a whisper of infinity.

By 1989, I had installed TASM — Turbo Assembler. The syntax was more refined, the responses faster, the possibilities endless. It was no longer just about making the machine obey — it was about understanding the beauty of structure, timing, and how logic itself could form poetry.

Those three milestones — MASM 1981, BASIC 1984, and TASM 1989 — were not just steps in learning programming. They were the chapters of an awakening: from watching code, to writing it, to mastering its silence.

And as I look back now, every beep, every crash, every green pixel was not a failure — it was the machine teaching me patience, teaching me to listen.

Because before there was AI, there was Assembly.

And before there was syntax, there was wonder.


Sunday, May 5, 2019

Excel, Gauss–Seidel, and the Smell of Coal and Steam

Prologue: The Iterative Prayer
In the dim glow of a control room, numbers danced across the black screen. Mass flow, enthalpy, exergy — each variable whispering balance, demanding attention. I sat there with nothing but Excel, a Gauss–Seidel loop, and the hum of a boiler miles away. It wasn’t just math; it was communion with a machine that breathed in coal and exhaled light.

Chapter I: The Manual Gospel
CycleTempo ran its calculations like a cathedral organ, precise and grand. But I trusted my hands on the spreadsheet, cell by cell, iteration by iteration. Jacobi was the slow psalm, Gauss–Seidel the responsive litany. With every pass, the cycle whispered: “Are you balanced now? Does entropy rest?”

Chapter II: The Smell of Steam
Coal dust clung to the air outside the plant. The turbine screamed in metallic prayer. Inside the diagram, numbers shifted: 335.00 K here, 11,772 kW there. It wasn’t sterile. It smelled of ash, heat, and human intent — equations written in fire.

Chapter III: The Dialogue
Excel was no longer software; it was a slate. Gauss–Seidel was not an algorithm; it was a question asked over and over until the plant answered. Δh, ΔT, η — they became more than symbols. They became the language of a living cycle.

Epilogue: Between Coal and Code
Years later, I open the same diagram and still hear the hum. Not just the turbine, but the quiet conversation between man, machine, and math. In the end, every megawatt is a hymn. And every balanced cell is a small act of worship in the Church of Thermodynamics.