1. 0
    What’s your favorite terminal command ? ask programming

So I recently discovered this terminal command on lobste.rs and now it became my favorite git log –graph –decorate –oneline –all

I have been using this command for about a week now and this has been a life saver since it allows you browse git history easily when working on large projects with a lot of commits.

Lastly guys i would like to thank everyone who have enjoyed discussions threads that I started and huge thanks to all those people who replied these threads by sharing their great knowledge with others. Honestly I learned a lot from you guys.

Anyways instead of repetitively posting discussion thread I have decided to post them once a week on Sundays.

I hope everyone had a great weekend and I’m definitely looking forward to great responses from you guys


  2. 7

    Grats on cooling the rate of posting while sticking around! :)

    tig is my favorite replacement for git’s builtins for almost anything related to viewing repository status

    asdf is my preferred language runtime manager, especially when paired with per-project .tool-versions files.

    sl is a fun thing to install on servers to remind people to type carefully

    Honestly, collecting a bunch of little bash scripts to scratch your own itches though is kinda where I’m at these days. I have a cute little snippet for quickly logging notes to myself:

    #! /bin/bash
    set -eou pipefail
    printf "\n---\n# $(date -u +"%Y-%m-%dT%H:%M:%SZ")\n\n" >>"$WORK_NOTE_PATH"
    vim + "$WORK_NOTE_PATH"

    Easy modification (used elsewhere) is to take the arguments to that script and add them in addition to the date in the notes file.

    Another variant is used to quickly generate dated and slugged notes for meeting minutes.

    1. 4

      Oh wow, I use something similar to your notes script to gather timestamped meeting agenda ideas, but using it to create timestamped meeting minutes is a fantastic idea. (I have ADHD, which comes with something they call time blindness, so timestamps really help me reconstruct how time passed.)

      1. 1

        I have basically this same script, which works great from an open terminal window, but I also have a hammerspoon key binding that works globally that I can type which will:

        • switch to iTerm
        • open a new window with a specific profile I have tweaked for this (it’s partially transparent)
        • run my journal command which does basically the same thing yours does so I’m at the end of the day’s journal file in vim insert mode

        It’s really handy for note taking during video calls and other activities where the terminal window can’t be the primary thing going on.

      2. 5

        Not a command exactly, but I only recently learned about $CDPATH which is great when you’re traversing around large source trees. There are other tools for this, like fzf, but what I love about $CDPATH is it’s deterministic, allowing me to build a muscle memory about commands to move to a desired location. Prior to this I used a lot of aliases that are really just shortcuts to cd with a frequently accessed directory.

        1. 13

          Instead of asking low-effort questions once a week what about writing a blog post what you learned during that week and submitting it here? I’d like that much more…

          1. 4

            Having slept a night I feel like this was rude. I’m sorry, @mraza007.

          2. 3

            I had to use double dashes for the command you listed:

            git log --decorate --graph --oneline --all

            It’s neat thanks for sharing.

            1. 3

              Tip: a mnemonic is ‘git log A DOG 🐶’:

              • --all
              • --decorate
              • --oneline
              • --graph
              1. 2

                Or you can use an alias. I’ve had the above or one very similar aliased to ‘git lg’.

            2. 3

              I have a shell command that I wrote called mb which I use kind of like mh or mblaze but on my mboxes. It still doesn’t work exactly as I’d like it to, and I’ve had to get into the habit of backing up my mailboxes as I have corrupted them a couple of times, but I find it is becoming my preferred way to interact with mail. Here’s a little show of the interface:

              > mb  32  # "Jeff Kaufman's Writ  04-18 13:00  Web Audio Echo?
              > mb  33  # eBay <ebay@ebay.co.u  04-19 03:08  =?UTF-8?Q?=E2=9C=85_Order_confirm
              > mb  34  # "service@paypal.co.u  04-19 03:09  Receipt for your PayPal payment t
              > mb  35  # Nicolas Petton <nico  04-19 14:18  Emacs 27.0.91 is out!
              > mb  37  # "Nicky Case's Blog:   02-05 01:50  Mr. Sacks
              > mb  38  # "Irreal: jcs" <news@  04-22 18:31  Learning Emacs With Macros

              The hash characters mean that I can run the whole line as a command and it’ll pull up the message, without me losing the advantages of having some headers available. In a similar vein, I also have an lm command which I think I found in an article on here quite recently, but I’ve enjoyed using it a lot. It works like apropos, but once again lets me run any line as a command and get the man page straight away:

              $ lm lisp
              man 3 common-lisp-controller   # Common Lisp system management tool
              man 1 lispmtopgm   # convert a Lisp Machine bitmap file into pgm format
              man 1 pgmtolispm   # convert a portable graymap into Lisp Machine format
              man 8 register-common-lisp-source   # internal clc commands
              man 1 sbcl   # Steel Bank Common Lisp
              man 1 zenlisp   # zenlisp interpreter
              1. 1

                Have you seen neatmail?

                1. 1

                  I hadn’t, but it looks pretty nice, along with a lot of the other software on that page! I’m definitely going to dig into the source, although I won’t use it exactly as is because it doesn’t fit my criterion that I must be able to interact by executing a full line.

                  That said, it runs noticeably faster than my mb script which was quickly patched together with Python’s mailbox library. Thanks!

              2. 2


                It closes the Amiga shell. Typing it means you’re done, phew.

                1. 2

                  !$ has been my favorite shell “command” lately. It inserts the last argument of the previous command. So, if I blame a file:

                  git blame this-file

                  And then I want to edit that file:

                  vim !$

                  It’s a decent time saver for me.

                  1. 7

                    Or use Alt-.

                    1. 3

                      I think I have new favorite.

                  2. 2
                    #screen emacs
                    1. 1

                      fzf hands down. I never run it directly, but I have it baked into a ~/bin/fuzzy-filter script and many of my shell aliases so it’s a key part of my workflow especially for dealing with situations where you end up with “choose from a list of things with partially memorable names and partial suffixes of uuids or other nonesense”. Like if I want to exec into a running docker container I can drun foo and if there’s only one container who’s name matches foo, the command runs immediately with that container’s name. If there’s more then one match though, fzf pops up a fuzzy filterable list so I type some more to pick the correct container, then the command proceeds with that container name.

                      1. 1

                        I collected a few favorites almost 20 years ago. Looking back at it now, there is one that I still use: color.

                        Really, though, asking for a favorite shell command is like asking for a favorite helper function in a programming language. The value of both lies largely in the surrounding context, in the system of names.

                        1. 1

                          Perhaps not my favourite, but my most popular are:

                          $ cut -d';' -f2 ~/.zsh/history | cut -d' ' -f1 | sort | uniq -c | sort -rn | head -n20
                            10088 git
                             3405 vi
                             3217 go
                             2922 cd
                             2050 l
                             1521 fg
                             1226 lc
                             1042 goatcounter
                              910 ls
                              894 ag
                              764 rm
                              568 wm-brightness
                              386 cat
                              373 psql
                              353 reagent
                              343 set-screen
                              335 man
                              318 alsamixer
                              299 su

                          This doesn’t include piped commands (the grep in ls | grep), so it’s not a full list of everything I’ve run. I can’t be bothered to come up with a program to include that too 😅

                          My favourites are probably grep and sed, because they’re such useful pieces of plumbing that can fit in so many different situations.

                          The most useful custom command I have is probably age, to open ag search results in Vim:

                          # "ag edit" and "grep edit".
                          age() {
                          	vim +'/\v'"$1" +':silent tabdo :1 | normal! n' +':tabfirst' -p $(ag "$@" | cut -d: -f1 | sort -u)
                          grepe() {
                          	vim +'/\v'"$1" +':silent tabdo :1 | normal! n' +':tabfirst' -p $(grep "$@" | cut -d: -f1 | sort -u)

                          P.S. informational nitpick: it’s really a shell command, and not terminal command. A terminal just reads input and displays characters, and a command for that is an escape code which moves the cursor or whatnot, whereas the shell interprets the commands you type (while reading the input from the terminal, and sending the output back).

                          1. 1

                            Your bash one-liner made me curious about what terminal commands I use most often:

                                590 yay
                                560 g
                                488 pass
                                442 sudo
                                404 cd
                                258 rm
                                207 nvim
                                199 rg
                                184 exa
                                154 mv

                            yay is a 3rd party arch linux package manager, g is my alias for git, pass is the standard password manager, rg is the ripgrep utility. Other than those, it’s all pretty commonplace basic command line tools.

                          2. 1

                            yes might be my favorite just because the source code isn’t a simple loop.


                            pushd/popd are pretty useful to, though I’m not sure shell builtins count as far as “terminal commands” go.

                            1. 2

                              The AUTOPUSHD option is a feature that I really like in zsh. It effectively turns every cd into a pushd. This way, I don’t have to try to think about or anticipate whether I might later want to pop back to a previous directory.

                            2. 1

                              If I had to choose only one, it would be awk, but going through my history file it seems to be ls.

                              To replicate @arp242’s command:

                              awk -v OFS='\t' '{ c[$1]++ } END { for (i in c) print c[i], i; }' .bash_history  | sort -n

                              where I get

                              21	vi
                              22	sudo
                              23	mpv
                              24	git
                              34	cd
                              51	ssh
                              75	ls

                              Other noteworthy commands have to be pandoc and ffmpeg, although ffmpeg is one of those I can barley use (for something a bit more complicated that just simple format conversion) without looking the commands up.

                              1. 1

                                Absolutely daily I use:

                                • l PATTERN [DIR]: list files matching pattern, recursively
                                • g PATTERN [DIR]: wrapper around grep with good defaults
                                • gg PATTERN: small wrapper around git-grep

                                (code is at https://leahneukirchen.org/dotfiles/.zshrc)

                                1. 1

                                  Heya, good to see you’re sticking around.

                                  To add some interaction to these threads, how about we all try reply to another response, as well as posting our own?

                                  My favourite shell command … I have a great fondness for the humble tree and tree -if, which see the look-directly-around-you, one-directory-at-a-time ls and gives you a map of the entire directory tree at once. It’s like going to an unfamiliar supermarket and having a bird’s-eye view, instead of having to check every aisle.

                                  1. 2

                                    I’d completely forgotten about tree, which is slightly embarrassing as I use it a whole lot. Do you use tree -if with something like pick? I didn’t know about that set of flags but it seems to me that you lose a bit of the usefulness of the visual layout, although that might just be me.

                                    1. 1

                                      tree -if prints something like


                                      The indentation-based visual layout is nice for small trees. For large trees, where ancestors scroll a long way off the screen, a prefix-based layout shows you the full path directly. Because files in the same part of the tree are next to each other with the same prefix it’s still quite visual.

                                      1. 3

                                        Am I missing something, because I don’t see how this differs from find -type f?

                                        1. 1

                                          Same output, yes; but I learned about tree long before I learned about find, which is why tree is the one that I’m fond of. Fondness was this post’s prompt, hence.

                                          Points for mentioning find, though; because it’s always available as part of POSIX, and tree is not.

                                        2. 1

                                          Yeah, I tried it after you mentioned it. It might just be me, but I still find that it looks quite like a list of files even with the common parents. It’s cool that you find it helpful though :)

                                      2. 2

                                        I would say my favourite command is vim. If you open vim with a path to a folder, rather than a file, it will load the netrw plugin (which is enabled by default) which gives you a directory listing. In that listing, you can move around (with arrow keys or j/k) and you can even search for entries (start typing /git to find .git, for example). You can press - to go up one dir, and t to open something in a new tab. I find that kind of interactive thing to be great for looking around directories!

                                        1. 2

                                          You can also vim open a compressed tarball and edit files inside.

                                      3. -3


                                        rm -rf /

                                        Give it a try; Edward Snowden approves it as a privacy-tool.

                                        1. 0

                                          This should cease this low-effort spam for a while, hopefully.