@b0rk Setting the bash history to unlimited and aliasing a shortcut for "history | grep" were fantastic for me

@b0rk "forced to solve a problem that requires it" seems to be a common thread here! Mine was trying to get CUDA working on a home computer years ago. Watching Gary Bernhardt's Destroy all Software screencasts really made some things click too.

@b0rk 1. discovering that copying /moving files is so much easier on the command line. 2. the desperate need of having a lot of data stuck on a server I only can access via the shell. nothing like desperation to teach you stuff

@b0rk for me: autocomplete, learning to search back in history and learning the ctrl-* shortcuts to move around and edit what I found into what I want. Each of those felt like a productivity/success/happiness multiplier when I started using it.

I have a hunch that LLM(“AI”)-assistance will join this list soon; just waiting for some solution to get sufficient traction to try that out.

@b0rk A lot of what I've done over the years is to force myself to use the thing I'm trying to learn instead of getting it done "how I know how to do it/have always done it." Scripting languages, shells, editors, new tools or utilities or environments.

@b0rk@social.jvns.ca :

Definitely #FishShell! Having intuitive and discoverable key combinations helped me so much...

I think it would be even better if it had more features built-in!

@b0rk I was
overwhelmed with the number of commands and options that are available. It's important to remember that you don't need to memorize every single feature. You'll memorize the ones you use the most and you can look up the rest.

@b0rk i had very good teachers in university, and having to use it more and more for personal stuff (linux laptop not working correctly after system upgrade, ...) helped also. i keep looking at how other people use it in videos to see what workflow makes it comfortable to use

@b0rk

Youtube videos, especially @distrotube

https://www.youtube.com/@DistroTube

@b0rk I have two friends one of which is a commandline guru. Years ago, the non-guru friend would often ask the guru to do something for him at the commandline and instead of asking the guru for any explanation or even trying to follow what he was doing in real time, the non-guru would record the entire thing with the script(1) command and then study the typescript at his leisure, looking up all the commands used.

@b0rk I passed this question on to Fastmail's support team, who for the most part start with zero shell experience and work their way up to "use it daily in relatively simple ways”. I'll pass on what I get back.

@b0rk Autocomplete goes a very long way. The `cheat` thingy is nice, but being able to just hit `[tab]` and see my possibilities helps _so_ much when writing a commandline.

Unfortunately it's non-trivial to setup. zsh/oh-my-zsh, which you already mentioned, has support for it, but still you have to enable autocompletions as plugins.

@b0rk One trick I like is to make it super easy to lookup man pages. I run my shells inside Emacs and I setup a keybinding that pops up in another window the man page for the command at the cursor —so I can keep typing the command while looking at the man page. I bet it would be easy to do the same in, say, Vim or even screen or tmux, with the man page showing up in a split.

@b0rk better error messages.

Silent failures and incoherent "man" pages absolutely did not help.

@b0rk I switched to fish and my « command line » usage was made a bit easier and I use many fzf powered workflows (find file below ., go back in history…)

@b0rk (I am in the 15+ years command line user group now, but anyways):

- batch processing tools - for me this was the "rename" tool for renaming a lot of files at once. This would be very long and error prone to do with a GUI filemanager, so it was worth the time learning a command line tool
- making yourself comfortable: there is a lot of configuration and settings, and a few changes can make a huge difference! (for me, it's making my prompt red when a command errors, and green otherwise)

@b0rk ctrl-r without a doubt

@b0rk having them broken down, at first I didn't even understand what apt-get does, but then someone on YouTube broke it down and it was quite easy

Same thing with xargs, awk, etc... They still sometimes look like blackmagicfuckery but just breaking them down bit by bit makes it eas{y,ier}.

@b0rk 1. Fuzzy search history (like fzf)
2. Recently I've actually started using copilot CLI. Actually convenient for tasks I do not do as often. "?? grep hidden files"

@b0rk ctrl-r for the shell history becomes immensely more useful when paired with fzf or similar fuzzy finders and it’s probably worth a mention

@b0rk in my opinion, the best way to get people to use a command line interface is proper error messaging. If I forget to include a flag or input that's required, then I want the cli to print what I forgot instead of just printing "invalid input"

@b0rk For the first six months at university our computer science teacher forced us to use the terminal: no Gnome, KDE or even Windows. Brutal but effective as learning this just takes time.

@b0rk Only thing that's ever really leveled me up is shoulder-surfing. I don't even know what I don't know until I see other people doing their thing. (The intersection of this with remote work is left as an exercise for the reader.)

@b0rk dry run options

@b0rk wow both of my reasons are in the article! Git felt much easier to work with in the terminal than with TortoiseGit, and I’ve really gotten into “ricing” my Windows Terminal running PowerShell tabs with oh-my-posh

@b0rk while shell history search is a great relief, positional jumps at the prompt with keyboard shortcuts - between word boundaries, beginning and end - are the enabler for comfortably writing new history. That would be my "one tip".

Helpful to this day: a pattern in note files: # headline, then grep -A1 when trying to recall on a used keyword in the file.

manpage searching in the pager for what args do: after / a space preceding the hyphen will quickly churn a hit

@b0rk realizing that literally nobody "knows it". Everyone just learns the parts that are useful to them.

So learn enough of the shell language to be able to identify what you don't understand, and then pick up stuff as you use it. Cheat sheets and stack overflow are great for finding new tools and getting started, but they're not gonna teach you anything, so read the help docs for the flags you use… and don't worry about the rest. You're not going to be an expert in every tool, that's crazy.

@b0rk
been skimming the replies and being surprised no one mentioned it yet; making it fun! With customisations.

Fun things like adding more colours, use a font with emoji support, modern shell that's not bash or print a colourful ascii fish that lol's at you every darn time you misstype a command.

Silly, unnecessary but fun things makes the terminal life so much more comfy.

@b0rk

What's always been the most help for me is good built-in documentation. PowerShell is amazing for this, every command has huge info pages with many examples, all just a `help $command` away!

In unix shells, man pages are alright and it helps to get comfy with how to use and search them. A third-party helper like tldr or woman-pages (in emacs, also a great app for built-in help) can make that a little nicer.

@b0rk My favorite CLI learning/ remembering trick is to write a cheatsheet in .bash_profile so I see it *every time* I log in.

Then *that* cheatsheet will remind me how to look up *other* cheatsheets for specific things.

Also, the other cheatsheets are often in this system: http://ratfactor.com/cards/um

@b0rk I really found customizing the terminal a bunch (initially ConEMU, then the new windows terminal) made it far less intimidating 🔮💖

(I think my config is here, but likely needs updating 😅 https://gist.github.com/crazy4pi314/c0874aef9a34e35f6ad07cc163662e51 )

@b0rk I'm trying to teach my teenage son how to use the Linux command line - and his age may make him an outlier here - and what's worked so far is to treat the command line like spell incantations, because that really is what they are. You're a computer wizard, [insert name here], so let's learn some spells. After that, it's just about exposure and building comfort with it. I gave him a set of common commands, let him know not to use "sudo rm -rf /", and told him to have at. It;s working.

@b0rk wonderful post!

I'm still uncomfortable, but getting better in the last five years... Some of the tricks mentioned really helped but I often forget them. Some tools are still terribly hard for me like git and ffmpeg. The thing that made me happy with the command line for the first time was creating some small scripts of my own to automate frequent tasks.

@b0rk When I used Windows more, I started to realise that file search took several minutes to fail to find a file I know is there!

So I went back to my old DOS habit of
dir /s /b \*.* | find /i "myfile" | more
and it was reliable.

On Linux I never really stopped using the CLI.

@b0rk I run my terminal maximized, but man(1) doesn't limit the width of text by default, which makes it really hard to read for me.

Now I have "export MANWIDTH=100" in my .bashrc, which makes it much nicer.

@b0rk Surprisingly, what made me most comfortable was switching shells from bash to fish. The syntax highlighting and the pretty colors made visually parsing a command very simple (and enjoyable). fish's autocomplete, sugestions, and simpler syntax also went a long way. It's what made fish such a friendly interactive shell :)

@b0rk motivation with a clear end goal and concrete steps.

I really got comfortable in the command line as a kid when I had to enter a DOS prompt to be able to start playing Lemmings (on a floppy drive!)

@b0rk ah! what an excellent question!

when we were kids, command lines were all that existed, so we got comfortable because we liked computers and this was the way to use them. not much of an anecdote but we felt we should offer it anyway, in a spirit of collaboration.

we'd like to encourage anyone following us who is comfortable with a command line to talk about their experiences too!

@b0rk Since I'm from the last generation that pretty much *had* to use a command-line when they got into computers the question isn't for me, but are you going to write an article based on the replies? Because I'm pretty curious what people have to say :)

Edit: I mean about trends among the replies and such

@b0rk This ain't for me (because I'm floppy disk old) but I appreciate the query because I've got an agenda to indoctrinate some touch-screen kids generation.

@WizardOfDocs What helped you?

@b0rk I teach undergrads command line for working with git and GitHub, and in that context have confronted the weird differences of Windows (vs Mac and Linux) shells. The best thing I did was choose a neutral shell—git bash—to start teaching shell commands so everyone handles file paths and commands like ls the same way.

@b0rk Quick reference guides of the commands I used most, listed in the order of my typical workflows. I kept my list updated as I learned new commands, and thought of it as a sort of spellbook.

@b0rk I wouldn't say "being forced to use it" as much as "needing to use it". If you have a fancy graphical interface that can do all of what you wanna do through command line, then you won't learn.

@b0rk one thing I use fzf for is switching my kubectl context. I set up a keybinding in my shell so that when I type control-K, I get a list of all of the k8s clusters I have set up. Then I can just type a few letters to pick the one I want and hit Enter. I like this because it’s easier for me than remembering the exact names of all the clusters and quicker than typing `kubectl config use-context $X`.

@b0rk this is a very interesting talk on the subject (I was lucky enough to see it live)

https://youtu.be/IcV9TVb-vF4

A couple of interesting points (among the others) it brings up about CLI interfaces:
- The ability of just copy-pasting a series of commands vs the difficulty of deliver detailed instructions for a GUI program
- The discoverability aspect of git<tab>

@b0rk

Two things helped me get comfortable with using the Linux CLI:

1. Finding guides listing steps *and explaining them* for something I was trying to accomplish. The explanations meant I could modify the commands a bit to get custom results.

2. Having time to learn a new way. Often I just needed to get the task done, so I’d do it the slow way. Sometimes I get a chance to learn a faster way.

@b0rk
I am using the command line for too long for your question, but I was missing one thing: pipes, or more general: combining lots of different tools in very flexible ways to get what I want. This was the great thing for me in the old days.

especially interested in what helped folks specifically get over the fear of accidentally deleting their files / doing something destructive on the command line. so far folks have mentioned:

- get started on a raspberry pi / other “safe” environment
- use a fancy prompt that tells you the current directory

(again, only looking for replies from folks who got over this fear relatively recently)

@b0rk something I’ve done before is changing the font colors, like having a red font on a prod server, to make sure I notice right way where I am before doing anything

@b0rk How it's gone for me: using Linux and trying to do something weird, end up breaking something, and then having to manually fix it.

Like you mention in your article, I think git is a great way to get more comfortable with the command line. For most situations, the commands you need to use are pretty simple and straightforward. It's also well documented and the nature of the tool means it's (usually) easy to recover if you screw something up.

@b0rk
- anything that makes me confident i can go back to an OK place if I mess up--history in Git, a backup, a way to rebuild the box i am hacking on from scratch

- a "dry run" way to see what a cmd will do without doing it, e.g. for a bash script with loops/expansions, echo the cmd instead of running it; for SQL, trying a DELETE as a SELECT, or trying it in an uncommitted transaction before committing

@b0rk a minor thing, but a lot of people don't realize tab completion exists. Not only do you not have to remember individual commands, you don't even have to remember their names, just what they start with

@b0rk Great question! I have routine of doing a full disk iso backup right after completing the setup of a new laptop. The code is safe in github. Documents are safe in Nextcloud. It's the laptop's dev setup and the OS that are fragile. I use Partition Magic for Linux, TrueImage for OSX, and Macrium Reflect for Windows. Step (1) make a backup (2) buy a 2nd drive, swap it in (3) do a trial restore (4) hack away knowing you have a solid safety net under you

@b0rk The last team I worked with used to do "Mob Programming" sessions multiple times per week. Each participant takes turns using input devices at the behest of the others. Even with 30+ years unix xp I was learning some new command line tricks. Check out Woody Zuill.

@b0rk @irenes I had access to training material, but what really gave me comfort was just daily use on my MacBook. I think my learning came about from deliberately asking myself, “how can I do this in a shell?”

I think that early emphasis on scripting and shell centric scripting really helped. “from sys import argv, environ” etc.

And finally, I guess the other driver for improvement was always asking “is this the best way? Is there a better way?“

I hope this helps!

@b0rk having actual documentation for it, not just describing the commands but listing the available commands.

https://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html

Alas it looks like @monsieuricon broke https://www.kernel.org/doc/man-pages/ so it no longer links to any man pages, which means remembering https://man7.org/ is now useless because you can't drill down from the top anymore.

@b0rk more of a confession than a useful answer but my inability to type “destroy” correctly when typing fast has prevented more than one botched “zfs destroy foo” from turning into a painful restore session. There might be a UX lesson in there somewhere.

@b0rk i had a unit on unix system administration where each week we got a slightly broken VM, one per student, we had to fix. every week was slightly harder culminating with a totally broken PAM so you couldn't easily log in

we couldn't break anything, it was already broken! and if we broke it too much prof would just re-image the VM. so no fear!

@b0rk tested regular backups.

@b0rk most starters like things like #tmux - #bash-insulter (its fun) and #cmatrix and the obvious
telnet towel.blinkenlights.nl
and for people which go the extra mile, either #adb with #scrcpy for android fun or the limitless options of #yt-dlp
(spice up your music collection with some yt-dlp -x <LINK>
or choose smaller / bigger quality with yt-dlp -F <LINK> ... so much more fun tha any limited and fastly outdatet gui/addon)