Hacker News Reader

Comment by zvmaz | Hacker News Reader

Excellent talk. She seems to be a very likable person. She is right about Bash being full of "gotchas" and trivia and memorizing them all is very hard, but I think it is nice to memorize some trivia. For instance, I tended to forget the order of the arguments of the find command, and I would lose time trying to remember its syntax when I'm in front of a machine with no readily available internet connection. So I committed to learning and memorizing the most common command line tools and some of their "gotchas". I used Anki for that, and some mnemonics, and the return on the investment has been worth it I think.

View on HN

I came here to say Anki is my lifeline for grokking difficult things like DNS.

It was in fact on jvns.ca's book recommendation that I got Michael W. Lucas's _Networking for System Administrators_, and strip mined it for Anki cards containing both technical know-how and more than a little sysadmin wisdom.

It might be one of the highest ROI books I've ever read, considering I actually remember how to use things like nectat and tcpdump to debug transport layer issues at a moment's notice now.

I maintain a file with commands that I don't use often (ex: increase volume with ffmpeg, add a border to an image with convert, etc). I even have a shortcut that'll add the last executed command to this file and another shortcut to search from this file.

Oh, that's a great idea. I have a doc that I maintain by hand, either via ">>" or editing directly. Time to go and make a shortcut. Do you do any annotation to help with the search?

Usually no annotations, as I typically search by command name. But sometimes I edit the file to add comments if there are many examples for the same command.

A large Justfile (https://just.systems/) of random recipes might be a way to make it both executable and searchable (at least on zsh, you can get an autocomplete list of completions from the command line).

Can you think of a single CLI tool that would let me commit a past incantation to a file and retrieve it later? Especially one that syncs well across devices.

The best I can think of is Atuin (https://github.com/atuinsh/atuin) but I wasn't super interested in using it - I kind of want something more lightweight.

I've been using a little set of bash funcs I called `hs` for this for a few years:

https://github.com/mikemccracken/hs

your snippets are stored in a git repo that you can sync around how you like.

Pretty much the same, though I usually just keep the file open in a side terminal. I want to use stuff like cheat.sh (ex. curl cheat.sh/grep) but I never remember.

If you’re already putting them in a file, you might as well put them in a shell script on $PATH: at a certain point I started writing shell scripts and little utilities for relatively infrequently used commands and other tasks (e.g. clone this repo from GitHub to a well-known location and cd to it)

Keeping a ~/bin directory with all your personal shell shortcut scripts has been my go-to for years. I tend to make a lot of project-specific shortcut scripts for anything that I want to remember/becomes a common task.

Wait, how do you “cd to it” from within the script? Doesn’t exiting the script take you back to where you were?

You're right that you often can't modify your current environment by invoking a shell script. That's because it's executed in a sub-shell.

For cases where you need to modify your current environment (setting environment variables, changing directories, etc), you need to run the script using the "source" built-in. That will execute the script in the current shell rather than a sub-shell.

So instead of

    ./some-script.sh

you'd run

    source some-script.sh

or use the dot (".") shorthand

    . some-script.sh

In cases where I need to source a script, I generally create an alias or a shell function for it. Otherwise I may forget to source it.

For this I use shell functions in my .zshrc and I wrote a loader to source a bunch of files in a .zsh.d directory.

Rolled your own direnv?

No, this is global: I use direnv too.

It’s more like “roll your own oh-my-zsh”

Nobody asked but I'd like to chime in with my method.

I have a lot of aliases, for example to start my QEMU VM with my development stuff in it, I make an alias for 'qemu-system-x86_64 [...]' with all the switches and devices and files required, called 'startvm'. I have another that takes me to my current project's folder and pulls the repo. And a third that creates a new folder called 'newproject', creates a small set of folders and empty files with specific names, and finally makes a git repo in it. I am a serial abandoner of projects so I use this more often than I care to admit.

It's not pretty, but functional; and since I always copy my dotfiles when I change computers, I've kept these small helpers with me for a while now.

If you don't mind, it would be awesome to see your cheatsheet. I think this would be a great thing for people to share - like their dotfiles. But maybe they already do and I don't pay much attention to it because I'm lazy - like their dotfiles.

I like `fzf`'s default override of Ctrl+R backwards search for this purpose, along with the fish shell's really good built in autocompletion.

I've been thinking about updating the GIFs in my fzf tutorial to show off fish, but I think I'd rather leave them with ish just so I don't dilute the pedagogical message.

Oh, specially ffmpeg and imagemagick! I have a handful of incantations saved over time.

Just today I saved a new one for trimming borders on video screenshots https://xenodium.com/trimming-video-screenshots to https://github.com/xenodium/dwim-shell-command/blob/main/dwi... (that’s my cheat sheet).

I wrote an Emacs package that works fairly well for saving commands but also making them reusable from its file manager without the need to tweak input or output file paths https://github.com/xenodium/dwim-shell-command

While Emacs isn’t everyone’s cup of tea, I think the same concept can be applied elsewhere. Right click on file(s) from macOS Finder or Windows Explorer and apply any of those saved commands.

Edit: More examples…

- Stitching multiple images: https://xenodium.com/joining-images-from-the-comfort-of-dire...

- Batch apply on file selections: https://xenodium.com/emacs-dwim-shell-command

I tended to forget the order of the arguments of the find command, and I would lose time trying to remember its syntax when I'm in front of a machine with no readily available internet connection.

The man pages are readily available.

The bash man page is huge and hairy, but comprehensive, I've found it pretty valuable to be familiar with the major sections and the visual shape of the text in the man page so I can page through it quickly to locate the exact info I need. This is often faster than using a Internet search engine.

> The man pages are readily available.

True, but I find the man pages not easy and quick to parse.

Right. I don't think you're supposed to read them top-to-bottom.

Use `/` and search for the things of interest (keywords, arguments, options, etc...). Use n/N to quickly jump forward/back.

Find has a particularly bad man page to find things that way.

FWIW it's `-maxdepth 1` not `-depth 1`.

But yeah, you're right.

Dude, flashbacks. Aren’t you supposed to do a trigger warning or something first! ;)

AFAIK there is a find replacement with sane defaults: https://github.com/sharkdp/fd , a lot of people I know love it.

However, I already have this in my muscle memory: find <where> -name '<what>' -type f(file)/d(directory)

Works in 90% of situations when searching for some file in terminal, ie: find / -name 'stuff*'

The rest of the time is spent figuring out exec/xargs. :)

And once you master that, swap xargs for GNU parallel. I bet your machine has a ton of cores, don't let then sit idly. ;)

you can grep the man page contents by using the following command

man <command> | col -b | grep "search_string"

I'm not a fan of man pages. Or any documentation that focuses on textual explanations rather than examples in code (looking at you aws).

I recently found https://tldr.sh/ and found it more convenient. I ended up writing myself a vscode extension to have a quick lookup at my fingertips, since I am at least 60% of the time looking at a terminal in vscode

I've used a small bash function. example : to search grep's manual for "lines", I type gm grep "lines"

gm () { man $1 | col -b | grep --color=always "$2" }

I also have something similar for grepping a command's help

gh () { $1 --help | grep --color=always $2 }

I usually try gh(grep help) and if I don't get what I'm looking for, I run gm(grep man).

It appears that I can also use tldr

For find, I think the Info pages are (even) more comprehensive (info find), and you get more structural navigation.

Comprehensiveness is not a benefit if it's poorly searchable

It might be better to invest in something more general like better docs/cheatsheets (the bad old man pages which you could convert to a text editor friendly format, or something better like tldr, or something like Dash) so you don't depend on the internet, but also don't have to memorize bad designs (since find wouldn't be the only one)

We should stop using Bash, and use TypeScript instead.

Bash is terrible.

well this shell is just broken

  > ls -al
  <repl>.ts:4:1 - error TS2304: Cannot find name 'ls'.
  
  4 ls -al
    ~~
  <repl>.ts:4:5 - error TS2304: Cannot find name 'al'.
  
  4 ls -al
        ~~

Easy...

    $`ls -al`

    ls('al')

And, transpile shortcut strings on-the-fly to TS code:

    ls({
      all: true,
      oneEntryPerLine: true,
    })

Reply on news.ycombinator.com