[grayhatter]

I doubt it's possible to draw a concrete line between in domain, and out of domain. Would you mind trying with a specific example? Because so much of engineering is understanding the interactions between systems. While I cant enumerate the exact asm codes, I do need to understand how the compiler is going to rewrite my function if I want to understand if a cast is safe, or if this function call order needs to be rewritten, or if I'm need a mutex to protect this from a torn read.

[fibonachos]

One specific example that comes to mind is developer tooling in the form of bash scripts. Sure, I can write it myself, but I do this so infrequently that there is a cost for the context switch and ramp up. This, and similar dev ex things that have been languishing in the “one day” pile because there is always the next feature to build. I can now spend 10 minutes here and there to ship incremental QoL improvements alongside my core work.

[grayhatter]

You don't have a scripting language in your toolbox that you're comfortable with?

I would probably say a shell is "the correct tool for the job" but other than the appeal to authority, or appeal to tradition. There's not a great argument for a shell script over a language you're already comfortable with.

There are hundreds of examples that are easier or faster in python than shell.

Engineers are bad at making tooling, we're even worse making ephemeral tooling we're willing to throw away. Contrasted with other makers, you have machinests who gladly make a one off tool to make a single process easier.

The more 'correct way' than a shell script, is something simple and composable. A large unwieldy shell script that you can't make simple changes in, is terrible design, and it's a mistake to allow that inertia to gain speed.

It's not exactly a complete refutation but something I've been thinking about recently.

[docheinestages]

I'm not disagreeing with your point. A good understanding of the domain and relevant systems is quite crucial. My point is that you don't always need to inspect the code at such low-level detail, provided there are tests or other ways to prove that the code behaves in the way that you describe.

[grayhatter]

> My point is that you don't always need to inspect the code at such low-level detail, provided there are tests or other ways to prove that the code behaves in the way that you describe.

This is true *only* in isolation. The pain of going through said depth of detail, is what builds the intuition for the whole system. Once and twice may not be noticeable, but a new habit, and that new habit's corresponding extreme downtime because no one understands the quirks anymore... Despite a few engineers who stake their life on the testing system, tests can't catch all issues. And it's extremely difficult to stop an oil tanker.