Stuart Thompson
7.7K posts

Stuart Thompson
@StuartDAA
Occasional opinions, never advice. Value and process investor; market and currency agnostic, consumer sovereignty.


Some of you have been giving me grief about my past with the ANC before I became a refugee in the USA. I hear you, politics is messy. But here’s the truth of what I actually did. I was a modern-day Oscar Schindler in my own way. I helped dozens of young people , White, Coloured, Indian, who otherwise had no chance. I fought to get them university bursaries, places in medical school, and real jobs in local government. I also made roads safer by installing speed bumps in front of schools. And I helped a disabled boy get permission for an elevator in his school — opening the door for many disabled kids after him. I did this especially for minorities when no one else was speaking up for them. It didn’t matter what colour they were, if they needed help, I acted. These weren’t just favours. These were lives changed forever , safer kids, future doctors, professionals, and students who could actually access their education. It cost me. Eventually it forced me to flee to the USA as a refugee. I’m not here to relitigate history. I’m proud I chose humanity when it wasn’t easy. To those I helped back then — drop a comment or DM. I’d love to hear where you are now. ❤️ Life’s too short for the anger. Let’s focus on the good we can still do. What’s one kind act you’ve done that people tried to twist? Share below. #HumanityFirst #SecondChances



A Stanford computer science professor has been teaching the same software design class for more than a decade, and every quarter the seats fill faster than almost any other course in the department. Students from Google, Meta, and Apple sneak back onto campus to audit it. Most of them have been writing code professionally for years. I read the book that came out of the class in a week and walked away seeing every codebase I had ever worked on through completely different eyes. His name is John Ousterhout. The book is called A Philosophy of Software Design. Almost everyone in tech eventually hits the same wall. You learn to code. You get good at it. You ship features. 6 months in, you cannot find anything in your own codebase. 12 months in, you are afraid to change things. 2 years in, you start wondering if the problem is you, because everyone around you seems to be drowning at exactly the same depth and nobody is willing to admit it. Ousterhout's argument is that the problem is not you. The problem is that nobody ever taught you what software was supposed to look like. Here is the story almost nobody tells you. Ousterhout was already a legend before he became a teacher. He invented the Tcl programming language, which has been used inside everything from Cisco routers to NASA spacecraft. He built systems companies. He served as a senior fellow at Electric Cloud and as VP of research at Sun Microsystems. By any normal measure he had earned the right to coast. He went back to Stanford instead. The reason he gave in interviews is the part that should make every senior engineer pay attention. He said almost every brilliant engineer he had hired in 30 years of running teams had the same gap. They could implement anything. They could solve any algorithmic problem. They could ship code that compiled, ran, and passed tests. And then 6 months later their own code would start to suffocate them, and they had no idea why. Nobody had ever taught them what good software was supposed to feel like to maintain. Universities taught data structures and algorithms. Bootcamps taught syntax and frameworks. Companies taught company processes. But the actual craft of designing software so that you would not hate yourself in two years was being passed down by accident, in code reviews, by the few senior engineers who had figured it out the hard way. Ousterhout decided to teach it on purpose. He built a class called CS 190 at Stanford, A Philosophy of Software Design. The structure of the class was unusual. Students did not just write code. They wrote code, threw it away, and rewrote it from scratch after detailed feedback. Sometimes 3 rewrites per assignment. The point was not to ship a project. The point was to feel, in your own hands, the difference between a system designed well and a system designed badly. Most students had never felt the difference before. After the class, they could not stop seeing it. He turned the lectures into a small book. It is around 190 pages. The first edition came out in 2018. It costs less than a textbook. It has quietly become one of the most-shared engineering books inside senior teams at Google, Meta, Stripe, OpenAI, and Anthropic. Senior engineers buy copies for their juniors. Tech leads send specific chapters to their teams during code reviews. The argument inside the book is brutally simple. Complexity is the enemy. Not bugs. Not slow performance. Not missed deadlines. Complexity. A system too complex to hold in your head is a system you will break by accident. You will not know which line broke it. You will fix the symptom and miss the cause. Over time, complexity compounds. The codebase becomes a place engineers fear to touch. New features take longer. Old features break for unrelated reasons. Eventually the team starts whispering about a rewrite. The rewrite usually fails for the same reasons the original did. Ousterhout argues that complexity comes from two sources. Dependencies, which are pieces of the system that affect each other across boundaries. And obscurity, which is information about the system that you cannot see from where you are reading. Reduce one, you almost always reduce the other. The deepest insight in the book is about what good modules actually look like. Most engineers are taught to build small, simple modules with lots of small, simple methods. Ousterhout calls these shallow modules and he says they are the disease, not the cure. A shallow module has a small interface and an even smaller body. The interface barely hides anything. To use the module, you have to understand almost everything inside it. Building software out of shallow modules creates the illusion of organization while the actual complexity stays exposed. Good modules are deep. A deep module has a small interface that hides a large amount of functionality inside. You use the module without understanding how it works internally. The interface gives you exactly what you need and nothing else. The complexity is contained. Files have file names, sizes, modification dates. You read and write them. You do not need to know about disk sectors, file allocation tables, or buffering strategies. The Unix file system is a deep module. Most modern abstractions are not. This is the part of the book that makes engineers stop reading and look at their own code with horror. Most production codebases are full of shallow modules disguised as good engineering. Tiny classes. Tiny functions. Long parameter lists. Wrapper layers that wrap other wrapper layers. Every layer leaks information about the layer below it. Every interface forces the caller to understand internals. Engineers wrote it that way because they thought small was good. Ousterhout argues that small is not good. Hidden complexity is good. The module should be doing a lot. The interface should be revealing very little. The second insight that landed hardest for me was about comments. Most engineers are taught that good code does not need comments. The code should be self-documenting. Variable names should be descriptive. Functions should be small enough to read top to bottom. Comments are a sign of failure. Ousterhout argues this is wrong, and that the people who say it have never actually maintained a large system over many years. Comments are not a failure of the code. Comments are how you write down the things the code cannot say. Why a particular approach was chosen. Why a tempting alternative was rejected. What invariants the function depends on. What the caller is supposed to know. None of these things can be expressed in code itself. If a future reader has to read every line of your function to understand what it is doing, you have not finished writing it. The job is not done when the tests pass. The job is done when the next engineer can pick up the file and understand it without asking you a question. The third insight is the one that hit me hardest, because it is the one almost no engineer is taught to think about until it is too late. Strategic versus tactical programming. Most engineers are taught to be tactical. You get a task. You finish the task. You move on. You take the shortest path between the current state of the codebase and the new feature. Each individual decision is reasonable. The combined effect, over years, is a codebase that has been hacked into shape by hundreds of small reasonable decisions, none of which made the system better as a whole. Strategic programming is the discipline of asking, every time you make a change, whether the change is leaving the system better than you found it. Sometimes the smallest task should pay for a refactor that makes the next ten tasks easier. Sometimes the right move is to pause for an hour and redesign the abstraction before you add the feature. Tactical programmers always feel like they are moving fast. Strategic programmers actually move fast. The difference becomes obvious around the two-year mark. Ousterhout's rule is the one I think about almost every day now. The best engineers do not write code faster than bad engineers. They delete code faster. Every line you add to a system is a permanent tax on every future reader. Most of the job of being a senior engineer is deciding what not to write. The book is short. Around 190 pages. You can finish it in a weekend. Reading it once will not make you a better engineer. Reading it twice, then watching yourself catch your own bad habits in real time, then forcing yourself to redesign one module per week using its principles, will measurably change how you write software in less than a year. Almost every engineering team I admire has at least one person who has read this book carefully and has been quietly nudging the rest of the team toward what it teaches. Most teams that do not have someone like this end up rewriting the same system every two years and never understanding why. Ousterhout is still teaching the class at Stanford. The course site is public. The book is around twenty dollars. The single most useful book about how to actually design software is sitting one click away from you. Most engineers will spend a decade learning the hard way what 190 pages would have taught them in a weekend.

In 1921, Mahatma Gandhi asked K.V. Ratnam to make a pen; he issued a challenge that was practically an industrial death sentence. He told Ratnam to build a fountain pen made entirely of Indian materials, or not to bother at all. For 13 yrs, Ratnam operated like a medieval alchemist in the shadows of Andhra Pradesh, trying to solve a puzzle that the British claimed was impossible for an Indian mind. The story started with a failure. Ratnam's 1st attempt was a hybrid pen using foreign nibs. When he showed it to Gandhi, the Mahatma famously rejected it. Gandhi’s logic was brutal: “If the nib is from Germany, the soul of the letter is foreign.” Ratnam went into a 13 yr exile within his own workshop. He was not just making a product; he was fighting a war against Ebonite & Iridium. The British laughed because they believed the tipping of a pen (the tiny point on the nib) required specialized European machinery that no Indian could access/operate. How did a man in Rajahmundry replicate 20th century German metallurgy w/o a factory? Ratnam began experimenting with local materials. He sourced Ebonite (hardened rubber) &, most importantly, developed a secret method to tip the nibs using indigenous alloys. In 1934, Ratnam sent his 100% Swadeshi pen to Gandhi. The Mahatma wrote back a letter that changed history: "I have used it & it is a good substitute for the foreign pen." That single piece of paper turned a small-town workshop into the Official Armory of the Satyagrahi. Before the Ratnam pen became famous, Ratnam was known as the only man who could fix the expensive British Parker & Sheaffer pens of the elite. While repairing the pens of British officers, Ratnam was essentially performing Industrial Autopsies. He was studying the internal mechanics of the Empire’s best tools to build something that would eventually destroy their market. The British officers were paying Ratnam to fix their pens, unwittingly funding the R&D of the very brand that would soon make their imports obsolete in the Indian market. When world leaders met, they often exchanged expensive Swiss watches/German pens. But the Indian leadership carried the Ratnam, a pen made of humble ebonite that did not leak at high altitudes (a common flaw in early pens), proving that Indian low-tech engineering had outsmarted European high-tech manufacturing. If Saha’s pen (story link at the bottom) was a Scalpel (precise, scientific, cold), Ratnam’s pen was a Staff. It was rugged, made of the earth, & designed to write the destiny of a nation on a piece of handmade paper. To this day, the Ratnam Sons workshop in Rajahmundry still uses some of the original lathes. When you hold a Ratnam pen, you are holding 13 yrs of stubborn refusal to accept that "Indian" meant "Inferior." Saha Story Link - x.com/Fintech03/stat…




🔥🔥🔥















