* git + sql scripts
* simplenote (notes across devices) Semi-automation of pieces of my job captured in these notes.
* zapier if I'm trying to connect two web apis.
+10
I love 'set -o vi' and have been using it for ages, since ksh in fact. It makes editing commands and then re-issuing them so fast in Unix, if you're even just okay at vi - don't even need to know vim. Used to immediately put it into the .kshrc on any new Unix system I started working on (along with some other commonly used productivity settings, of course).
A fact that some might not know about 'set -o vi' is that once it is set (a one-time task per login shell, or put it in your login shell's profile file, then it is one-time, period), and you are now editing a command at the command prompt (using vi features), you can just press v to open up vi with a temp file containing that command, edit it using the full-screen view and power of vi, then save the file and it runs automatically.
This is particularly useful for multi-line shell commands like a for or while loop, or a long command pipeline.
And while in that vi session, if you decide you do not want to run the command right now, you can always save it to a different, persistent file name (with :w filename), and exit the temp file without saving it.
Then the command will not run, but you've saved it in a permanent file, and can do anything with it, now or later.This is useful if you realize in the middle of editing it, that you want to look up some command syntax (to add to the file), or polish the code some, etc., but maybe not right now, because you want to finish your current task first (which the original command sequence was a part of). You can just edit that permanent file at your leisure later, polish and test it, then use it regularly as needed.
Edited for formatting and grammar.
FWIW you can do this with ctrl-x ctrl-e in normal (emacs-like mode) and it will open up your $EDITOR. Example:
> EDITOR=nano # or EDITOR=vi, EDITOR=emacs, etc
> echo [ctrl-x ctrl-e]
* edit command by adding foo and save*
> echo foo$_ in a command gets substituted by the last argument of the last command you typed - happens to be useful surprisingly often. Simple example: copy a file to some other directory, then cd or pushd to that directory:
$ cp some_file /long/path/to/directory
# cd $_
But there are many other cases where I regularly find it useful.
_ also evaluates to result of the last expression in the Python interactive shell, and probably in IPython (command-line version) as well - need to confirm it about IPython.
Edited for formatting of commands above.
cat /really/long/path/to/something/only/readable/by/root
cat: Permission denied (goddamnit)
sudo !!
$ ls /long/path/to/file.ext
$ less !$
bash-3.2$ less /var/log/authd.log.0.gz
"/var/log/authd.log.0.gz" may be a binary file. See it anyway?
bash-3.2$
bash-3.2$ zcat /var/log/authd.log.0.gz | less
<ESC> k cw zcat <ESC> A <SPACE> | <SPACE> less <CR>
There are zillions more such that can be done in Unix, of course, if one puts one's mind to it and experiments, even without spending a lot of time. Another simple one I use some is to define some environment variables to the value of long directory names to which I need to go often as part of some project. Then I can just do:
cd $short_name_for_that_dir
A shell alias can also be used instead.
https://www.reddit.com/r/selfhosted/comments/5dgcn9/zapier_s...