Hans Sperker (@hsperker) header
Hans Sperker (@hsperker) profile picture

Software Engineer, Consultant, loves Traveling, Good Food, Games, Learning, Cars

Joined March 2018
Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)Photo by Hans Sperker (@hsperker)
There is a good programming principle stated here: Don’t write functions for code one can write inline as a simple expression using well-known operations. It’s much easier to read code that uses a small number of common primitives than to remember 1000’s of helper functions.
Today, Linus Torvalds told a Google engineer that his code (updating RISC-V support in the Linux kernel) is “garbage” which “makes the world actively a worse place to live”. Adding that the Google engineer’s code needs to “get bent”. As you might have guessed, Torvalds has rejected that code submission.
144
394
70
6,490
672,467
Hans Sperker retweeted
I've been running five @AmpCode coding agent instances for a couple months. One little piggy works on Emacs. One little piggy builds Node. One little piggy ports old tests. One little piggy reviews code. And one little piggy does wee wee wee random crap the other piggies can't be bothered with. Right now Piggy Five is porting old scripts from Ruby to Kotlin. My piggies are the best. I love Amp. I love coding this way. I'm working via deep, ongoing conversations, keeping my piggies on track and accountable. It was not easy to learn how to work like this. It has been a journey full of traps and surprises. But it has paid off in droves. At least, it has for Anthropic, who bilk me, sorry I mean *bill me, for a few hundred bucks a week. There are naysayers. I can share with you the secret sauce they are all missing. Is it money, you ask? Well, sure. None of us have enough money for this shit. Mostly, though, it's patience. The only way you can be successful with agentic coding is through patience, persistence, and low expectations. Coding agents aren't a panacea. They can't cure cancer. They can't even be trusted. You have to be very patient with them. But they work. The piggy farmers who learn to use multiple coding agents are two to five times faster than you. That's a big difference. And companies are starting to take notice. Be the farmer. Not the piggy.
10
21
7
175
31,466
Hans Sperker retweeted
I like this take by @KentBeck on how AI-assisted programming changes the balance of which skills are most important
18
148
29
1,289
139,332
Hans Sperker retweeted
My Notes: - “Software 3.0” Software 1.0 is code, 2.0 was weights of tightly scoped ML models, 3.0 is using English to program LLMs Just like how in certain use cases software 2.0 would “eat away” at software 1.0 code, software 3.0 will now eat away at a lot of places where we would previously have used 1.0/2.0 - LLMs are like ___ LLMs are kind of like power stations: they require infrastructure, have switching stations (open router) and cause “brownouts” during disruptions in output LLMs are unlike traditional utilities though and more like software. They can easily be duplicated and transferred. LLMs also resemble operating systems: they memory, external devices, networking, etc Similar to the OS space there are a few major closed providers (Mac / windows ≈ gpt / Claude) and a more widespread ecosystem of open source options (Linux ≈ llama). - We are currently in the 1960s shared computing moment for AI Just like traditional computing in the 60s, current frontier AI is expensive and requires immense centralized compute, accessible only over the network, and shared by others when you’re not using it. What will the PC moment for AI look like? - The anatomy of a successful AI empowered app Sees humans as a fundamental part of the loop- 1000 line Devin PR still needs to be reviewed. The best AI empowered apps provide the best experience for their human users by providing: a custom GUI (escape just textual interfaces) + an autonomy “slider” (tab -> cmd K -> cmd L -> cmd I) Really likes the Iron Man suit analogy: the suit is 2 parts: Augmentation: giving the user strength, tools, sensors and information Autonomy: the suit at many times has a mind of its own- taking actions without being prompted How can we design AI products that follow these patterns? - Rate of progress Seemed very conservative on the rate of AI progression. Cited this example of when he rode a Waymo prototype around back in 2014 and had a 15 minute drive with zero interventions. He thought “wow we’ve done it, it’s here”. And while we’ve made a lot of progress since then, there’s still kinks to work out. And we will, but it just takes time. Where `works` is a boolean array of situations where your product “works” or not: A demo is simply `works.any()`, but building a real product is `works.all()` Sees AI in a similar way: explicitly said to avoid thinking like AI 2027 or saying 2025 is “the year of agents” and instead to look at 2025-2035 as the “decade of agents” - Vibe “coding” is the easy part and the rest is still hard Cited example of vibe coding a simple app: cursor wrote most of the code pretty easily. But after that the AI speed ups disappeared: setting up auth, getting environment variables, deployment, registering and assigning a domain, etc Docs are a really important part of this. Explicitly cited Clerks docs which had a 5-10 step long list of instructions for where / when to click. After showing this he literally said “What the hell?” Cited lee rob / vercel adding curl commands to docs where “click” was before as a good first step - AI reverse flow of adoption Previous major advanced technologies (computing, internet, GPS) stemmed from government / large corporation use cases and slowly made their way to consumers. AI so far has had the opposite flow. Consumers are using the tech for the most random mundane things while governments haven’t even started to adopt AI.
Wow fantastic talk from @karpathy at startup school Unbelievably insightful and pragmatic
9
24
3
178
35,723
Some people might read this and think, that's just not my world, I am stuck in this world where software breaks all the time and everything I build is disposable. Even if that is kind of the case for you, there is still good news, because this isn't an all-or-nothing problem. It's a dial that can be turned; you can turn that dial in a direction that reduces flailing and results in more-stable long-term progress. You don't have to remove all the dependencies, because every dependency you remove contributes to stability. Even getting rid of 1/3 of your dependencies can do amazing things. You can look at all the things you depend on and divide them into two categories: major and minor. Major dependencies are things that, realistically, you are never going to have your own version of. I am never going to make my own graphics API, so those count as major dependencies for me (DirectX12, Vulkan, Metal, etc). I am not going to write my own CPU-side font rasterization, so anything I choose to use there (FreeType, stb_truetype) goes in that category. With Major Dependencies, you limit your contact surface with them: You call only the functions you really need, and you do this only from the surface of your program -- you don't build data structures deep into your program that propagate the particular data structures or API decisions of any of these systems. A good API author will help you do this (stb_truetype), a bad API author will be trying as hard as they can to screw you up and force you to become tied to their system forever (anything from Microsoft or Apple). Understanding that many API authors are hostile can cause a big change of perspective here, and once you see it, the correct tactics become much more obvious. So, that's the major dependencies. Minor dependencies are things that are smaller, and that you want to use much more thoroughly throughout your program: for systems programmers this might be a data structure like an expanding array or hash table, for Web, maybe there are some string or file operations that you like to do. Minor dependencies can be eliminated and it's not even hard. You just do one at a time: hey, I need this data structure, I have been importing this other code to provide that functionality, I have suffered X, Y and Z problems because of this, how about if I just implement my own simple version of this one thing? People can get scared of implementing core stuff like this, because they look at the implementation they are using now, and it looks huge and complicated and hard to reproduce. But the thing to realize is most of this implementation is spam. It is mostly doing things for people who are not you, for reasons you don't necessarily agree with, chosen by a decision-making method that is deeply flawed. Your own implementation can be cleaner and smaller, and it can give you good feelings when you go look at it. You don't need all the functionality of the thing you are importing; you only need 8% of the functionality. Implementing that is easy. Once you do this a few times, you have your own stable body of code that you bring with you from project to project. It won't break unless you mess with it. You can keep improving it if you want, incrementally over time, but the cost of this is small because this code represents stable algorithms that don't change with fashion, so work on this is never forced. Every big company has their own internal version of this, but the problem in that scenario is that a big company is full of people who want different things, and have varying levels of decision-making skill, so these usually end up not so good. But when it's your own personal thing, it can in fact be very good, and help make you happy on a daily basis. And, your software will break much less often. Which is great. @NotAShelf @ThePrimeagen nitter.cf/Jonathan_Blow/status/1…
I read this article about software development, which I knew about because I saw Prime reacting to it: notashelf.dev/posts/curse-of… For the most part I think it is fine: a relatively young programmer is doing the healthy work of introspecting on what he should really be doing. But there's one part of the article that I think is a deep mistake, and the author doesn't know it's so wrong because he has never experienced the alternative: "Software doesn’t stay solved. Every solution you write starts to rot the moment it exists. Not now, not later, but eventually. Libraries deprecate. APIs change. Performance regressions creep in. Your once-perfect tool breaks silently because libfoo.so is now libfoo.so.2. 2 I have had scripts silently fail because a website changed its HTML layout. I have had configuration formats break because of upstream version bumps. I have had Docker containers die because Alpine Linux rotated a mirror URL. In each case, the immediate emotional response was not just inconvenience but something that moreso resembles guilt." Yes, this is true in much of the programming world. But there is another world in which people build things that last much longer. I have done it many times. I shipped a binary for this game Braid in 2009 that you can still download and play on Steam 16 years later. If you are pretty young (like 35), you can run binaries on Windows that were compiled before you were even born, which is amazing given how hard they have been trying to f up Windows lately. On an emulator like MAME, you can play arcade games programmed in 1979. If today's software "technology" is so much better, why does it fall apart like tissue paper? The author is not wrong about the cited decay. But this decay is not inherent to the practice of software. It's due to choices made, usually foolishly, by the people designing the systems being interacted with. And, it's due to a lack of knowing better, non-exposure to the sector of programmers who are very concerned with their code lasting a long time, actually. The way you make code last a long time is you minimize dependencies that are likely to change and, to the extent you must take such dependencies, you minimize the contact surface between your program and those dependencies. The actual algorithms you program, the actual functioning machinery you build, is a mathematical object defined by the semantics of your programming language, and mathematical objects are eternal, they will last far longer than your human life. The goal then is to avoid introducing decay into the system. You must build an oasis of peace that is insulated from this constant bombardment of horrible decisions, and only hesitantly interface into the outside world. This means, for example: If you are shipping on iOS, you only reluctantly use any functions iOS gives you, because when you use them, Tim Apple will come along and break your program next year for arbitrary pointless reasons, because Tim Apple does not respect you or anyone you know. This means a program cannot last forever on iOS, because Tim Apple likes breaking your things and watching you submissively clean them up. But the core of your program, which could be 95% of the code, is fine, and you can deploy it elsewhere. This means you have to insulate from Linux userspace, because of all the jackass decision making that introduces constant incompatibilities while somehow never making the system better. Using a library dependency to do font rendering or sparse matrix math? That dependency gets checked into your source tree, a copy of exactly the version you use. Ten years later you can pull down that source and recompile, and it works, because your program is a mathematical object. If you want to upgrade to something newer that has bug fixes and so forth, you are free to do so, but you are also free not to do so, and your program still works. (And how many of these bug fixes do you really need? Your program worked correctly when you shipped it to the greatest extent you could measure, because you are a skillful software engineer who wants to ship things of a high quality). Everyone who got into programming for the joy of it knows, at some level, that the magic of programs is that they represent complexity that is replicable over time (and thus they exist outside of time). But the trashy programmer culture of the past 20 years stopped aspiring to this, and now has forgotten it is even possible. And so long as people have forgotten, decisions will continue to be made that make the problem worse. There are programmers who only write glue code, and who think that's what programming is; to these people what I have written above will not make sense. But the good news for that contingent is, they can always just stop writing glue code and start doing something else! If today's software "technology" is so good, why do you think it needs so much glue? Maybe there is a stylistic problem. So if you are looking for what to do in the world of software that can represent a lasting contribution, maybe this is food for thought. @NotAShelf @ThePrimeagen
41
178
24
1,557
102,461
I read this article about software development, which I knew about because I saw Prime reacting to it: notashelf.dev/posts/curse-of… For the most part I think it is fine: a relatively young programmer is doing the healthy work of introspecting on what he should really be doing. But there's one part of the article that I think is a deep mistake, and the author doesn't know it's so wrong because he has never experienced the alternative: "Software doesn’t stay solved. Every solution you write starts to rot the moment it exists. Not now, not later, but eventually. Libraries deprecate. APIs change. Performance regressions creep in. Your once-perfect tool breaks silently because libfoo.so is now libfoo.so.2. 2 I have had scripts silently fail because a website changed its HTML layout. I have had configuration formats break because of upstream version bumps. I have had Docker containers die because Alpine Linux rotated a mirror URL. In each case, the immediate emotional response was not just inconvenience but something that moreso resembles guilt." Yes, this is true in much of the programming world. But there is another world in which people build things that last much longer. I have done it many times. I shipped a binary for this game Braid in 2009 that you can still download and play on Steam 16 years later. If you are pretty young (like 35), you can run binaries on Windows that were compiled before you were even born, which is amazing given how hard they have been trying to f up Windows lately. On an emulator like MAME, you can play arcade games programmed in 1979. If today's software "technology" is so much better, why does it fall apart like tissue paper? The author is not wrong about the cited decay. But this decay is not inherent to the practice of software. It's due to choices made, usually foolishly, by the people designing the systems being interacted with. And, it's due to a lack of knowing better, non-exposure to the sector of programmers who are very concerned with their code lasting a long time, actually. The way you make code last a long time is you minimize dependencies that are likely to change and, to the extent you must take such dependencies, you minimize the contact surface between your program and those dependencies. The actual algorithms you program, the actual functioning machinery you build, is a mathematical object defined by the semantics of your programming language, and mathematical objects are eternal, they will last far longer than your human life. The goal then is to avoid introducing decay into the system. You must build an oasis of peace that is insulated from this constant bombardment of horrible decisions, and only hesitantly interface into the outside world. This means, for example: If you are shipping on iOS, you only reluctantly use any functions iOS gives you, because when you use them, Tim Apple will come along and break your program next year for arbitrary pointless reasons, because Tim Apple does not respect you or anyone you know. This means a program cannot last forever on iOS, because Tim Apple likes breaking your things and watching you submissively clean them up. But the core of your program, which could be 95% of the code, is fine, and you can deploy it elsewhere. This means you have to insulate from Linux userspace, because of all the jackass decision making that introduces constant incompatibilities while somehow never making the system better. Using a library dependency to do font rendering or sparse matrix math? That dependency gets checked into your source tree, a copy of exactly the version you use. Ten years later you can pull down that source and recompile, and it works, because your program is a mathematical object. If you want to upgrade to something newer that has bug fixes and so forth, you are free to do so, but you are also free not to do so, and your program still works. (And how many of these bug fixes do you really need? Your program worked correctly when you shipped it to the greatest extent you could measure, because you are a skillful software engineer who wants to ship things of a high quality). Everyone who got into programming for the joy of it knows, at some level, that the magic of programs is that they represent complexity that is replicable over time (and thus they exist outside of time). But the trashy programmer culture of the past 20 years stopped aspiring to this, and now has forgotten it is even possible. And so long as people have forgotten, decisions will continue to be made that make the problem worse. There are programmers who only write glue code, and who think that's what programming is; to these people what I have written above will not make sense. But the good news for that contingent is, they can always just stop writing glue code and start doing something else! If today's software "technology" is so good, why do you think it needs so much glue? Maybe there is a stylistic problem. So if you are looking for what to do in the world of software that can represent a lasting contribution, maybe this is food for thought. @NotAShelf @ThePrimeagen
124
549
102
3,822
457,518
I'm going to call it right now. A lot of stuff is going to break on this mission. By design. As part of the plan. Don't get upset. I'm not saying SpaceX plans to fail. I'm pointing out that SpaceX has taken an ultraimportant principle from software engineering, and realized it applies to all engineering. Feedback beats planning. And that, you see, is why SpaceX doesn't do things the NASA way. The NASA way was to gold-plate everything, plan and test and plan and test, and generate mountains of paper detailing every contingency, with every scenario prepared for. SpaceX just shrugs, says "it's unmanned", and sends it. Half the time it blows up. That's the whole point. They don't actually want it to blow up, of course, but they're anticipating that it might. That possibility is part of the plan. Because one rocket blowing up, or crashing, in an actual end-to-end test, beats many, many man-years of planning and plotting. The key realization here is that knowledge only comes from empirical observation. Everything else is just speculative. The sooner you get into a feedback loop, and the faster you run it, the more iterations you can do in less time. This means, while others are planning and speculating, you actually learn something. Relevant data is the most precious thing in the universe. And it's worth blowing up any number of rockets to get it. Because rockets are just stuff. They're just made of stuff. And you can always get more stuff. You can never get more time. So expect to see a lot of things go wrong on this, and other SpaceX missions. Anticipate it. Accept it when it happens. Doesn't mean the dream of the stars is dead. It just means we're doing it cowboy style. This is a valuable lesson for our own lives. If there's something you want to do, something you want to try, some goal you have, it's easy to dip a toe in the water, test the temperature, and plan. A lot. Planning makes us feel good if we're afraid. Because it provides us with the illusion of security. Never mind that we don't know which scenarios are actually going to happen, never mind that we're planning for the wrong thing, planning makes us feel safe. And if we're nervous, we can plan forever. But the difference between the expert and the novice isn't theory or intelligence or plans. It's relevant domain knowledge. Gathered from empirical observation. So the trick is to get into that feedback loop as soon as possible, and run it as fast as possible. Give yourself the most possible opportunities to learn, per unit time. We only learn while we are moving.
Starship will hopefully depart for Mars at the end of next year with Optimus explorer robots!
567
1,267
315
8,249
2,968,188
Hans Sperker retweeted
If by Rudyard Kipling If you can keep your head when all about you Are losing theirs and blaming it on you, If you can trust yourself when all men doubt you, But make allowance for their doubting too; If you can wait and not be tired by waiting, Or being lied about, don’t deal in lies, Or being hated, don’t give way to hating, And yet don’t look too good, nor talk too wise: If you can dream—and not make dreams your master; If you can think—and not make thoughts your aim; If you can meet with Triumph and Disaster And treat those two impostors just the same; If you can bear to hear the truth you’ve spoken Twisted by knaves to make a trap for fools, Or watch the things you gave your life to, broken, And stoop and build ’em up with worn-out tools: If you can make one heap of all your winnings And risk it on one turn of pitch-and-toss, And lose, and start again at your beginnings And never breathe a word about your loss; If you can force your heart and nerve and sinew To serve your turn long after they are gone, And so hold on when there is nothing in you Except the Will which says to them: ‘Hold on!’ If you can talk with crowds and keep your virtue, Or walk with Kings—nor lose the common touch, If neither foes nor loving friends can hurt you, If all men count with you, but none too much; If you can fill the unforgiving minute With sixty seconds’ worth of distance run, Yours is the Earth and everything that’s in it, And—which is more—you’ll be a Man, my son.
559
1,224
167
7,183
635,072
That’s an absurd penalty for @LandoNorris
785
1,480
172
27,641
2,089,984
The future of fixing bugs? Just record them. I filmed 3 separate bugs in an app and gave the videos to Gemini 1.5 Pro with my entire codebase. It correctly identified & fixed each one. AI is improving insanely fast.
189
952
202
6,618
1,138,415
“Coding” was never the source of value, and people shouldn’t get overly attached to it. Problem solving is the core skill. The discipline and precision demanded by traditional programming will remain valuable transferable attributes, but they won’t be a barrier to entry. Many times over the years I have thought about a great programmer I knew that loved assembly language to the point of not wanting to move to C. I have to fight some similar feelings of my own around using existing massive codebases and inefficient languages, but I push through. I had somewhat resigned myself to the fact that I might be missing out on the “final abstraction”, where you realize that managing people is more powerful than any personal tool. I just don’t like it, and I can live with the limitations that puts on me. I suspect that I will enjoy managing AIs more, even if they wind up being better programmers than I am.
This Post is from an account that no longer exists. Learn more
521
2,510
478
16,513
2,754,166
Architecting software products for problem reporting is undervalued. Practically everyone suffers with annoyances large and small in the software they use, but there is rarely a convenient path to effectively communicate it. Like any feature, there is a steep adoption curve — it needs to be trivially easy to make a report. On the developer side, it needs to be easy to recreate the circumstances of the report, which is a tall order; just like it can be challenging to add undo/redo or multiplayer gaming after a product is running, an architecture that can travel back in time a bit doesn’t happen by itself, and highly distributed systems may make it basically impossible. You have to pay for it, both in technical trade offs and organizational structure to track and triage reports, but increasing the value signal from your users can be critical.
38
73
11
870
258,110
Leadership advice from submarine captain David Marquet: „Move the authority [to decide] to where the information is!“ youtu.be/HYXH2XUfhfo
2
„It almost does not matter what you know. Execution is what matters the most!“ — Andy Grove 👉 Why the secret to success is setting the right goals | John Doerr youtu.be/L4N1q4RNi9I #okr
1
"Good code documents itself" is one of the most damaging takes in software engineering. Code itself won't tell you about the decisions and rationale behind it, nor about about higher-level structures and abstractions. All this needs elaboration in documentation.
71
217
52
1,524
When reasoning about system performance first-principle thinking helps to go from iterative to order of magnitude improvement. Napkin math by ⁦@Sirupsen⁩ helps by providing data to quickly estimate the expected performance from first-principles. github.com/sirupsen/napkin-m…
You cannot be agile if you're fighting your code and architecture to make every small change. Conway's Law is pbly the biggest problem that ppl face when adding agility. You can install perfect process, but if the code & architecture doesn't match the new process, you're hosed.
thriving: being energized and empowered to do meaningful work in your role Supported by: - Keep collaboration in balance - Prioritize deep work - Measure outcomes, not hours inc.com/justin-bariso/micros…
1
The Man-DeLorean! I love the level of detail, even has a baby McFly 🤩 found by reddit.com/u/CraisyDaisy/ at reddit.com/r/pics/comments/t…