He was writing some niche OS system and the blog was a collection of posts about that system.
I also remember from the discussion thread that the developer had passed away.
EDIT: Looks like the parent post entered the second chance pool (https://news.ycombinator.com/item?id=26998308). Not only did all the timestamps get rewritten, but apparently I can now edit this day-old comment :) Interestingly, it does show the correct timestamp when editing. Off-topic, but thought it's interesting behavior worth mentioning.
I think 10x programmers are indeed usually smarter than ordinary programmers. They don't work out 10x amount of higher quality code, or 10x quality of code, but work in COMPLETELY DIFFERENT DOMAINS -- OS, Compilers, Emulators, etc., they simply solve tougher problems.
And they also have the capacity to hold a lot of code in their brains. This is so amazing. I usually lost myself after just maybe a couple of dozen lines, or a few function hops. Admittedly, my program uses more libraries so TBH the brain trace just stopped whenever it went into a 2000 line long library function. But my project is more trivial than theirs.
It's a bit disturbing to me that this is being voiced as a feat of some kind. Everybody should be doing this and most people are capable of it. I'm sure you are as well, despite your own pessimism. If you're not doing this, there's been some failing among your mentors. You can develop this skill with intent and practice and you really really really should.
That's what the programming part of our job is: not pasting in snippets from Stack Overflow, not asking Copilot for something that you hope is okay, not vomiting code until it gets a big green OK from your tooling, not gluing together library functions whose implementation and constraints we don't understand. You should be developing a clear mental model of your code, what supporting utilities it references, how those utilities work and what constraints they impose, as well as actively considering edge cases that need specific attention and the constraints your code projects outward to its callers.
You won't be able to do this consistently during your first couple years of working. And that's fine. But something's gone deeply wrong with your craft if you haven't gotten a handle on it once you're more professionally mature. But rather than feeling incapable of doing it yourself and in awe of those who do, you just need to commit yourself to practicing it as much as you can until it becomes second nature.
I'm sure that was true for everyone back in the punchcard days. It would enforce a kind of rigor that I can blissfully ignore.
edit: I see the exact same story in the linked thread, so clearly a lot of Russians are very proud of that skill
It Can Be Done (2003) - https://news.ycombinator.com/item?id=39342143 - Feb 2024 (137 comments)
It Can Be Done (2003) - https://news.ycombinator.com/item?id=18415231 - Nov 2018 (18 comments)
(re the timestamps see https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que... - only the front page and /item pages show the re-upped time. Good point about the edit window, I missed that twist!)
https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que...
It can also be Mel
I cannot help but reflect on how my approach was a "hybrid" between both pencil-and-paper and modern-cli-and-ide -- we were coming out of the age of really simple home computers, but not yet in the age of super fast computers with large monitors.
So I wrote BASIC programs in the back of my school notebooks and typed in some of them when I got to the computer.
The blog (in old school design) had a lot of posts and pictures of that era and the people involved building that OS.
https://news.ycombinator.com/item?id=32395589
He also passed away relatively recently.
https://melsloop.com/docs/the-story-of-mel/pages/mel-kaye-cv
This was all code in the heart of an OS - thread switching, interrupt dispatch, synchronization mechanisms - things where even the most rare and exotic error might actually occur and cause a disaster.
But some hazard/cost computation is needed. There was an article in the '90s about a team doing software for an arm for space work (maybe on the shuttle) - they were hyper careful. I figured out that if all of windows had been made at that rate out of code output it would take 100 years to finish and would cost several trillion dollars. Not long after that that space arm suffered some kind of software failure, in space. Wasn't for want of effort by the dev team.
Remember that many errors arise from things outside the code you wrote/studied - some other code corrupted something, buggy behavoir in hardware, and so forth.
As for coding by hand, simulating by hand, flow graphing by hand, I don't think those were all that unusual, just one person took it to extremes and wrote about it.
It looks as if some of them might have been re-drawn for:
https://www.multicians.org/nss.html
and this is the source code in question?
I had totally forgotten about this. I still have the PASCAL book.
https://www.history.com/news/in-1950-alan-turing-created-a-c...
(Might have a lot of details wrong)
I've got a pile of notebooks full of hand assembled Z80 code that my dad wrote in pencil for the Exidy Sorcerer, which he got in 1979.
It was easier to do that, and reason about your program on paper before running it on the actual computer.
