[csdvrx]

> Checklists are much, much easier to adapt. They can also hold more information than progress indication, like important outputs of the procedure that need to be used somewhere else later, etc.

echo "## Step 2/10 : preparing the SSH key for xxx"

(...)

KEY=$( cat .ssh/id_rsa.pub )

echo "## Do not forget to use this important output somewhere else later: $KEY"

> They can be archived in case I need to understand how I did it on that particular occasion one year ago.

(...)

# 20191102

# TODO: 2 years ago, we decide to use 4096 bits key, make sure to check the length

# in case I forget, how to do that, the number of bits can be forced with -b 4096

# 20201102

# WONTFIX: use ecdsa for the specific host yyyy

So I stand with the author: this is the absolute best solution there is: it can be as simple or as thorough as you need, while being very low tech and simple to use.

And when you find yourself needing to make say an Ansible configuration, you already have most of what you need.

[MaulingMonkey]

This fails on !wsl windows (no `cat`.) Or on *nix if `ssh-keygen` is missing (minimal VM image? new box?) Or on *nix if I absentmindedly used `bash` specific syntax and I'm now in a real `sh` shell. And this is for basic SSH setup!

An aborted script has a good chance of having left things in a broken, half-constructed state, such that simply re-executing the script results in more errors. Attempting to manually resume the script midway will have likely discarded important env variables that I must now figure out how to reconstruct.

...which isn't to say the scripting approach doesn't have value - poor checklist discipline by my coworkers has led me to painstakingly automate more than one perfectly fine checklist, and some stuff is quite scripting friendly - but I've also written my share of scripts that ate up more time in debugging and troubleshooting than I ever saved by writing them in the first place.

[csdvrx]

> This fails on !wsl windows (no `cat`.)

If you really want to argue about details, install git bash or msys2 or busybox and be done with it...

> Or on *nix if I absentmindedly used `bash` specific syntax and I'm now in a real `sh` shell.

Write your scripts in whatever you like as long as you are consistent!

Protip: starting your script with #!/bin/bash will limit the chances they are executed by sh

> An aborted script has a good chance of having left things in a broken, half-constructed state, such that simply re-executing the script results in more errors

Yes, please write good scripts that clean up and are idempotent (!!)

> but I've also written my share of scripts that ate up more time in debugging and troubleshooting than I ever saved by writing them in the first place.

With experience, you will avoid doing things like `echo something >> file` and will replace that with `grep something file || (echo something >> file)` (you get the idea)

[MaulingMonkey]

> If you really want to argue about details, install git bash or msys2 or busybox and be done with it...

"And now you have two problems!"

(My main goal here isn't to argue the details, but to exemplify the many ways scripts end up brittle and go boom in opaque ways, in a way that a checklist and common sense might not. To argue the details anyways: git bash / msys2 scripting always causes more problems than it solves IME - at that point, fire up a real *nix, or switch to a non-shell language like Python or Rust, instead of further entertaining the sunk cost fallacy.)

> Protip: starting your script with #!/bin/bash will limit the chances they are executed by sh

I do so when I can, but bash is missing frequently on oddball targets, so I have good uses for the russian roulette that is `#!/bin/sh`.

> Yes, please write good scripts that clean up and are idempotent (!!)

Easy enough if the underlying tools the scripts invoke are idempotent. Of course, the underlying tools are never idempotent - that'd be too easy.

> With experience, you will avoid doing things like `echo something >> file` and will replace that with `grep something file || (echo something >> file)` (you get the idea)

I've done plenty of that style, and it still tends to be brittle as heck.

`file` might be in use or protected (IDE? Anti-Virus? Previous unkilled build? Uninstall gone awry? Directory corruption? Owner/permissions issues? I've seen it all...)

`file` might fail mid-write (packaging/archiving stuff is a great way to run out of disk IME)

`file`'s format can change wildly between tooling versions, and the resulting errors from using the wrong format might be absolute garbage to the point of not even mentioning `file`.

What you grep for can depend on all kinds of implicit state (I once had a Android unit-testing script break because `adb logcat`'s default format depends on settings stored on the phone, and the default changed between Android versions at some point! Grepping errors to differentiate retryable errors vs fatal vs expected non-errors tends to break as tool authors don't think of error messages as part of their stable ABI, nor should they...)

Experience helps, but sometimes the problem is fundamentally intractable/dynamic enough, and the task executed infrequently enough, that even an automation expert would be better served by manually executing a checklist and hand-editing files, instead of writing a script and trying to decode the error messages when it inevitably explodes each time it runs due to unexpected dependencies on undocumented underlying state.