That reminds me of the usual argument by AI hypers:
“it would have taken me days/weeks/years/… to learn and produce something by myself”.
They forget that often what you need to know can be learned quickly, it’s just mastering (solving the general case) that takes a long time. Learning the piano takes years, learning how to play “Happy birthday” can be done in a few minutes.
> have prided myself on keeping a clean codebase, making 'art-not-science' decisions of when and what to abstract, scope boundaries, then implementing them cleanly, specifically to be easily grok'd by other developers
That’s more of an artist thinking than an engineering thinking, favoriting elegance (cleanness, readability) over practicality. This was not really valuable even though you prided yourself on doing so. It’s like endlessly gushing on the design aspect of the report (the medium) instead of just providing a well-written one (the message).
Code is a medium, and being an artist about it can feel good, but the information processing mechanism (the message), is what’s important. If, after using AI, you can’t reason about the mechanism (nothing about code, files,…), you can’t essentially justify anything about what happens in the software. Meaning data given to it has a non-zero chance of giving garbage answer.
> but new skills are replacing those (context/AI/agent engineering) in equal measure
This is still highlighting surface activities, not anything pertaining to engineering.
I use a frustration threshold. A lot of times, I’ve got a working solution, but it’s not “right”, so when that become frustrating enough, I build something.
A few examples
dotnet does not work on OpenBSD, so to run jellyfin (supported by the infuse app on the apple tv), I have to run Linux. I wonder if I can replicate the API somehow
calibre is quite nice, but I don’t use much of its capabilities. I could try to make a simpler system for my use cases.
> Your tests become limited to things that are hard or impossible to assert with the type system
Type systems are not a panacea. You still have to be logical and careful about them, especially around boundaries where types are just assumptions and not logical inferences. Then you have functions that switch type, but only a subset of the input is actually valid (string -> int for a number parser). Checking for NaN is like checking for Null.
Type systems does help, but they need the same attention as code to be actually helpful.
Not less obvious as it’s generally the way for a group’s member to locate each other if a bit far away. And my receiver does the same for tuning itself. It has a wired microphone that you put in the middle of the room, with a general template on how to put the 5 speakers, then it will play sound on them to estimate phase shift and distance.
This looks like built by someone raised exclusively on web and touch technologies, forgetting that both are the results of constraints. The web was not meant to be a UI platforms and have poor primitives, and touch devices lack precise positioning and a physical keyboard.
There's also that the fact that computing historically have two models as far as managements goes: a) The mainframe model where users have reduced right and there's a set of administrators that are responsible for choosing programs and configuring them b) and the microprocessor model where it's a tool owned by the user and programs acting on the behalf of the users.
The main issue comes from the mixing of those two models where users own a computer, but vendors keep thinking of them as clients for their services. No longer content to use the network as the boundary, they also want a boundary inside the computer. Discord is not that fundamentally different from IRC, and people usually had no reason to sandbox their IRC clients, but you always have to worry about Discord doing some nefarious updates or abusing its role.
> Everything is regular, predictable, documented and easy to read. A file made for one distro only needs trivial changes to run on another. That's what simple really means. I would never go back to init scripts.
OpenRC, s6, rc.d (the BSD), are more simpler than the systemd ecosystem which is feature ladden and not easy to use on the common line. They are also way easier to hack upon, especially when you want to run a lean system (small vm, containers). systemd feels like running windows server for a small php application. The happy path is easy, anything outside of that is torture.
> Pre LLMs, the main barrier to producing software for non-tech people was writing the code, literally.
Based of my several rounds of discussions about every features, non-tech people usually have several unknown unknows about their idea. Their requests are usually one sentence or one paragraph, and then to flesh it out requires several back and forth which usually start with “I didn’t think about that”.
It’s like how everyone has seen people draw, play music, or build an house. But when the time to do so, they’re hopeless to replicate it. Because what you see is just surface level.
reply