Then if you’re wanting to only remove the directory if it has a tests subdir, the typical way would be to check [ -d "$TEMPDIR"/tests ] before recursively removing $TEMPDIR. No need for the cds or double remove.

I’m asking why, though. The “variable only” thing doesn’t make sense. If you’re worried about it being unset or not pointing to a directory, use test / [ with -n or -d. If you can’t trust your own script to not change the variable, that’s a hell of a threat model and you shouldn’t remove anything.

But you’re still deleting files with recursion, despite saying

I would always prefer deleting files without recursion and then deleting empty directories. Why is that moot? The point is not to use recursion.

So if you’re using recursion to begin with, rm -rf "$TEMPDIR" is simpler than your rm -rf "$TEMPDIR/tests" && rmdir $TEMPDIR, and works identically except for when $TEMPDIR has other files. But it doesn’t sound like that’s the case.

If you’re always opposed to using recursion, why are you ok with using it to remove the subdirectory?

You’re already deleting files recursively:

rm --verbose --one-file-system -rf "${TEMPDIR:-/invalid/615e1a5d}/tests"

I generally dislike using the set methods to change how the “language” works. So even if it covers my issue, I’m not using it.

If you don’t feel like using it, that’s valid, just as long as you’re aware of the functionality. It seemed fitting here to me because of the potential to simplify the code from a complex chain of commands with hard-coded values to a single command with no hard-coding, while keeping the old behavior.

Also if cd -> rm -rf -> rmdir solves it, why would I need to rewrite and change it to set -u -> rm -rf?

You don’t. You asked for feedback, though, so I gave some.

In general, I’m a fan of set -u because it helps to avoid some common scripting bugs, but if you’re aware of the option and how it could be used, and you choose not to use it, then I’m not going to insist you write it how I would write it.

I think you mistook my asking questions as opposition, or maybe my intent wasn’t clear enough in my comment. My main point was that while I don’t have full context for the problem, it seems to me that a simpler solution exists. Is there some edge case that the cd -> rm -rf -> rmdir snippet covers that’s missed by set -u -> rm -rf?

However, I am very, very afraid of doing rm -rf in context of variables, in case the variable happens to become empty due to user error (or later changes in script).

I get the feeling that either there’s some missing info, a misunderstanding on my part, or there might be a simpler way to do things. Is $TEMPDIR changing a reasonable case to handle? Can you change your script design to make this impossible instead? (Like replacing a source with a script execution?)

If the snippet is just boilerplate at the top of numerous scripts, I’d do set -u, rm -rf "${TEMPDIR}" on exit (ideally defined in a common setup script/function), and just avoid assigning to the var later in the script. In terms of defensive programming, anything extra is added complexity that will only make an error more likely imo. You could rename TEMPDIR to something like TEST_ROOT if you’re concerned about the variable name being accidentally used again, but no amount of trap logic is going to make a future programming error impossible.

One of the games of all time

You said they’re called octets because they’re supposed to be written in octal. I was saying why I don’t think that’s true.

That smells a little like folk etymology to me, are you sure about that? My understanding is that since the word is older than computers and can refer to any group of 8 things, “octet” in computing just came from the need to communicate a group of exactly 8 bits given that bytes aren’t always that size.

Slow depends on the use case. If your main bottlenecks are in code that people have written highly optimized lower-level libraries for, it could be slower to roll your own implementation or use a less mature library in a different language. And in some cases it might not matter if you take 1 ms or 100 ms to do something.

It works the other way too, and you have to weigh the pros and cons of your specific case when you choose a language. What level of abstraction do you want to work at, how stable do you need the toolchain to be, how familiar you are with the language, what’s supported in the language, how easy is it to do what you want, what’s the norm in the domain you’re working in, etc.

Not moving the goalposts at all, you’re just missing the forest for the trees. The main point is that there are plenty of use cases that can use pure C with no assembly. I went with a simple example because I thought you’d have an issue with more complex examples like sending a notification over SMS via modem or providing a serial interface for sensor data.

I don’t feel like arguing for the sake of arguing, though, and I feel like we’re in a pedantry spiral, so I’ll leave the conversation at that. Hope you enjoy your day.

Again, those aren’t universally required. You can make an embedded device that reads the ambient light levels and turns on an LED when it’s dark without thread stacks, privileges, or interrupts. Don’t make your system more complicated than it needs to be.

Not necessarily. Let’s say that…

• The stack pointer is defined in the vector table to point somewhere into RAM.
• The reset vector points to some function _entry(), with a linker script to take care of its memory placement.
• All other interrupt handlers are arbitrary C functions.

You can compile only your C source file that defines _entry() and interrupt vectors, then flash the resulting firmware. No assembly involved, no external linkage, and no stdlib required.

My point is that assembly isn’t strictly required. You can do memory-mapped reads and writes from C all you want, which is enough for plenty of I/O: storage, serial, sensors, GPIOs… You can build quite a few things with these without touching system registers.

I’m not saying we should abolish assembly. Just that it isn’t a universal requirement.

Yeah, if your bootloader is expected to handle that you’re going to need assembly. That can also be delegated to the kernel, RTOS, or bare metal reset vector later on in the boot sequence, though. I had to write a bootloader for an embedded system like this once and it basically just applied firmware updates, validated the firmware, and handed control over to the firmware.

Reminds me of not long after I started using Linux. I thought the kernel was “just a program” like cat and tried to run the kernel from the terminal, only to be disappointed when a new kernel in fact did not start running inside the terminal window.

A little hair-splicy, but an assembly-free bootloader is definitely doable on some platforms – Cortex-M processors load the stack pointer from the vector table, and the initialized memory setup can be taken care of with memcpy.