
Mastering Bash and Terminal - blockloop
https://www.blockloop.io/mastering-bash-and-terminal
======
Normal_gaussian
Rather than temporarily suspend vim to use the terminal you can get vim to
suspend and resume itself with the exclamation mark command. This has the
benefit of not wreaking havoc on your vim session and allowing you to read
data into vim by prefixing with r.

For example

    
    
        :!ls
        

will execute ls and show you the result (press enter to return)

    
    
        :r!ls
    

will read the result of ls in for you

More usefully

    
    
        :r!sed -n5,10p that/other/file
    

will read lines 5-10 from that other file.

However you will most often want to

    
    
        :!make
        :!up build
        :!git status
        :!git commit -am "Fixed #23"

~~~
u801e
Regarding the last git command you listed, I actually find it better to do

    
    
        :r !git status -v
    

And at the to of the result, type my formatted git commit message, visually
highlight the message I just typed, and then use the following vim command

    
    
        :r !git commit -F -
    

Which reads the commit message from standard input.

~~~
fragmede
That's interesting, why not just do `git commit` at the command line?

~~~
u801e
It's more of a way to be able to commit without having to exit or suspend vim.
I typically type the commit message while checking the diff. If I find an
error in the diff, I'll switch to the vim window with the file, correct the
issue and run :!git add %, delete the original output of the git status -v
command I ran earlier and I re-run that command (which I can pull up by using
q: to bring up the vim command history window).

------
greenspot
Great post & thread, a tl;dr:

    
    
      Ctrl-r      search history
                  - then Ctrl-r again to show next match
                  - then Tab to show all options
      Ctrl-p      previous command or arrow up
      Ctrl-n      next command or arrow down
      export HISTCONTROL=ignoreboth:erasedups
                  Add to .bashrc to avoid duplicate entries
    
      Ctrl-a      to beginning of line
      Ctrl-e      to end of line
      Alt-b       one word back
      Alt-f       one word forward
      Ctrl-k      delete to end of line
      Ctrl-u      delete to beginning of line
      Alt-d       delete to end of word
      Ctrl-w      delete to beginning of word
      Alt-Backspc same
    
      cd -        change to last dir
      pushd <dir> mark current dir and go to <dir>
      popd        go to marked dir 
      z           fuzzy cd, install from https://github.com/rupa/z
      j           fuzzy cd and more, install via autojump
    
      Ctrl-z      to background & suspend
      bg          recent background app continue running
      fg          bring recent background app to front
      disown -h   remove recent background app from current tty
      fg %n       bring nth app to front, e.g.: fg %2 for second
    
      less        better than cat, doesn't flood screen, same keys
      find        find files, e.g. find / -name <filename>
    
      ag          install via the_silver_searcher, faster grep
    
      tree        shows dir like a GUI app, install
      !!          last command, e.g. sudo !!
      fish        bash alternative with more sensible defaults
    
      man bash    read more about bash

~~~
yamaneko
There is Ctrl-y for pasting deleted strings, which goes along very well with
these commands:

    
    
      Ctrl-k      delete to end of line
      Ctrl-u      delete to beginning of line
      Alt-d       delete to end of word
      Ctrl-w      delete to beginning of word
      Alt-Backspc same
    

Bash keybindings behave like Emacs by default, hence every time you invoke one
of these, it will put the string into a buffer, which can be later pasted
using Ctrl-y.

This is very useful. For instance, if you remembered that you didn't `mkdir
/mnt/disk` while in the middle of the command `mount /dev/sdb /mnt/disk`, you
can delete what you have already typed with Ctrl-u; issue `mkdir /mnt/disk`;
than you can paste the previous command with Ctrl-y. Very useful and I use it
all the time! (Ctrl-u have never tied to my muscle memory, so I usually do
Ctrl-a Ctrl-k to move to the beginning of the line and delete what comes
next).

Other tips:

    
    
      cd            goes to home dir
      Ctrl-]        moves cursor to character (such as vim f)
      Ctrl+Meta+]   moves to character backwards (vim F)
    

I also put these in my .bashrc for searching history pressing up/down.

    
    
      "\e[A": history-search-backward 
      "\e[B": history-search-forward 
    

This is different of searching with Ctrl-r. When you type part of a command,
such as

    
    
      mkdir /dev
    

and press up, it will complete with previous ocurrences of commands starting
with `mkdir /dev`. It is faster than Ctrl-r if you already know what to do.

~~~
pjvandehaar

      "\e[A": history-search-backward 
      "\e[B": history-search-forward 
    

These have to go in `~/.inputrc`, right?

~~~
yamaneko
That's right! Sorry for the late reply.

------
oblio
The article is nice but a small part of it rubs me the wrong way:

> I know there are some cool newcomers out there like zsh and fish, but after
> trying others out I always found that some of my utilities were missing or
> ill-replaced.

First of all bash was first released in 1989 and zsh arrived just 1 year later
so zsh is in no way a newcomer.

Secondly zsh is almost strictly a bash superset so I don't know what he was
missing (or what he found "ill-replaced").

~~~
blockloop
I wasn't so much commenting on the release date when I said "newcomers."
Mostly commenting on my personal experience. I've been using bash for a long
time and only recently have I seen zsh get so popular. It's entirely possible
that only the people I know have only recently taken an interest in it.

I would have to run zsh again to remember the pieces that I didn't like. I
might have been able to configure my way around it, but I do remember things
not working as I expected them to.

~~~
oblio
zsh was quite popular when I first went spelunking in *NIX-land (2005). oh-my-
zsh, which was a decent boost to zsh popularity, seems to have been around
since 2009 ([http://ohmyz.sh/](http://ohmyz.sh/)).

zsh has always been held back by the "default browser"-syndrome: Linux and Mac
OS both come with "good enough" default shells, so few people actually want to
go through the effort of switching.

Especially since there is a bit of a learning curve to becoming more
productive with zsh than you already are with bash.

~~~
dotancohen
The problem with installing zch on my desktop is that I won't have it on the
servers I SSH into. I need to know the proper spells and incantations that
will work on a wide variety of distros and versions, many of which I don't
personally maintain. Therefore, bash.

~~~
abalashov
Indeed. The same argument applies to other exotic tooling, interesting vim
plugins with many dependencies, etc.

It's one reason to keep one's environment relatively standard and boring.
Otherwise, one comes to be dependent -- psychologically, at least -- on one's
meticulously configured custom environment, and either chafes at its absence
elsewhere or spends a great deal of time copying it everywhere.

~~~
dotancohen
I must admit guilt to dragging my .vimrc and sometimes the whole of ~/.vim/
into machines that I'll be SSHing into for only a short time.

~~~
abalashov
Me too. :-)

------
teddyh
Regarding macOS and bash, it is slightly remiss of the article to not at least
mention that the version of bash in macOS is

1\. Ancient.

2\. Will most likely never be updated by Apple

(Most GNU- and Linux-based systems, and also Windows, on the other hand,
continue to use the latest versions.)

~~~
KKKKkkkk1
Why are you saying that Apple will not update bash? Wouldn't that be in the
best interest of its users?

~~~
teddyh
It would indeed be in the best interest of its users, but Apple has apparently
decided that it would not be in _its own_ best interest:

[http://meta.ath0.com/2012/02/05/apples-great-gpl-
purge/](http://meta.ath0.com/2012/02/05/apples-great-gpl-purge/)

[…]

 _Anyway, the message is pretty obvious: Apple won’t ship anything that’s
licensed under GPL v3 on OS X. Now, why is that?_

 _There are two big changes in GPL v3. The first is that it explicitly
prohibits patent lawsuits against people for actually using the GPL-licensed
software you ship. The second is that it carefully prevents TiVoization,
locking down hardware so that people can’t actually run the software they
want._

 _So, which of those things are they planning for OS X, eh?_

 _I’m also intrigued to see how far they are prepared to go with this. They
already annoyed and inconvenienced a lot of people with the Samba and GCC
removal. Having wooed so many developers to the Mac in the last decade, are
they really prepared to throw away all that goodwill by shipping obsolete
tools and making it a pain in the ass to upgrade them?_

~~~
bitserf
Or, it could just switch the default shell to Z shell. First thing I do on a
new Mac, is chsh -> zsh. Ships with an up to date (enough) version of that.

~~~
mitchty
zsh was even the default shell for an OS X release, 10.3 or 4 can't remember
at this point.

~~~
em500
Nope, before switching to bash in 10.3, tcsh was the OS X default.

~~~
mitchty
Yep looks like you're right, I could have sworn that zsh was after tcsh then
bash from there on out. Went looking in my Mac OS X for unix geeks book and it
was right on the transition so bad memory no cookie. I'll punish my brain with
beer for its transgressions.

------
whack
Personally, I found the following to be extremely easy and powerful. A no-
brainer that should be a bash default really.

    
    
      if [ -t 1 ]
      then
        #   search for commands that start off with the same characters already typed
        bind '"\e[A":history-search-backward'
        bind '"\e[B":history-search-forward'
      fi
    

One of my friends also recommended version-controlling your config files and
storing them on gitlab, which I'm only sad I didn't do sooner. It's been such
a help in keeping my aliases and configs in sync, as I make changes across
numerous different machines.

~~~
mjlangiii
I'm sorry, can you explain how to use this?

~~~
whack
Just stick that snippet in your .bashrc file

------
h2hn
I actually resolved most of that common issues with just bash: :)

 _Substring history search, so you can use just a substring to look for a
argument,command. Binded to ctr+r /s by default. ;)

[https://github.com/liloman/asyncBash#use](https://github.com/liloman/asyncBash#use)

_Changing directories: Last n directories, transparent popd/pushd.

[https://github.com/liloman/dirStack](https://github.com/liloman/dirStack)

 _Movements: vim-surround for your cli, so you can do ysiw " o whatever... ;)

[https://github.com/liloman/bash-surround](https://github.com/liloman/bash-
surround)

_Control-n right: So just type the start and control+n to search for the
arguments/commands starting with whatever. And the classical up/down to look
up for a complete history line:

[https://github.com/liloman/dotfiles/blob/master/bash/.inputr...](https://github.com/liloman/dotfiles/blob/master/bash/.inputrc#L234)

[https://github.com/liloman/dotfiles/blob/master/bash/.inputr...](https://github.com/liloman/dotfiles/blob/master/bash/.inputrc#L170)

There're a ton of hidden functionality and customization behind the classical
bash instalation. :)

~~~
tambourine_man
That is amazing, thanks for sharing.

I'm gonna steal some ideas from asyncBash

~~~
h2hn
I'm glad you liked it. :)

I don't understand why the default bash/readline doesn't get something related
for substring search or way better autocompletions, it's really not that hard
definitely (actually quite easy) and even when that's the reason for a lot of
people to choose zsh over bash.

------
wyclif
_I also assume you 're using bash. I know there are some cool newcomers out
there like zsh and fish_

While there is much useful in this post, I always find comments like this one
odd. bash was released back in 1989, zsh was released one year later, in 1990.
One year difference in age almost thirty years ago means that you can't really
call zsh a newcomer. Maybe he's talking about adoption, though.

~~~
blockloop
I was definitely talking about adoption ;-). See my comment
[https://news.ycombinator.com/item?id=13400707](https://news.ycombinator.com/item?id=13400707)

------
alphast0rm
For changing directories, you can also use something like z
([https://github.com/rupa/z](https://github.com/rupa/z)) to jump around:

    
    
           Tracks your most used directories, based on 'frecency'.
    
           After  a  short  learning  phase, z will take you to the most 'frecent'
           directory that matches ALL of the regexes given on the command line, in
           order.
    
           For example, z foo bar would match /foo/bar but not /bar/foo.

~~~
kbd
Also fasd, which has a z-compatible interface and does a little more:
[https://github.com/clvv/fasd](https://github.com/clvv/fasd)

------
TheAceOfHearts
I've tried bash, zsh, and fish. After trying all three, I'm staying with fish.
bash and zsh don't have sensible defaults, and configuring them is tedious.
fish works great out of the box, and it's really fast. When I picked up zsh I
used oh-my-zsh and later prezto, but it was slow and figuring out what
everything all the framework did was complicated.

With fish I have a setup.fish script that defines all my universal exports,
for when I setup a new computer. This is for private tokens, like
HOMEBREW_GITHUB_API_TOKEN. For aliases and utilities, I wrote a fisherman [0]
plugin. It has a functions folder and a fishfile for the few other plugins I
use.

[0]
[https://github.com/fisherman/fisherman](https://github.com/fisherman/fisherman)

~~~
eknkc
I use fish too but I'm thinking about switching back to zsh. Mostly due to
incompatible software here and there (like nvm) and lack of completions for a
lot of cli tools.

~~~
TheAceOfHearts
asdf [0] is a great alternative to nvm. The best part is that it supports
multiple languages and it's fast. I use the plugins for elixir, erlang,
nodejs, and ruby.

Many CLI tools are missing completions, but I think it's slowly getting better
over time. The pros outweigh the cons for me.

[0] [https://github.com/asdf-vm/asdf](https://github.com/asdf-vm/asdf)

[1]
[https://github.com/fisherman/fisherman](https://github.com/fisherman/fisherman)

------
why-el
In the spirit of sharing: one of my favorite lines in my bashrc is the alias
of `rm` to `rm -i`. This prompts for a confirmation. You might not need it but
I deleted some important, not-yet-checked-in-git files in the past by
accident.

If you want to delete everything and don't want to keep typing yes just do
`yes | rm bla`.

~~~
RJIb8RBYxzAMX9u
No need to do that: just pass -f. The last flag "wins":

    
    
      $ rm -fi blah
      remove blah?
      $ rm -if blah
      $ # confirmation suppressed

~~~
Symbiote
With GNU rm, you can put the -f at the end, which I do for safety.

    
    
      rm -i x y z -f

------
lxe
The one tool that saved me quite possibly a few months of typing paths over my
lifetime is autojump:
[https://github.com/wting/autojump](https://github.com/wting/autojump). I
can't imaging a terminal workflow without it.

~~~
stinos
This should be shouted out regulary to anyone using any type of command line
until everybody uses it. I cringe everytime I see someone spelling out cd
/mega/long/path/to/a/place/i/visit/multiple/times/every/single/day. Ok some of
them already know about tab completion, but it just hurts to see that knowing
all that's really needed is _j d_ or _z d_ or so.

------
xolb
One that I learned from Mr. Robot: put a space before the command to avoid
being registered in the history.

~~~
jlgaddis
That only works if $HISTCONTROL includes "ignorespace" or "ignoreboth".

------
alkonaut
> "tool that every developer uses regardless of language, platform, or
> framework it's the terminal"

I'm not sure I agree with that. If you work in a decent IDE and your vcs is
not git then you can do pretty well without a terminal. Especially on Windows.

------
llasram
Worth it just for finding out about `stty -ixon`. I never would have guessed
from the `stty` man page description that this option would give me back C-s
and C-q to bind to something actually useful.

~~~
uuoc
It is described perfectly, but it does presume the reader knows the meaning of
"XON/XOFF flow control".

Whether the reader knows that meaning immediately is a rather good proxy for
just how long they have been working and/or playing with computers. Long ago,
in a world of RS-232 connected display terminals and/or analog telephone
modems, one became _very_ familiar with "XON/XOFF flow control".

------
pmoriarty
bash (and shells in general) are so hacky (in a bad way) that I wouldn't want
to waste my time mastering them. Whenever a shell script grows beyond 10 or 20
lines, I try to rewrite it in a "real" programming language. Fancy shell
tricks are a code smell to me, and clarity and simplicity are of far greater
importance.

For me, as far as shells go it's usually enough to know the basics and be able
to look stuff up when debugging other people's shell scripts.

~~~
Karrot_Kream
While I understand this sentiment, I think it's a point that needs a bit more
thought; it's not a black and white issue.

On my personal machines, I often find places where I want to either clean up
my desktop experience or automate some workflow, where I break some shell out.
Most of the time, the overhead to drop into an actual programming language is
quite heavy, and even though I try to comment my scripts and write them in a
maintainable fashion, I only end up editing them maybe a few times a year.

I feel like discouraging shell scripts is part of what's driving us to seek
increasingly heavyweight solutions like systemd in our architecture. Sometimes
a lightweight environment where we trust the programmer is needed.

~~~
pmoriarty
I'm about as anti-systemd as you can get, but I also cringe whenever I look at
some of those massive, convoluted shell scripts in SysVinit. There is a middle
path, with runit[1], which mostly uses short, simple shell scripts for its
process initialization and supervision.

Brevity and simplicity are really the keys when it comes to shell scripts. I
really don't have a problem with them if they're short and don't try to be too
clever. Whenever I've let my shell scripts get long or complicated, I've
always regretted it, and always wound up rewriting them in a "real"
programming language anyway, and then realizing that I would have been better
off rewriting them much earlier, as soon as they'd outgrown the short, simple
stage.

There's no shortage of relatively light-weight "real" programming languages
like Perl, Python, Ruby, Lua, and Go -- for even moderately sophisticated
tasks, all of them would be better choices than shell scripting.

[1] - [http://smarden.org/runit/](http://smarden.org/runit/)

------
johnchristopher
I love `set -o vi`. It gives you vim motion in the terminal.

------
gigatexal
Instead of ctrl-z and bg why not just do # <cmd> & to push it to the
background.

~~~
number-sequence
I don't know if you can bring a process back to the foreground using the

~~~
gigatexal
it does work. I just tried it.

#> watch -n 1 dmesg & #> fg -- brought it back

------
gogolb
On macOS, instead of

    
    
        ip addr show en0 | grep -inet\ | awk '{ print $3 }' | awk -F/ '{print $1}' | pbcopy
    

you can use:

    
    
        ipconfig getifaddr en0
    

If you wanna stick with ip addr, a more compact command is:

    
    
        ip addr show en0 | awk '/inet/{split($2,a,"/"); print a[1]}'

------
Scea91
One thing I am struggling with is that when I use several terminal windows
then the history is not recorded immediately and history from one window is
not available in other windows. Some time ago I was looking up how to solve
this but didn't find a solution that would work for me.

~~~
MarcScott
This bugs me as well. I use a tiling windows manager, so terminal windows are
completely disposable to me, and I'll open and close them at will, often
having double digit terminals open across 10 desktops.

My bash history does not reflect my use of multiple terminals.

------
hiq
About bindings, it would have been better to redirect to:

LESS=+/"DEFAULT KEY BINDINGS" man readline

assuming it exists on mac.

About suspend, what's the benefit of suspending vim using C-z? Shouldn't you
use a terminal multiplexer instead, or even terminal tabs if you don't want to
learn how to use tmux or screen (which I find weird if you already spent time
to learn how to use vim but alright)?

I only ever suspend a program when I want it to stop, for instance because it
slows other programs and I realize I would rather resume it when I'm not in
front of my computer. Even in that case, I often just renice the program
instead. Stopping a program just because you want to run some bash commands
looks like an anti-pattern to me, but maybe there are better motives I'm not
aware of.

~~~
blockloop
I use tmux. The benefit of using suspend is not having to move around multiple
windows/tabs. I try to keep those to a minimum (usually one or two). With
suspend I can stick with the same tmux window for editing and cli within the
same context. It's a personal preference over managing multiple windows.

~~~
hiq
To stay on the same window I would personally use a split-window depending on
the size of the display. I didn't think about the context though, good point!

------
danielrm26
Rather than trying to remember all those commands for moving around in your
command, I recommend turning on vim mode for the command line, and remapping
ESC to "jk".

bindkey -v bindkey -M viins 'jk' vi-cmd-mode

Then you can edit your command line the same way you would edit a line in vim.

~~~
kpil
But come on, the default mode is "emacs" for a reason.

------
blunte
Those Emacs commands you mention for moving around on the line also work in a
lot of other text fields, in a lot of other programs.

Notably they don't work in MS Office, but they work in web browsers and
practically every other app I have on my Mac.

~~~
ubernostrum
They work in so many things because they're the default keybindings for the
movement commands in readline. So anything using readline gets them for free.

------
santaclaus
I'm curious about the popularity of Bash vis a vis, say, Csh. Is Bash more
popular due to superior features, or is simply because it is the default on
quite a few *nix distros (and macOS)?

~~~
pmoriarty
I used to use zsh way back in the day because it was clearly superior to bash,
then decades ago switched to bash because it was everywhere by default and my
job involved using lots of computers that only had bash on them, then about 4
or 5 years ago I switched back to zsh because I realized that it really didn't
matter that I used zsh on my own machine and bash on others, and zsh was still
better than bash.

These days bash seems to have a lot closer feature parity to zsh, and I'd be
curious to read an up-to-date comparison of both shells to determine if either
is clearly better than the other.

------
coldtea
> _If there is one tool that every developer uses regardless of language,
> platform, or framework it 's the terminal._

Sounds like the author never heard of Windows development.

------
Graziano_M
> Now that we know we don't need the up and down arrow keys, what about the
> left and right? Unfortunately, these keys are still needed for single
> character movements...

What? No. Use Ctrl-f and Ctrl-b. I use this probably more than any other
readline shortcut.

Ctrl-h for backspace, Ctrl-d for delete. Half my keyboards don't even have
arrow keys and I don't miss them.

------
teddyh
> _8\. alt-w - delete the word behind of the cursor_

He means “ctrl-w”. But since that only works in bash, not in Emacs or other
tools with Emacs key bindings, it makes more sense to use (in his terminology)
“alt-backspace”. This does the same thing, and works _both_ in the shell and
in Emacs-like environments.

~~~
syrrim
Another advantage to using alt-backspace over ctrl-w is that the former has
the same semantics as alt-b. ctrl-w considers a word to be anything surrounded
by spaces, whereas alt-b and alt-backspace consider a word to be any
consecutive string of word characters.

------
nurb
Another trick is to use "!!" which is the last command launched, especially
useful if you forgot a "sudo" in front of your command, just write

    
    
      sudo !!
    

In the same way, "!*" is all the arguments of your previous command, and "!$"
only the last one.

~~~
jcutrell
Came here to mention the sudo-bang-bang trick, which really has the best name
of all the commands I know.

------
RJIb8RBYxzAMX9u
Regarding history, another simple trick is to increase $HISTSIZE and
$HISTFILESIZE, for the defaults are woefully tiny for 2017. I set mine to a
million. You could have 100 terminals open and they would still consume less
RAM than <insert "native" Electron app(s) of your choice>.

------
wodenokoto
Personally I found "Learn Enough Command Line to Be Dangerous" to be really
helpful to get started with actually using the command line at all.

[https://www.learnenough.com/command-line-
tutorial](https://www.learnenough.com/command-line-tutorial)

------
ivanhoe
It's missing my favourite: CTRL + _ for Undo.

Also there's a big difference between Alt + Backspc and Ctrl + w. The first
will delete a word consisting of only alphanumerics, while Ctrl + w also
deletes the word, but word can be made of any characters other than space.

------
mr_donk
> Now that we know we don't need the up and down arrow keys, what about the
> left and right? Unfortunately, these keys are still needed for single
> character movements

Don't ctrl-f and ctrl-b work?

------
rofrol
I would suggest
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)
over ag

------
ndesaulniers
When going past something with ctrl+r, use backspace rather than ctrl+s. less
has movements similar to vim. In less, hit v to open the file in your editor.

------
annetee
Also:

Alt-l converts next word to lowercase

Alt-u converts next work to uppercase

------
thiagof
A very usefull command is Alt-m. This command repeat the last digited string
in the current line. It only works in ZSH.

------
cel1ne
Tipp for OSX-Terminal:

Option + Cursor-Left/Cursor-Right to jump words

------
rerx
I never knew of `cd -` before -- very useful!

------
philonoist
Kindly help me out on how to learn this tool in Windows10 without using VM?

------
greenspot
tl:dr

    
    
      ctrl-r     search in history, ctrl-r again to skip-
      ctrl-p     previous command (instead of arrow up)
      ctri-n

------
lisivka
I recommend to install mc (Midnigth Commander) and bash-completion (if bash is
your shell of choice) as first terminal tools.

mc allows to explore system efficiently while not standing in my way, because
I can always press ctrl-O and get my shell back.

bash-completion saves time on typing of commands.

Other tools I install often are htop (better ps) and strace.

~~~
mdekkers
all of these are my go-to tools. I also edit inputrc to make pgup and pgdn
history search - something I picked up from SuSE version 15 years ago, and
stuck.

~~~
amirbehzad
would you mind to share and elaborate a bit. tq.

------
krzyk
It would be good to mention that this article is MacOS centric.

~~~
blockloop
I use most of it on both GNU Linux and Mac. I have installed coreutils (GNU
bins) and bash v4.4.5 via homebrew on Mac. It's probably safer to say these
are more specific to Linux.

------
SFJulie
Seriously you can get on fi(r)st page of HN with 5% of man bash?

~~~
xutopia
Consider for a moment that it might be better written and explained than man
bash.

~~~
krick
Which is quite sad, if you think about it.

~~~
JdeBP
If one thinks about it, one realizes that there's a difference between
tutorials/guides and reference doco, and the world is happy to have _both_.

