Today had some important markdown file that accidentally deleted on my SSD and had to go over the recovery of it.
All I did was this:
run sudo systemctl status fstrim.timer to check how often TRIM runs on my system (apparently it runs weekly and the next scheduled run was in 3 days)
run sudo pacman -S testdisk
run sudo photorec
choose the correct partition where the files were deleted
choose filesystem type (ext4)
choose a destination folder where to save recovered files
start recovery
10-15 minutes and it’s done.
open nvim in parent folder and grep for content in the file that I remember adding today
That’s it - the whole process was so fast. No googling through 10 different sites with their shitty flashy UIs promising “free recovery,” wondering whether this is even trustworthy to install on your machine, dealing with installers that’ll sneak in annoying software if you click too fast, only to have them ask for payment later. No navigating complex GUIs either.
I was so thankful for this I actually donated to the maintainers of the software. Software done right.
In that case I would prefer using variables for the filename:
file="/dev/nvme0n1" text="text I remember" strings "${file}" | grep -n "${text}" tail -c -100000000000 "${file}" | head -c 50000000000 | strings | grep -n "${text}" tail -c -123456789012 "${file}" | head -c 3000 > filerecEven if it’s in the terminal, a temporary variable helps a lot. And for a series of commands I would probably end up writing a simple script or Bash function to share.
I could do a script if I knew what I was gonna do ahead of time, or would write one later if I was gonna do it more often.
A variable in the shell is fine, but I still have to skip over it to change the first command, it still breaks up the flow a bit more than not having that
"$file"in there at all.Also if I interrupt the work (or in this case have to let it run for a while), or if I wanna share this with others for whatever reason, I don’t have to hunt for the variable definition, and don’t run any risk of fetching the wrong one if I changed it. Getting by without variables makes the command self-contained.
And it still maintains the flow of left to right, it’s simply easier to take the tiny well-known packet of
cat fileand from that point pipe the information ever rightwards, than to see a tail, then read the options, and only then see the far more important start of where the information comes from, to the continue on with the next processing step.Any procedural language is always as left to right as possible.
If you really want to avoid the cat, I have yet another different option for you:
< /dev/nvme0n1 strings | grep -n "text I remember"< /dev/nvme0n1 tail -c -100000000000 | head -c 50000000000 | strings | grep -n "text I remember"< /dev/nvme0n1 tail -c -123456789012 | head -c 3000 > filerecThis ofc you can again extend with
${infile}and${recfile}if the context makes it appropriate.I understand the reason why you do it this way. Hardcoded and be explicit has its advantage (but also disadvantage). I was just saying that I personally prefer using variables in a case like this. Especially when sharing, because the user needs to edit a single place only. And for variables, it has the advantage being a bit more flexible and easier to read and change for many commands. But that’s from someone who loves writing aliases, scripts and little programs. It’s just a different mindset and none way is wrong or correct. But probably not worth it complicating stuff for one off commands.
And for the cat thing, I am not that concerned about it and just took the last example in your post (because it seemed to the most troublesome). I personally avoid cat when I think about it, but won’t go out of my way to hunt it down. I only do so, if performance is in any way critical issue (like in a loop).