I like to automate the “popd && rm” part in the alias directly. This bash function enters a subshell inside the tmpdir and when I exit or ^D, it pops back to the previous directory and deletes the tmpdir – with a little safeguard when you mounted something inside it! Had a bad time when experimenting with mount namespaces and accidentally deleted my home directory because it was mounted inside this tmpdir …

tmp() {
  history -w || true
  t=$(mktemp --tmpdir -d tmpdir-XXXXXX) \
    && { $SHELL -c \
     "cd '$t' \
      && printf '\033[31m%s\033[0m\n' 'this directory will be removed upon exit' \
      && pwd \
      && exec $SHELL" \
     || true; \
    } \
    && if awk '{ print $2 }' /etc/mtab | grep "$t"; then
      echo -e "\033[31maborting removal due to mounts\033[0m" >&2
    else
      echo -e "\033[31mremoving temporary directory ...\033[0m" >&2
      rm -rf "$t"
    fi
}

Here is a more recent one for fish as well.

I have nearly the same function, but I’m using ~/tmp has the base, precisely because /tmp is often emptied on boot and I know that I sometimes want to go back to these experiments.

Using ~/tmp helps keep my home directory clean and makes it obvious that the stuff is easily removable, but if, on an off-chance, I might need one of those experiments again, it’s there, waiting for me in ~/tmp even though I might have rebooted in the mean time.

But in general, yes, this is the way to go. I’ve learned it here on lobsters years ago and I’m using it daily.

This is absolutely fantastic. I’ve been independently using this trick for years (through ^R instead of an alias) and I love it too. I didn’t know mktemp took an argument though, thank you!

I like to do programming-language-specific versions of this. So like “newrust” creates a temp dir, puts a Cargo hello world project in there, cd’s in there, and opens my editor. Similarly “newgo”, “newcpp”, etc. Great for playing around.

I tend to have two use-cases for these, one that’s very very temporary (single shell instance), and one that should stick around a little longer (i.e. duration of the boot). This works out to something along the lines of

t() {
	mkdir -p /tmp/t
	cd /tmp/t
}
tt() {
	local dir=$(mktemp -d)
	[ -d "$dir" ] || return 1
	cd "$dir"
	trap "rm -rf '$dir'" EXIT
}

Notably, I use cd because I rarely popd at the end, I usually just close the shell once I’m done with it. I probably should do it anyway though :)

Oh man, thank you so much, this is the kind of “small purpose, great impact” tools that I love! Here’s my fish version where the argument is optional.

function t
    if test -z $argv[1]
        set dirname xx
    else
        set dirname $argv[1]
    end
    pushd (mktemp -d -t $dirname.XXXX)
end

What kind of experiments are you doing with folders exactly? I’m curious about the overall workflow where you would like a folder’s contents or not.

I have the exact same function. It’s so freakin’ useful.

Agree. It’s also not just on reboot; some systems have tools that clean /tmp and other directories (e.g. tmpfiles.d, macOS has similar).

How often do people here reboot? Since moving to the 6.8 linux kernel, I’ve started encountering regular memory leaks and begsn to restart every few days. (Battery life is great, so I stay.)

*nod* One of these days, as I’m now finally starting to get my time management and tooling in order, I’m going to go through the home_old folder where I keep the remaining bits and pieces I haven’t yet triaged from the home directory of the PC I stopped using in 2007.

Maybe it’ll save me the trouble of having to go through mountains of DVD+Rs to find less easy-to-remember-the-existence-of things in the vein of “My original 1997 website, which I want to add to a git history for my current website”.

That post also had https://systemd.io/TEMPORARY_DIRECTORIES/ merged into it which has the best advice at the top – use /tmp for small files, /var/tmp for larger files and $TMPDIR instead of either if it is set.

The article here suggests using /tmp for downloads, which will work on some systems, but on other systems /tmp might be a tmpfs and you’re downloading into memory/swap.

XDG_CACHE_HOME would be the closest match.

On macOS $TMPDIR is a per user location unlike /tmp – although I suspect fewer macs are shared than Linux systems.

This makes me curious. Do you do a lot of work like described in the article on a multi-user machine?

There’s $XDG_RUNTIME_DIR, which is usually /run/user/<uid>

https://specifications.freedesktop.org/basedir-spec/latest/#basics

On my client machines, I create ~/tmp/ and use that as a location to download, unzip source bundles when I only need a single file, throw a clone of a project for a comparison. I have it set up as a ram disk with a 7 day retention so it works more or less like tmp. Additionally, I set the noexec bit on the directory which makes it a better place for stuff that I just want to dig through.

A huge amount of the stuff that I bring onto my box comes through the ~/tmp/ folder first, and after looking at it and deciding I need it for longer I will move things to a disk some where.

I realized at some point that there’s a lot of stuff I know I’d toss in 2 hours but I also didn’t want to put it in actual tmp because it’s shared and I don’t want to mess with permissions or deleting it later.

on distributions that clear /tmp, if you forget to unmount before rebooting, your device/network share can be wiped out.

But this happens during the boot process, not the shutdown process. So temporary mounts will not be mounted anymore. Right?

In what kind of enviornment people use multi-user system? Except at school, where this is not your computer so you should not store things on it anyway, i have never encountered such systems.

Assuming that almost everybody use a single-user personal computer, i don’t see how this is a “terrible advice”.

After a few too many regretful deletes, one of the first things I install on a new machine is trash-cli[1] and add an alias for rm=“trash-put”.

[1] https://github.com/andreafrancia/trash-cli