Programs that have saved me 100+ hours
sadacaraveo.com
sadacaraveo.com
Create scripts to automate all kinds of things, usually triggered by keyboard / mouse conditions.
Here are a few - these are small things, but they can incrementally save hours and hours
- CTRL+@ - pastes my email address at the cursor
- ALT+MouseWheel - Page up / Page down
- ]d - send the current date and time to the cursor
- CAPSLOCK - sets transparency of window to 75 as long as caps is held down
- #t - open http://e.ggtimer.com
It's also set up as a universal spell-correct and intellisense for SQL/ JS / PHP etc independent of IDE
---
ShellJump
https://github.com/kjerk/shelljump
Set up jump locations and shortcuts so that you can quickly move between project folders in powershell
---
Renamer
http://www.oldware.org/software.php?swid=74
The original authors site isn't available anymore, not sure why because this was a super useful utility. Its like Ant Renamer or File Renamer or any of those, but I just prefer this one's simplicity
---
Mp3Tag
Bulk edit Id3 tags on mp3 files (if anyone has mp3s anymore)
---
NimbleText
Simple tool to repeatedly format text. Like foreach for plain text
https://github.com/ahkscript/awesome-AutoHotkey
A curated list of awesome AutoHotkey libraries, library distributions, scripts, tools and resources.
It's easily saved me 100+ hours -- a half-second at a time, 400 times a day. And probably a couple cases of RSI, a couple inches of finger contortion at a time.
The economy of motion is as far beyond keyboard shortcuts as keyboard shortcuts are beyond hunting around with a mouse. It's crime more people don't use it.
It's also really practical for programs that don't even support custom keybinds or when running multiple instances at the same time like multiple firefox profiles. No need to set the new shortcuts in every profile, they just always work on every running firefox instance.
It also has nice features for window snapping and resizing, I have two of my side mouse buttons mapped to window move and window resize respectively, whenever I hold one of them down the window under the mouse pointer will just move/resize accordingly until I release the mouse button, including snapping to edges and all that nice stuff.
BTT is one of apps I miss most whenever I use windows, makes customizing the user experience so much easier.
https://i.imgur.com/qvAOmHA.png
----
I think I can say with a fair amount of confidence that 3 Finger Tap (open in new tab), Pinch In/Out (close/open tab), and Rotate Left/Right (change tab) are my most used custom gestures.
With 3 Finger Swipe Left/Right (back/forward) configurable in vanilla system preferences, but done in BTT for consistency, and 4 Finger Swipe Up (Show Desktop)/Down (Mission Control) with their directions reversed from the system defaults [1].
Really, every one of the gestures on there is pretty indispensable to me feeling comfortable using a computer. Going back to keyboard shortcuts for the same actions (eg, when I'm using someone else's computer) feels like hunting-and-clicking menu items with a mouse.
----
[0] Import/Export is a thing, but I usually use a reinstall as an opportunity to tighten things up.
[1] Because this way makes way more intuitive sense to me. Swipe Up = Swipe Away = "GTFO windows". What hell, Apple HCI engineers?
Rebinding the f1-f4 keys to tab navigation (previous, next, close tab, new tab) works well. Rebinding extra mouse buttons to get gestures back on non apple mice (tilting scroll wheel to smart zoom). Other setups would be neat to hear about.
I miss the days when applications came with proper applescript dictionaries. Nowadays I have to pull shit like
tell application "System Events"
tell process "Firefox"
get menu item "Quit" of menu "File" of menu bar 1
click
end tell
end tellI have a bit of OCD when it comes to micromanaging my music library, and the bulk editing and automation features in Mp3Tag is the the only reason why I ever have time left to do anything else.
Or if you just use a window manager, like i3wm for example, you can define all sorts of hotkeys, which you can also bind to custom shell scripts, or anything you like, in your i3 config.
Edit: I used this a while ago, when I was using bspwm as my window manager: https://github.com/baskerville/sxhkd
Outside of the tech world, people seem to think that grabbing some columns out of a file and rearranging them or pasting them somewhere else is some kind of sorcery.
IME: I had much more time available to spend learning tools like that. Now that I work, have a family, etc, I don't have as much time to spend.
Agreed. I'd just add that there are many more tools along the same lines (just have to look in the various bin directories, and not to forget custom ones that people write in C / shell / other languages and combinations of the same), and that it is how they work together - because of a few powerful key concepts like pipes, I/O redirection, file wildcards, the various metacharacters starting with $ and others - that really makes the system powerful, more than any individual tool, though those play a part too.
1) some guru out there has probably done a blog post on how to automate things with all of these.
2) I wanted to write something that could help anyone, not only people who are well versed in tech.
But I agree, most of the renaming/sorting/parsing in general, can be done with unix commands.
… in 1982, before the word "blog" even existed - and the advice/instructions still work just fine on any modern vaguely posix/unix-like command shell, including Mac and Windows which also didn't exist when the piece was written.
(Gopher search in "Unix - Utilities - Tutorials - sed and awk - brian kernighan" or dial in to your WELL bbs number and ask for a copy of "sed-awk-tutorial.txt" in the Software conference...)
You run vimv and you get your pwd, in the editor, and you can edit it like a text file. Then just quit and save and all of your filename changes get committed to that directory.
It's an extremely fast way to do a bunch of random and irregular edits to a big directory full of files.
Wow, this is really cool! Wish I had known about this sooner!
$ brew install moreutils
$ brew install imagemagick
Fantastic stuff although I can never remember the commandline options.
The dev lead at an agency I worked at used to tell me using such old tools was going to hold me back. I've found the opposite to be the case.
I'm by no means an expert but the even my basic skills allow me to do things that they couldn't with fewer key strokes.
They also didn't complain when I created some bash scripts to automate pushing development databases around.
Fun!!
Make is a utility that's seemed super useful to put into use for non-programming tasks. In my case: take a LaTeX file, create a PDF from it, run tex2html on it and ftp the results up to some web server, run pandoc on it to create a dated epub, etc. But my initial forays into learning make were frustrating and I gave up. Is anyone using make to automate workflow processes, or is that wishful thinking?
This is done at the cost of great obfuscation of the build process.
If you can suffer the cost of a full rebuild each time you change something, it is far clearer to have a linear script which executes certain steps one by one.
Such a script can be sped up for incremental builds with some judicious checks like "run this command which makes A out of B, only if A doesn't exist or is older than B".
(P.S. I don't want to overlook make's ability to parallelize builds on multiple cores. That can just be scripted too, with utilities like GNU Parallel.)
I'm yet to see a tool that doesn't become just as obfuscated for complex builds though, you're script for instance (bash? python?), is probably just as illegible to someone new to it.
If a program is made of libraries, such that when we change a single source file, the entire library which contains the .o has to be re-archived, and then the entire program made up of all those libraries has to be re-linked, that is still an "incremental build".
You might possibly be mixing up "incremental link" (optimized way to just update a function or object file in a previously linked program image) with "incremental build" (compiling only parts of a program in response to a small change).
Honestly, I'll never go into some .sh file to see what happens there, but often open Makefiles to find and tune details of anything. It... adds something manageable(?), I can't find a word for it.
Of course I use makefiles for tasks not connected to building projects. Not "a lot", but if I need reproducible actions in workdir, then it is Makefile.
Edit: if/for flavor
So it's not just one known file. Big trees can have lots of little makefiles.
> I'll never go into some .sh file to see what happens there, but often open Makefiles to find and tune details of anything.
Thanks for sharing. My own personal preference is such that I will never go into a Visual Basic file, but I will go into a Lisp.
You do know that the recipes in Makefiles are shell scripts? (With a subtle difference: each line implicitly executes in its own subshell, so setting variables or doing "cd" doesn't propagate). In a Makefile you still have to read shell code. It's mixed with make code, and with additional quoting rules and where true multi-line shell scripts that run in a single shell have to be written with backslash escapes; ugh.
(Note by the way that I didn't say anything about specifically using shell scripts for builds; I deliberately used the word "script" without qualification.)
> Not "a lot", but if I need reproducible actions in workdir, then it is Makefile.
If you want irreproducible parallel build problems, that's when you want make.
Sometimes Makefiles depend on execution orders which are not actually encoded as dependencies and these non-asserted orders turn into race conditions in a parallel build. You get a situation where in one out of twenty builds, that "y.tab.h" file out of yacc didn't get generated yet, while the lexical analyzer that wants to #include-s it is already being built. In single threaded mode, it just so happens that the rule which makes "y.tab.h" always runs first.
I once created an embedded Linux distro from scratch (build and packaging system and all). Over the base of supported packages we were pulling in, I saw quite a number of build issues of this type when the distro build would randomly fail to build a package due to race conditions like this.
GNU Make doesn't have any diagnostic ability that I know of to help you uncover where rules have unexpressed dependencies (a recipe refers to an input file which is the output of another rule, and that input file is not named as a prerequisite).
All of those increments make particular tasks easier. Makefiles eliminate the need to write 'if this doesn't exist or it exists but is older than its dependencies' over and over again. The built in targets also make building C programs quite trivial.
Makefiles can get nasty, but for simple chains of "if this file has been modified take this action" they're a great tool. The syntax isn't even that hard for those types of actions.
target: dependency ...
actionWithout macros, this traditionally involves a lot of copy-paste-change-stuff repetition.
With a Vim macro, I can happily just do this once, assign it to a register, and repeat as needed, and even store it for later reuse if I want.
There are also, littler things, like jumping between HTML tags, or bulk-indents.
What makes Vim's macros better (in my opinion) that other editor's macros is that fact that they're simply stored in copy-paste registers, meaning that you can have many of them, store in a different file, copy them off the internet, or compose them together.
For example, I may be testing a function and wanting to test a few scenarios on many IDs. So I will create a csv list of numbers and then use a macro to format it
your csv string will be like this (normally much longer)
134,234,367,4345
Then record the macro:
- type "myFunction("
- type ctrl + right arrow (this moves the cursor to after the comma)
- type backspace
- type ");"
- type enter key
then run stop recording and run the macro. It will produce:
myFunction(134);
myFunction(234);
myFunction(367);
myFunction(4345);
Which doesn't seem like a big time saver over regular copy and pasting. And you could have iterated over the csv string with a for loop. This is probably a really contrived and basic example but you find yourself thinking about using a macro anytime you have to do the same keystrokes over and over.
Compared to regex search and replace this is much more malleable, interactive, and ultimately powerful.
Although, there are still several situations where macros are better, especially things that involve several motions and edits. (I tend to use qw because w is more convenient to hit after @).
Also, it's occasionally useful to remember that you can use the double quote character " to paste a macro, edit it and then update it. i.e. ( "ep .... edit ... ^"ed$ )
The most fun vim macro I've made solved a "solve this puzzle before we want to interview you" question. The problem was a URL to request that gave you a response to parse into the next URL, chained about 100 times. The vim macro took the URL in the current line, shelled out to make a network request for the result of `curl` with that line as an argument, and edited the result into the next URL to fetch.
For instance, I've recently tried the ones in Atom and VSCode and they were both incompatible with my normal workflow. In one of them you couldn't save files with :q, for instance.
They're works in progress, likely--and I'm still grateful to the teams who work on them. They just weren't enough for me.
I view Vim as half-editor, half-editing philosophy. The editor is just an app that I like, but I feel that embracing the philosophy does make me more productive and able to accomplish a lot.
You may be, though ultimately it depends to some extent on personal preference.
If you want to check it out, try this vi quickstart tutorial by me:
https://gumroad.com/l/vi_quick
I initially wrote it for a couple of Windows sysadmin friends at their request. They had been given a few Unix machines to manage. They said it helped them quickly get up to speed with the basics of vi. I later published it as an article in Linux For You, a print computer magazine (now Open Source For You).
intelligent refactoring: is extremely unlikely to happen soon
customizble search directories: is way more flexible in a terminal than anything i've ever seen an IDE guru do. it's not vim though. it's vim + shell.
integrated terminal: you're already in the terminal, using tmux doubles down on the benefit
vim has way more flexible buffer pane layouts + tabs + sessions (IDE's also have sessions, but vim can do multiple sessions for a project). i've never seen an IDE with anything like the jump stack, marks, multiple yank registers, the flexibility of macros, or anything like `:r !$COMMAND` or for that matter `:w !$COMMAND`. basically no IDE has anything which matches vim's `NormalMode`. type aware code completion and syntax checking is available depending on the language.
these things aren't free though. you have to invest before they pay out.
Why is that? I'm a long term vim user, and I prefer multiple cursors to 's///gc' for many operations. Unfortunately the multiple-cursors implementation (via plugins) is not flawless, but it's quite handy for standard usage.
But if you don't do that sort of thing, there are plenty of other tools that you can use. Most are probably far easier than learn vi.
But I like using command line tools where possible. Most are available everywhere and they are incredibly powerful once you learn parts of them.
I find Vim plugins in most editors are quite good, a true vimer probably doesn't like them as much because they are a blend (but then, they may as well just use Vim itsefl), and for jetbrains stuff, it blends the awesome of vim with the awesome of jetbrains code manipulations.
Chocolatey
Apt get for Windows, although I would argue its actually better because there's just one central repo, so you don't have to add some long repo before you can install Telegram
----
Postman
The fastest way to test APIs - create GET and POST requests easily and view the results any way you like.
Most of the tools I've mentioned in this and my other comment are listed on Scott Hansleman's "Ultimate Developer and Power Users Tool List for Windows" - (https://www.hanselman.com/blog/ScottHanselmans2014UltimateDe...) which is probably the most definitive list out there for this kind of stuff (for windows). It's not been updated since 2014, so there are a few newer alternatives - in particular Foxit reader is kind of a mess these days, there are far better alternatives.
Be sure to check out the comments for lots of extra tools in the format "I can't believe you didn't mention {x}, I can't live without it"
In what way is Foxit reader a mess, and what are those alternatives?
My main PC has 8Tb of storage in 4 HDDs, with "Everything" I can find any file immediately.
Too bad Windows is the platform people love to mock. I hadn't been able to find a tool as efficient as Everything for Linux or OS X.
Resharper (is that a tool?). No need to explain I guess. You use Visual studio, you get resharper. Can't live without it anymore.
The ability to write bash/powershell/your favorite script language. Everything I do more than twice turns into a script and is added as user action in my xplorer2 under a shortcut.
ShareX gif capture. My company has email attachment max sizes too small to send proper mp4 longer than 1 min. The gif capture has lower quality (sometimes Horrible) but is good enough for sharing bugs which require investigation before they can be submitted. Instead of having to type I capture the gif and send to our test engineers to turn into proper PR/ticket. Saves time writing it all out and makes me actually share random issues found during doing other stuff.
P.s. Try irvanfiew on Windows beats the bulk resize thing in OP.
I suspect in terms of lost time I didn't have to spend debugging and other stuff it's probably 3-4 times that minimum.
But by far the most time saving feature I have is the type searching functionality in it! For example, one can type 'ack --java System.out' and it will search ONLY the java files! No more 'find . -name *.java -exec grep -Hni System.out {} \;'. And you can add custom types easily through your .ackrc, it is a very well put together piece of software.
(PS: If you're trying it, definitely try out 'ack --bar')
https://github.com/monochromegane/the_platinum_searcher
Since it's pure Go, there's your static binary which makes it easily deployable again.
While ack is great, I just want to point at you could easily do 'grep -rHni System.out --include \*.java'. Granted it's still more words, but the '--include' directive (which you can specify multiple of) is really great for quickly modifying a grep search to restrict to certain filetypes. No need for find/exec :)
When installed, you can use the app or call it as a service.
Not sure if it's as full-featured as Bulk Rename Utility, but it's close. [regex replace is hidden under Advanced & Special, which will tell you a bit about their target market.]
* Available for OS X 10.[12]-11, and macOS 10.12
* 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.
$_ 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 !!
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.
$ 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>
https://www.reddit.com/r/selfhosted/comments/5dgcn9/zapier_s...
+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 fooAnother one is, of course, Emacs. By far the most useful and brilliant tool in my toolbox.
When I see such productive articles coming I can't keep but smiling and thinking ( but you could to this or that easily using wdired or macros or...)
s/Ruby/Perl/
(One of the guys I work with does this with Java - which always seems an odd choice to me. The best sysadmin I've ever worked with did everything in bash, which feels odd to me for opposite reasons (ever seen anyone doing SQL database connections in shell???). But the underlying message holds: "learn and use a programming language, it pretty much doesn't matter which one, whatever you're most comfortable with - and then use it when the simple tools don't work for you...")
Java does seem an odd choice. I don't disrespect Java, but for very quickly loading in data, making changes, etc, it's going to be far from a few lines I suspect..
(At work, I use Perl quite a lot, though. I recently have started trying to use Go for problems I normally use Perl for. But the jury is still out on how well that works.)
Of course, the tradeoff is that you can't easily script this way. If the software gives you complicated pipelines and allows you to save them, though, sometimes you don't need to. I'd love to see more GUIs that, instead of (or in addition to) doing processing internally with calls to the low-level library, allowed you to copy out a command line version of the command which you could further customize for scripting. But it's rare to see that kind of feature.
http://www.adobe.com/devnet/photoshop/scripting.html
And at least last time I used it you could record an action and convert to script.
And while I have no idea how the information is calculated, the About dialog says the software has saved me 6 months (~4,000 hours). It may well be more than that since I've used KM for about 10 years now and that information is a recent addition.
"The only limit to Keyboard Maestro is your ability to tolerate the disastrous user interface"
$ cat ~/.inputrc
"\e\C-k": shell-kill-word
"\e\C-a": "awk 'BEGIN{OFS=FS=\"\\t\"; } { }'\C-b\C-b\C-b"
"\e\C-w": "\C-w\C-y > /tmp/temporary-inputrc && mv -f /tmp/temporary-inputrc \C-y"
"\e\C-f": "find . -type f -print0|while read -rd '' f; do ; done\e-b\C-b\C-b\C-b\C-b\C-b\C-b"
"\e\C-i": "\C-awhile true; do ( \C-e ); inotifywait -q -e modify -e close_write *; done\e51\C-b"
"\e[A": history-search-backward
"\e[B": history-search-forward
"\ep": history-search-backward
"\en": history-search-forward*
while true; do ( make -j && grep foo|sed 's,b,x,g'|./run ); inotifywait -q -e modify -e close_write ; done
meaning whenever I save a file in that directory, the command runs again.
IntelliJ for everything. Extract methods and interfaces auto-modifying to support close duplicates. Signature changes. That sort of thing.
Rsync. Zsync allowed me to even get Linux back in the day (thank you Ubuntu).
Another text editor worth mentioning is EMEDITOR that has tons of macros and handles larger files much better than Sublime
> What are your 100 hour time savers?
function ff() { find ${2:-.} -name "*$1*" ; }
function gg() { grep -n $* ; }
function ggr() { grep -rn --exclude-dir=.git $1 ${2:-.} ; }
function ggi() { grep -in $* ; }
function ggri() { grep -rin --exclude-dir=.git $* ${2:-.} ; }
# display a man page as pdf window
function pman() {
local pdf="/tmp/pman-$RANDOM.pdf" \
(man -t $* | ps2pdf - >$pdf && mupdf -r 96 $pdf 2>/dev/null )&
}m, a Unix shell utility to save cleaned-up man pages as text:
https://jugad2.blogspot.in/2017/03/m-unix-shell-utility-to-s...
https://www.scootersoftware.com/
Especially with integrated source control and remote sessions to manage source on multiple server types and platforms. Very customizable rules for compares and folder structure / filename case etc.
I used to use Araxis Merge, but Beyond Compare, with a tiny bit of customization, is in my opinion a far superior tool.
I tested multiple other options like Custom Style Script [2] and others but while being ok during initial tests, for some reason nothing worked on my typo3, js based backend website.
[1] https://addons.mozilla.org/en-US/firefox/addon/imacros-for-f... [2] https://addons.mozilla.org/nn-NO/firefox/addon/custom-style-...
Interestingly, IIRC, Gina Trapani, who I think was/is an editor or writer there, had herself written a utility for to-do lists called todo.txt or some such name. It was supposed to be lightweight and only need and use text files, so could be used almost anywhere.
This is THE best screenshot tool on Windows, I've installed it on every machine I use. It also has an editor where you add text, highlight, circle things, etc.
# Store screenshots in ~/temp/screenshots
mkdir -p ~/temp/screenshots
defaults write com.apple.screencapture location ~/temp/screenshots* mouse moves
* keyboard input
* raising lowering windows
* one keypress -> multiple effects
create an edit -> launch -> debug tight loop ? no problem
dismiss annoying Lotus Notes dialog warning box -> no problem
enter 5000 multi tabbed entries from a CSV into a custom gui -> no problem !!
(Obv. ignoring more command line oriented tools.)
Saved me 100+ hours _this week_ :-). Thanks, Tony Finch &co!
For benefit of others - this approach would work with the 'set -o vi' option too (discussed by me and others elsewhere in this thread) - just that you would have to type a / (slash) to search instead of C-r (Ctrl-r), because the mode is vi, not emacs. And since you start (obviously) at the bottom of the history (i.e. latest command first), the usual sense of the vi / command (which means search forward or down in the edited file) is reversed here to mean search backward in the history of commands. And ? is the opposite of / . N and n work, too, to repeat the previous search command in the opposite / same direction.
I know I could basically write scripts and start them with SystemD timers/cron but.. not sure it'd be worth the effort doing it all myself.
- Perl regexp's
- Worksheets for thing you'd want to remember
- Process Duplicates Lines / Process Lines Containing
- Nice set of Markup tools
- Diff
- Support all kinds of versioning systems
Araxis Merge (x-platform) for text, image, folder diffs.
also for renaming i find built in TCMD multi rename tool quite powerful
At first I thought this was an elaborate meta joke since not reading articles would save me thousands of hours, but I think it is a bug. I am using the latest google chrome with a very restrictive uMatrix that blocks pretty much all cross-site requests that are not images, and Ad-Block.