But it was posted 3 years ago, and perhaps some useful stuff has emerged in the interim, hence my starting this thread.
It's one of those rare tools that interacts with my stream of consciousness which is one step away from mind reading.
I know this is OT but one of the reasons I've switched is history search that actually works.
kd foo $PWD # stores as foo
kd f # jumps to foo
kd # in a Ruby project subdir, jumps up to where the Gemfile is
kd f # => jumps to foo
echo $(kd f) # => outputs foo's path
# some creative, if nonsensical, examples:
cp some/file $(kd foo)/app/controllers/whatevs
cp $(kd bar)/Gemfile $(kd foo)/Gemfile
kd foo && cd app/controllers && cp $(kd)/config/whatever .
Since I also love ranger as a file manager, I wrote my own integration of both: https://github.com/fdw/ranger-autojump . It remembers where I went in ranger, and I can also call autojump in ranger.
> autojump is a faster way to navigate your filesystem. It works by maintaining a database of the directories you use the most from the command line.
1. Scan an eternal history file for `cd` with absolute path except for /tmp/*
2. Sort and filter out duplicates
3. Call fzf and let user pick the desired result
4. Upon selection don't enter the directory but instead type `cd <selection>` into the prompt so that the user can navigate further using <Tab>.
What's nice about this approach is that it automatically builds your bookmarks, but only from `cd` commands where you deliberately used an absolute path.
Here's the code. It has some prerequisites (fzf[0] and ~/.eternal_bash_history[1]) and probably only works with my terminal (Xfce Terminal); it took a bit of tinkering to get it to work.
# ~/bashrc.d/aliases.sh
__b() { # bookmarks; props to fzf for providing examples of READLINE configuration
local selected="cd "$(cat ~/.bash_eternal_history | grep '^cd /' | egrep -v '\.\.|/tmp' | awk '{print $2}' | sort | uniq | fzf --exact)
READLINE_LINE="${READLINE_LINE:0:$READLINE_POINT}$selected${READLINE_LINE:$READLINE_POINT}"
READLINE_POINT=$(( READLINE_POINT + ${#selected} ))
}
bind -m vi-insert -x '"\eb": "__b"' 2>/dev/null
The amount of work Microsoft is putting in this editor is amazing. Last month we got file history, that was the last thing I needed to ditch the Git GUI I had installed.
(I’m on the team)
I also prefer vim's macros to multicursors, but I think it ammounts to nothing more than habit and preference.
Macros in Vim are going to be much more powerful, with movement commands and selection commands giving yo a more flexible system... I think? Hard to be objective after so many years of Vim.
Not OP, but to take a recent example (although it was in Emacs, I'm pretty sure it would work in any advanced editor), I had a macro select the second half of the open file and pipe it through sort and uniq to replace it with each unique line and their number of occurences. That's not doable with multi-cursors; their use cases intersect but don't overlap with macros ones.
My (admittedly naive) mental model of recursion is basically a loop where you bring your entire stack frame with you (or less, in the case of tail recursion).
My typical pattern is something like: define it, try it, adjust it, then apply variable times (including “infinite until error”), maybe save 1% of them. That often takes less time to do than it just took me to describe.
I use macros probably 25x for every one time I reach for multi-cursors, though to be fair, if I came the other way, I’d probably use multi-cursor more often than currently. (I used macros for 30 years before getting multi-cursors, so if both can do the job, I’ll use a macro.)
In my experience with multicursor, I don't need to be able to "inspect" the operation as the act of typing it is inspection in and of itself. Sure they aren't saveable and thus aren't editable (but you admit this is a very rare use case - I can't recall needing that, ofc you often don't know when to want what you don't have).
As for applying across a number of files, I recently added an in-editor rendering of workspace search results to VS Code, and I've created an extension that can apply edits to those search results back to the original files. This allows for performing multicursor edits across many files.
As for using variable numbers of times, this is again quite trivial with multicursor. I simply select all the instances I need (either all in one go or iteratively), and go from there. I admit there is an art to selecting the right text such that iterative selection works with a single keypress, but once you get the hang of it it becomes pretty natural. (Unless you mean "apply this N times", which again I'm not sure I've ever been in want of)
If the use case is “every day, download this file from a server and process it using pre-defined text editing commands”, multi-cursor doesn’t help you in any way that I can see.
I admit there’s a huge overlap in use, but when someone asks for macros and a product person says “how about multi-cursor instead?” I think it’s fair to raise the cases where someone asking for macros might actually want macros.
Lately, I'd add the remote ssh and wsl extensions have been insanely useful, but starting code from inside wsl has gotten sluggish since the last vs code update.
AWT/Swing based IntelliJ manages to be much, much faster in comparison.
I switched form VSCode to PHPStorm half a year ago, and while it feels a bit slower, the improvements are so unbelievable worth it for me. It does have a taste for memory, but then again, it easily saves me a lot of time each month, so just throwing RAM at it was a no-brainer for me.
I was relieved when I switched back to PyCharm.
Vscode is nice but still quite far away from some good IDEs.
I also have to do a lot of context switching (e.g. to review someone else's code), and being able to have a separate set of tabs (even within the same repo) is super-useful for this.
At previous jobs with less separated out code, I have taken this approach (although with Sublime Text rather than VSCode).
Even in the mono-repos I work with, I'll generally open an editor per inner repo. Mostly ./feature/featurename/filename is as far as I have to open. Some of the C# projects are deeper though.
As to the RAM, it's using around 1.2gb between vs code and the connecting server (WSL2), multiple isntances vary... but with the number of containers and VMs I'm running, I'm generally well over 16gb of use, and I have 64gb on my desktop. So even without VS Code, I have trouble on a 16gb system.
I usually run 3-5 instances for different projects and it'll hover around 3gb RAM, but it appears that they share a lot of memory, closing one or opening an additional project has no visible impact.
I use it daily for .net coding, while i use VS code for everything else.
Also shout out to LINQPad, for letting me test quick snippets of C# with better visualization than Visual Studio. It's also a better alternative to Sql Server Management Studio for running SQL.
I'm sure this saved me an additional hundred hours.
I mostly program in languages like Ruby & Perl using Vim. Even with my decked out version that has 35 plugins, and some other bells and whistles, I'm on average using 20 MB of RAM. Open/Close is near instantaneous.
Now that Windows search often fails to turn up even my most used files (what happened to Windows search? Was it intentionally nerfed?), Everything has become a necessity for me.
I don't use Windows much nowadays, but ripgrep and fzf are sure handy on linux and mac.
I found it amusing that they also offer what is apparently the same product with completely different branding "for corporate environments" called FileLocator Lite/Pro.
Even on a machine with several million files on it, it searches as fast as I can type.
Everything also has an API that I've used to integrate the search into my own apps:
Also, to second your question: what the hell did happen to Windows search? I always just assumed I'd done something to break it (and honestly, could never be bothered trying to "fix" it... even after all these years), but apparently it's inherently broken.
I know very little about OS software. Could someone explain at a high-level how something as fundamental as file search can be rendered totally unusable? Doesn't windows have the best engineers in the world working on it?
Windows has great engineers, yes, but the problem with Windows search is not an engineering problem, it's a trade-off between different use cases and performance and compatibility and innumerable other factors. Design by committee and circumstances of history made Windows search what it is, the shortcomings aren't caused by a lack of engineers capable of building Everything or Spotlight or grep or Google or whatever your ideal file search tool looks like.
https://docs.microsoft.com/en-us/windows/win32/search/-searc...
https://github.com/junegunn/fzf "A command-line fuzzy finder"
I got Everything in a hotkey so it also doubles as an application launcher. It really is quite elegant.
Is Alfred good in this sense?
The issue with the spotlight engine that everyone uses is that it excludes "hidden" directories and in particular every dot file and dot directory.
[0] https://antibody-software.com/web/software/software/wizfile-...
[0] https://locate32.cogit.net/ [1] https://sourceforge.net/projects/locate32/
I am not joking. I found out about it when it stopped working due to bing outrage and had to do registry fix to make it work again.
2) Anything that lets you resize/place windows with hotkeys. For example, Divvy for OSX. Divvy is also nice because if you press the hotkey multiple times, it cycles the application through each of your monitors. No need to ever use your mouse to move/resize a window ever again.
3) Fuzzy file search in your editor. You know you want to open src/components/user.js so you type "cu<enter>" and it appears.
Any tools like this that become so ingrained in your muscle memory that you just kind of think things ("move this window and then summon my terminal") and the computer responds.
Years ago I saw someone using this (I think it was actually Yakuake) and ran it for a bit. I really didn't like that it was a single session. However, I later messed around with tiling window managers (which relates to your #2!) and having a shortcut to pop up a new terminal is really what I wanted this whole time.
Just to touch on #3, any time I'm writing a gui that's expected to have more than a handful of items I push to add a search bar with fuzzy matching at the top. Otherwise, search would get added after it's used for like a decade and everyone is immediately enthusiastic and grateful. All of the non-fuzzy solutions are too pedantic to use.
CMD+Tab is enough of a global hotkey for my needs, and it's usually only one or two tabs anyway.
Browser history too.
(This might be true of free/shared/common tools that haven't been configured yet)
But getting past all that, after a lot of craftsmanship and idea sharing, that's when tools start to ramp up in productivity.
I use emacs, because if something doesn't work like you want to, you can coerce it to do so. That said I personally wish it was python-based, because I'm more fluent in python than lisp.
While using i3, you can also place a terminal in the scratchpad, which works more similarly to Yakuake.
When I was working more seriously on things with project directories I had a couple aliases set up with a simple bookmark system. The "bookmarks" would be symlinks in a dot folder. I could type `g proj` or `g lib` to hop around.
I like this method a little more because it's not a single session, there's no animation, etc. It just pops into existence exactly how/where I left it, and then goes away again when I'm done with it.
I’ve been using “fzf” [1] for file and directory search and I can’t recommend it enough.
It integrates nicely with vim [2] as well.
Aquasnap is an OKish windows equivalent. The best i've found, at least.
You don't need a separate terminal just for that. It's better to automate your window manager to open the terminal. I use this with tmux and i3:
#!/usr/bin/env bash
tmux new-window -t 0 -c "$1"
i3-msg 'workspace 1' # switch to i3 workspace where my terminal is placed
I rarely want to open a new window, I want a terminal that I never close, that stays in the background until I call it forward. And it has to be available on any workspace ("space" on macOS). Iterm does all of that perfectly
Thanks! I didn't know I need this until I tried it!
A lot of good editors have the issue that they are quite rigid when it comes to operating between multiple languages. So while your editor may shine at JavaScript, it won't understand vuejs templates or when you put Javascript code inside a php file.
This is where PhpStorm really shines. It can even complete your SQL statements inside php strings or go to a .vue file from a Html tag. I've never seen this type of understanding from an editor ever.
P.S. My only issue with it is that writing plugins for it is kinda hard. Since it is so extendable it's only expected that programmers would want to extend it with their own plugins. And while I have been able to write one plugin for it I found the documentation and tutorial for writing plugins all over the place and sometimes very outdated. It is my request if anyone from jetbrains read it to please make plugin docs more accessible and easier to understand, esp the testing quickly part.
I still could not configure the correct build step for XML-based javax forms as part of Gravel build process. And that’s supposed to be one of the easiest parts?
I mean, your problem kind of sounds like it should be explained in the javax or Gravel manuals, but not in the JetBrains IDE manual.
Except when you actually do both you realise there’s no way of compiling this plugin through gradle unless you first run the build step through the IDE (which secretly puts all of the compiled forms in the same build directory).
It’s a mess.
I use PHPStorm and DataGrip on a daily professional basis. I use PyCharm (CE) and CLion for side projects.
> P.S. My only issue with it is that writing plugins for it is kinda hard. Since it is so extendable it's only expected that programmers would want to extend it with their own plugins
Out of curiosity, what kind of plugins do you (want to) write?
I wanted to write a plugin to enhance Vuejs (auto import mixins, etc). The current vue plugin is good lacks a few features which I wanted to fix but I couldn't figure it out.
There are tutorials done by the Jetbrains ceo himself but I think they are outdated now. It was supposed to be a fun weekend project but due to the disorganised nature of the plugin docs I really couldn't make any progress, especially because i found testing my plugin really hard.
- Yabai on mac for not having to think about moving windows around.
- Pomodoro (now through org-mode) for helping focus (and saving hours, in a round-about-way.)
- Removing as much advertising from my life as possible. (Ublock origin, deleting social networks when possible)
```
$ brew tap d12frosted/emacs-plus
$ brew install emacs-plus [options]
```
open -A [path to applications/emacs startup] $@
Additionally in my .bashrc I have:
EMACS="/Applications/Emacs.app/Contents/MacOS/Emacs"
EMACSPOS="-g 140x66+655+23 --fullheight"
e() { ( $EMACS $EMACSPOS "$@" & ) }
For this case, I create a plist file ~/.MacOSX/environment.plist and can add stuff to it like this:
add_plist PATH "$PATH"
add_plist () {
/usr/libexec/PlistBuddy -c 'Delete :'"$1" ~/.MacOSX/environment.plist >/dev/null
/usr/libexec/PlistBuddy -c 'Add :'"$1"' string "'"$2"'"' ~/.MacOSX/environment.plist >/dev/null
}/Applications/Emacs.app/Contents/MacOS/Emacs “$@“
The script goes into /usr/local/bin or wherever that’s in your path.
You only need to disable SIP if you want features that require it like window opacity/stickyness/...
I am using Amethyst [1] right now as a "tile" window manager which is easy to set up and works as intended.
It's the first thing I landed on after switching to primarily OSX at work (I used i3 when I had a Linux dev box) so I'm not sure if it's the best among the alternatives; but I've been pretty happy with it.
There are three new fields in your profile, noprocrast, maxvisit, and minaway. (You can edit your profile by clicking on your username.) Noprocrast is turned off by default. If you turn it on by setting it to "yes," you'll only be allowed to visit the site for maxvisit minutes at a time, with gaps of minaway minutes in between. The defaults are 20 and 180, which would let you view the site for 20 minutes at a time, and then not allow you back in for 3 hours. You can override noprocrast if you want, in which case your visit clock starts over at zero.
WizTree (https://antibody-software.com/web/software/software/wiztree-...) is a freeware Windows utility (man, typing this took me back to 1997) that lets you quickly see which files are hogging your disk space. Think "df GUI for Windows". Especially useful to track down large application files hidden in the depths of system folders.
WinDirStat [1] (Windows) for the second. It is also available in the super-useful PortableApps format [2], which is always nice.
- Deliveries: macOS / iOS package tracking https://itunes.apple.com/us/app/deliveries-a-package-tracker...
- Screenotate: OCR all of your screenshots with metadata like program/webpage https://screenotate.com
- The Tagger: lightweight macOS utility to tag music / fetch metadata from discogs https://deadbeatsw.com/thetagger/
- youtube-dl: Download any video / song online https://github.com/ytdl-org/youtube-dl/
It was fun thinking of these, I actually put together a blog post a while back listing my favorite software. Would love to revisit it soon: https://lukemil.es/blog/software-i-like
Quoting the bug section of the Readme[1]
> Note that Ubuntu packages do not seem to get updated anymore. Since we are not affiliated with Ubuntu, there is little we can do. Feel free to report bugs to the Ubuntu packaging people - all they have to do is update the package to a somewhat recent version. See above for a way to update.
[1]: https://github.com/ytdl-org/youtube-dl/blob/master/README.md...
choco install youtube-dlFull list: https://ytdl-org.github.io/youtube-dl/supportedsites.html
Keycloak [https://www.keycloak.org] OpenID Auth Server
nREPL + Cider [https://github.com/clojure-emacs/cider] Clojure's Network Repl and Emacs integration for live coding Clojure
Company Mode [https://company-mode.github.io] Emacs autocomplete mode
> git config --global help.autocorrect 1
Based on bash history data, I've also added a simple alias to my bash config:
> alias gti="git"
[1]: https://git-scm.com/book/en/v2/Customizing-Git-Git-Configura...
> alias g="git"
With zsh: "history 1 | awk '{print $2}' | sort | uniq -c | sort -n"
With bash I think this should be "history" instead of "history 1".
I change this:
HISTSIZE=1000
HISTFILESIZE=2000
HISTSIZE=1000000
HISTFILESIZE=2000000
You can usuall answer questions with ^r instead of the man page. Or maybe:
"history | grep -C 10 <foo>"Genuinely interested, why?
I'm a huge fan of the CLI in general, but for some things it just slows me down, git usage is one of those.
Random example: reverting a commit is 2-3 clicks, or a whole lot of typing.
git log
git revert {hash}
Where the GUI falls down for me is more complicated things, like hard resetting a branch to origin or resolving merge conflicts.
Also, most of the git guis do things that I find distressing. For example, in one git GUI I tried a while back, I accidentally dragged a commit onto a branch listed in the sidebar. Only later did I realize the gui cherry-picked the commit into the branch without asking me for confirmation. It would do similar things if I dragged one branch into another.
They usually don't support the level of granularity I have on the CLI. For example, if I want to fix a commit on a PR based on feedback I've received, I can make the fix and `git rebase -i` will let me amend any of my previous commits (via 'fixup'). None of the IDEs I've tried support it; it's possible instead of an IDE one of the dedicated git tools like Kraken support this?
It's also just mildly terrifying when the IDE gives you a button with no further explanation for what it's actually doing. I.e. what do 'refresh' and 'sync' do in VS Code? The consequences could be dire: https://github.com/microsoft/vscode/issues/32405
> reverting a commit is 2-3 clicks, or a whole lot of typing.
Git revert is a single command; finding the commit to revert is the hard part. `git bisect` makes this easy, and I haven't seen any IDEs nail that one. That said, this is a rare use case.
Well for all of these people: I recently found Lazygit (https://github.com/jesseduffield/lazygit) which is a terminal UI for git and that does exactly what I've been looking for all these years, down to vim-like keybindings!
The true power of CLI apps comes from "alias" commands that you build up yourself. The following commands are great examples of this:
alias docker-kill-all='docker kill `docker ps -aq`'
alias docker-rm-all='docker rm `docker ps -aq`'
> The true power of CLI apps comes from "alias" commands that you build up yourself
I usually agree. I spent way too many hours making aliases and I'm very proficient at it. But sometimes there's something like lazygit which does everything my aliases did, but slightly better as it gives me, for example, line-by-line staging and vim keybindings.
It is true that it does not compose, but I can still (and do) use the command line. It's just a nice increase of productivity in 90% of the cases (for me!)
Note: I'm not related to the lazygit project in any way, just very satisfied with it
Visual walk through: https://emacsair.me/2017/09/01/magit-walk-through/
Fzf all you can, not just inside vim, but also use it to switch between tmux sessions in an instant. I have a tmux manager on top of tmuxp that is able to start / switch to already started sessions via fzf.
Identify patterns you use a lot and make snippets out of them. Create project templates.
Have a folder where you dump reference / things that need to be really easy to find, and set up vim to search into that instantly, no matter where you are.
Keep an inbox file to throw things in, make a wm bind a script to prompt for text and append it there via zenity. Don't throw links into it, it's gonna be a bookmark dump.
Make sure your todo system is a keybind away at all times.
Review your way of working, challenge, and improve it. Be lazy, but only when you afford it.
This point here I think is incredibly useful in general. When accessing your full to-do list feels like its own todo, you're gonna have a bad time
Can you access your todo system from your phone? I'm always torn on this, and why I keep my todos in google keep.
[1]: https://github.com/todotxt/todo.txt-cli [2]: https://github.com/mpcjanssen/simpletask-android
If you also need a browser, IDE, or any other non-terminal application open then i3 lets you tile those as well.
I haven't used it in a while since we switched to macs and ssh'ing to remote linux dev desktops but when I had an all-linux dev setup I remember i3 being pretty amazing.
Just having sensible defaults on a shell works wonders on my day-to-day productivity.
Add a couple of aliases for productivity and off you go.
abbr --add s "git status"
abbr --add gap "git add --patch"
abbr --add gco "git checkout"
abbr --add gd "git diff"
alias recent="git for-each-ref --sort=-committerdate refs/heads/ --format='%(color:yellow)%(refname:short)|%(color:bold green)%(committerdate:relative)|%(color:blue)%(subject)%(color:reset)' | column -ts'|' | tac"
alias r="recent"Sure, you can use your IDE to achieve some of this, but this is where the 80/20 rule really breaks down: since each IDE differs in the details, at some point auto-formatting the code is going to waste more time than it saves by having to undo or work around mutually incompatible formatting rules. You can't reasonably expect everyone to use the same IDE, but you can expect them to use the same Makefile targets and CI pipeline.
Here's a config file for running some of these checks with https://pre-commit.com/ both locally, and then again on CI:
https://github.com/kogan/django-subscriptions/blob/master/.p...
https://github.com/kogan/django-subscriptions/blob/master/.c...
Black and isort complement each other in formatting your code, and both have flags to check whether they would change anything in your code. You can do the former either as a script or Makefile target, and the latter in CI to verify that the code is actually lint-free.
flake8 is your standard linter - it checks for idiomatic Python. I prefer to set it quite strict, with `max-complexity` starting at something like 4 and only moving it up if I really can't figure out a way to make the code simpler. And you shouldn't have to ignore any lints unless there's a linter or formatter bug or conflict. The only place I've seen this is with E203.
mypy is a tricky one if you're not yet used to Python type hints. I would recommend starting with no configuration and then introducing stricter rules as you understand more of them. My current go-to configuration sets all of check_untyped_defs, disallow_any_generics, disallow_untyped_defs, ignore_missing_imports, no_implicit_optional, warn_redundant_casts, warn_return_any, and warn_unused_ignores.
To list all the files in your project tracked by Git (because you don't want to lint or format any third party files) NUL-terminated (because you want to handle weird file names) run `git ls-files -z -- '[star].py'`. To instead list only the files changed from origin/master (your typical target branch for a merge request) except for those you've deleted locally you can run `git diff --diff-filter=d --name-only -z origin/master -- '[star].py'`. You can then pipe the result of either command to `xargs --no-run-if-empty --null black` and similar. Use the first Git command in CI to lint all the files, so that you don't miss out on any changes for example when any of the linters change their rules. Use the second Git command locally to format and lint your changed code. And make sure you have some way to force formatting/linting all the code for when you update any of these programs.
Finally, running all the linters as part of a pre-commit hook is a great way to make sure you never commit broken code. Having a bunch of lint fixup commits is ugly and counter-productive.
Start with black. It's very easy to setup, and the reward is great.
Learning the YouTube APIs saved me thousands of hours on editing video metadata, organizing playlists, etc (https://github.com/cgranier/pytube).
Everything (https://www.voidtools.com/) is a wonderful file search tool for Windows.
Thanks for all the links and ideas... new things to try this week.
- setting up a personal vpn with a reserved IP if you connect to services that require your IP to be whitelisted and you move often
- for git cli: dashes take you back to your previous location (eg `git checkout -` will take you back to the previous branch). On zsh: `cd -n` will take you to n directories ago
Mac only:
- the Paste clipboard manager has been a most delightful tool, though I don’t know if I’ll ever upgrade to the new subscription version: https://pasteapp.io/
- the workflows feature in Alfred.app as a convenient place to keep utility applescripts / other kinds of little scripts that you want to invoke through global shortcuts or through Alfred
The thing that finally made this worthwhile for me is GNU stow.
https://alexpearce.me/2016/02/managing-dotfiles-with-stow/
Stow is available from homebrew if you prefer to get your Mac stuff that way.
What are you thinking about switching to?
Last year it looks it launched a sharing interface with what looks like a non-trivial backend to it. In January, a rewrite of Voice Boost and support for Air Play 2 was released. So it's pretty actively developed.
What kind of features do you think is lacking? I feel like I have very simple needs. The only time I've wanted for something is occasionally wishing to use it on my desktop and the web interface is okay-ish for those brief periods.
It definitely isn't the same thing. I kinda understand why you think that way, but it's pretty much completely illogical (see avoiding ever skim reading anything written by someone, or never fast forwarding any filmed media where a person is speaking).
- Listary (windows) Not sure if its 100 hours, but I love its search in any context of explorer. Default explorer search is terrible IMO. For example when you open file - you can use search there instead of navigating by hand.
The only major roadblock I encountered was with PHPStorm, as it doesn't have native access to files inside the Linux subsystem due to the different file system format. In the end I opted for running an X server on Windows (via MobaXTerm) and running PHPStorm inside the Linux subsystem.
I wouldn't mind going back to Ubuntu (and probably I'll do so when the quarantine ends), but it was a nice surprise to see how good Windows has become for dev work.
But there's no doubt I've spent at least 10x as much time on Ubuntu configuring and reading and fixing.
The only upside of Windows, and definitely a major one, is power management. On Ubuntu, my battery lasts around 2.5h with moderate use whereas on Windows, it's around 3-4 hours. Yes, I am already using powertop and TLP. =)
In truth I don't like any current OS - when you add up all the pros and cons, Linux has the best overall balance of attributes for my use. It's far from optimal though. I find the state of OSs in 2020 pretty sad.
On Windows I would have vaguely but very briefly googled. I would either find a quick fix or not, and be on my way.
On Ubuntu I only bother searching online if I know what software's causing it, and it's open source. Otherwise I find the signal/noise ratio too high (and I rarely get useful answers on SO or other forums - I either get nothing or too many people helpfully but uselessly saying "try this!" "try that!"). More often I just dig into things myself.
So I trawled the syslog, couldn't initially find anything, narrowed down by triggering the issue deliberately while `journalctl -f`'ing, etc. I traced the problem to a recently installed Gnome extension that was crashing X on screen blanking. An uninstall failed so I had to find out where extensions are on the filesystem, remove it manually, restart mutter, etc.
The whole thing took about 25 mins.
The upside for Ubuntu here is that I could actually fix the issue. This is rarely a given with Windows (though for me it produces fewer such small issues). On Windows, if I can't fix something that's not critical within a few minutes, I end up just putting up with it. These accumulate over time and I find the OS increasingly irritating. Ubuntu's irritation level doesn't increase over time (though its plateau is way above zero). The downside for Ubuntu is that this really does involve more fiddling time (a known known because I keep logs). For me (a regular non-expert user) anyway.
- you will run the latest software
- from the very beginning you are involved and personally responsible for your machine.
- the wiki is very well written
- no periodic upgrade hell, since it has rolling updates (everything is always updating all the time)
- if software is not in the repository, it has AUR, which will help you build anything that is missing
Ubuntu is a necessary evil, but I don't like some things:
/etc/default/apport
/etc/default/kerneloops
/etc/default/motd-news
snapd
unattended-upgrades
ubuntu-report
whoopsieThe good thing about Ubuntu is that it’s the default “Linux” (distribution) so whatever you are looking for, there is likely an AskUbuntu question, a .deb package, a blogpost, or a mailing-list entry to help.
Also, it is dead simple to make your own PKGBUILD script for arch, but last time I tried looking into making a .deb my eyes rolled into the back of my head.
These day I read more stories about people switching from macOS to Windows than the other way around.
OTOH I have to reboot Ubuntu from time to time (once every week or two) because I can't solve a problem (eg. the suspend getting in a snit).
I'm guessing you haven't tried Linux in 10 years or so, but even then I don't understand how Windows does any better on the drivers front.
Wife’s Mac mini sometimes prints, but it can take 20 minutes to go.
Unless the driver is broken or doesn't exist, then you're SOL.
Bonus: you can update video drivers on Windows without even rebooting or losing your GUI session.
OTOH building on windows takes literally multiple times the time it takes for building the same software on the same machine / SSD on linux. And that's something that I do every day, multiple times per day.
The VS Code remote wsl and ssh support has also been invaluable.
And for the past 2 months or so, WSL2, Docker Desktop (WSL2 enabled) and VS Code's WSL extension have made using windows for development about as nice as it gets.... all the non-essential stuff works (rgb controls, etc), and I can still just use linux for development using my GUI editor.
WSL, Docker Desktop and VS Code with WSL integration. It works well enough.
I cannot stress enough the word immediate. Delayed reports (after a week, after a day, or whenever I check) sure give a bit of reality-check and insight on what to change (usually only the first time) but were not useful for actually implementing these changes. (I have ADHD if that matters. For some people insight might be enough.)
Qbserve displays constantly the current productivity score. I had a love&meh relationship with RescueTime (since it does not offer a way to display productivity tracking all the time), but after composing it with a link to report on a new tab (my most common way of procrastination), it was a game-changer.
A small note - if you prefer something more private, and open-source, there is https://github.com/ActivityWatch/activitywatch (I use it as well). Not as polished, but clearly logging well, and it has Web UI on localhost, thus can be used with Custome New URL Tab as well.
- Spotlight - for quick calculations
- Contexts [https://contexts.co/] and chunkwm for window management [https://github.com/koekeishiya/chunkwm]
- Maccy [https://maccy.app/] for a decent and beautiful clipboard manager
reindex everything should be happening that often unless caches are cleared; you might want to raise an issue if it's happening more often than you'd expected
what I'm more bothered by is the regressions that creep in either IDE or official plugin updates; I've spent some amount of time on every update I'd deem wasted, just to find a YouTrack issue on it :\
For anyone on macOS who doesn't know, hit command + spacebar.
The saving layouts feature is an absolute gem.
2) dmenu (https://tools.suckless.org/dmenu/) is a lifesaver. I use it even on Ubuntu to launch custom scripts. The autocomplete is good because unlike when I use alt-F2 I can actually tell if a command is type correctly or not. Also it's a little known fact but you can type full commands into it, complete with pipes, and it will execute it. For ages I had a bind against notify send so I could examine data by doing `Meta-P foo | show` which would dump it to a notification. Just really useful for getting data without needing to wait for a terminal to start, just to show you one thing or value you need for 2 seconds.
3) Also I'll go ahead and plug my filesystem tagger - koios (https://gitlab.com/finnoleary/koios). It has a feature where it will autodetect (using libmagic) the type of a file.
So you can do something like: "tag all the files that have the mime type 'png' files in the directory with the tag 'png'":
koios auto image/png +png .
koios show +png | grep -v '.png$'
Less of a given, still Mac: Rectangle Tiling Window Organiser https://rectangleapp.com/
For Linux I would use Xmonad to achieve the same as the two programs above.
Without this, I might have given up on Haskell a long time ago.
Also Cachix[0], as building lots of Nix packages from scratch takes an awful long time, especially on my MacBook Air.
Also git, vim, etc.
[0]: https://cachix.org/
It can be a memory hog when left running ,and I wish I could "pop out" portions of the UI to reorganize on my screen.
Otherwise, indispensable to my work the last couple of years.
I still find myself in situations where I need more than Markdown but less than React; as a result I just need to quickly get some HTML on a page. Emmet lets you expand a snippet similar to a CSS selector into full-fledged markup, complete with attributes.
I love the plag in.
Elegant, clean, readable, an absolute pleasure to work with.
Compared to it HAML feels exhausting and writing/reading HTML... unacceptable.
It has tons of software packages.
The difference is that it (largely) stays confined within a directory without even needing elevated privileges and such for installs (which brings peace of mind for community installs). Repository is more centralized and automated too it seems.
Not perfect in a few edge cases, like other programs expecting a certain install location. Overall enormous time saver.
# ci = clipboard in, co = clipboard out
# xclip so this works in gui apps too
alias ci="xclip -selection clipboard"
alias co="xclip -selection clipboard -o"
Docker - Allows reproducible builds and caching, an indespensible and composeable tool for development.
Shell Aliases - just using aliases for common commands in .bashrc saves tonnes of time. Even better version control your aliases in a github repo like this https://github.com/benwinding/dotfiles
Flameshot and Peek - lightweight screenshot and screen recording tools
Linux - It's difficult initially, but Learning and developing in Linux really is just faster, easier, and saves tonnes of time, mainly due to the unix philosophy...
- Magit, to quickly organize hunks into commits and do general git things
- Org mode, to organize TODOs, thoughts and even draft code snippets and designs
- Language-specific layers with great features (usually REPLs, support for refactoring, autocomplete — stuff you expect from any other IDE).
If you work with Git a lot, it's worth looking at for Magit alone. The way you are able to perform complex tasks with a few keystrokes is a huge timesaver for me.
https://en.wikipedia.org/wiki/Spaced_repetition
There are two ways in which it’s saved me hundreds of hours. These are of course anecdotal, but the science behind Spaced Repetition is pretty solid.
1. We naturally forget information after a certain amount of time. Much of this information has to be relearned at some point; I’d estimate we end up learning the same fact at least a dozen times over the course of our lifetime. SRS can cut this relearning time to the minimum necessary.
2. By optimizing for ‘daily maximum possible learning.’ This is related to the Spacing Effect and it’s a crucial idea underlying SRS.
https://en.wikipedia.org/wiki/Spacing_effect
In my personal experience, there is a limit to the amount of information you can meaningful acquire per day. After that point, it becomes a waste of time and effort. So, by dividing learning materials into smaller pieces and spreading them out over time, you can reduce the amount of time needed to learn them.
This is particularly relevant for useful-but-not-urgent information, like alphabets or geography. For example, trying to learn and remember the Russian alphabet in a single day will probably take you a few hours, if not all day. Learn one letter per day over the course of three months, however, and your daily time requirement is perhaps a few minutes. The retention rate per minute of time invested is dramatically higher.
I've been using my own version of 'hyper key'[1] for years now. I map capslock to ctrl (in OSX), then ctrl-space to 'ctrl, command, option' in Karabiner, so that I have a 'namespace' of my own hotkeys, which I assign to apps in apptivate[2] to quick switch, and finally I make it so that if I tap caps without hitting another key, it actually hits escape. I use a two-button combo for hyper instead of just capslock so that capslock on its own is just ctrl, and I can use all the default readline shortcuts.
[1] https://stevelosh.com/blog/2012/10/a-modern-space-cadet/#s14... [2] http://www.apptivateapp.com/
I am a hobbyist NLP researcher and have published 4 papers in the last year just thanks to this library and the many life-saving tweaks. Honestly a world-class effort from the team at Facebook.
- Alfred App - helps with tons of things, but the clipboard manager alone has saved me over 100 hours
- iTerm 2, especially with a global hot key (and Guake on Linux before my first Mac)
- Prettier on npm (auto code formatting tool, like gofmt)
- Jumpy on npm (my own CLI bookmarking tool, makes it easy to hop around directories)
Spotlight on steroids, along the lines of Alfred and Quicksilver, but the best of the bunch, imo. It's a frecency based fuzzy matching searcher that adheres to subject - verb - (optional) object grammar, and using it feels like a global GUI terminal. A new mac without it feels completely gimped. Things I use it for:
- quick launch/switch apps
- browse filesystem (like https://github.com/ranger/ranger) and do anything with item
- take selected item (file, folder, url, text) -> open with X, send to any search engine, move, copy, rename, start composing email with text, compress, basic text munging, etc.
- calculator
- clipboard and snippets manager (incl. variables like current date/time)
Also - git, Django REST framework, VueJS
This plugin can be clumsy sometimes, so I tend to use qutebrowser more often
Is there a resource about state of the art typescript with vim?
It supports macros, and as far as I can tell most of the actual navigation and text manipulation stuff works, even stuff that I didn't find in spacemacs. Even relative line numbers work which has been a godsend. I can navigate tabs using gt/gp, and split windows with :split/:vsplit, but I use the built in file search/navigator for opening files which is far superior to anything I managed to get set up in vim (and I played around a lot).
Then I have a simple .vimrc with only a handful of modifications (100 lines or so) and I drop down to real vim for writing small scripts, and any other text composition and refactoring, like comments on HN ;)
I hear VSCode has an excellent vim plugin, although having briefly played with VSCode a few months ago I don't think it's the tool for me. I'm happy with something heavyweight for developing projects, and something simpler for quick scripts, slack messages, etc.
YMMV of course but this was the route I ultimately ended up taking and I'm happy with my decision.
Mosh https://mosh.org/ I'm a fairly recent user so it hasn't been 100 hours yet, but it will be.
Not a program per se, but a few years ago I set up a cron job to back up my shell history every night to a file named based on the date, and then aliased 'h' to grep them all and pipe to tail. This allows me to see the last dozen times I used any string in a shell command. It comes in handy many times per day.
Instead of stopping whatever I'm doing, thinking about what password I used last time something forced me to rotate, pass saves the day!
* AwesomeWM, https://awesomewm.org/.
Maybe not a program per se, anyway using easy-to-remember keyboard shortcuts instead of clicking through a gui probably saved me a few minutes here and there.
* Gentoo Portage, The Gentoo package manager.
Yea, something that compiles packages from scratch may not sound like your typical time-saver, however, back when I had to track down every dependency and compile it myself just to get whatever package working that wasn't in the current distribution package tree, this saved me a lot of time. - This of course goes for every package manager, however back then(tm) portage had the most current releases and a lot of packages not in apt, rpm, etc.
* tmux (and tmux-cssh), https://github.com/zinic/tmux-cssh/
synchronize ssh sessions, like clusterssh, not very elegant but this saved me more than once, fast synchronized change on multiple machines at once \o/
* Ansible https://ansible.com/
Make tedious boring tasks less so, specify stuff in yaml once, execute and forget about them.
I moved to SaltStack https://www.saltstack.com/
And for Ansible, I absolutely like sovereign[2] saved me a lot of time while setting up my home servers.
[1]: https://www.reddit.com/r/unixporn/comments/a900p7/awesome_me...
Rubymine - Ruby And JavaScript IDE with powerful SCM, test and debugging tools.
Notion - Shared Knowledgeable and collaboration. Really easy to go from a free form unstructured draft to organized, structured and easily accessible knowledge repo.
Whimsical - My favorite diagraming and wireframing tool.
Notable mentions
Stoplight OPen API editor.
Sunsama - light weight and collaborative todo list with focus on Calendaring
My blog post about setting up a Linux workstation has a few timesavers: https://tkainrad.dev/posts/setting-up-linux-workstation/#boo...
An important improvement for me was to switch from Bash to Zsh and use a variety of plugins, such as z, zsh-peco-history (better history search), zsh-autosuggestions, and zsh-syntax-highlighting.
If you work a lot with ssh, it is also worth the effort to create a proper .ssh/config that contains the most used hosts.
Anyway, my workflow is centered around directories and files accessed from Sublime. Every directory is major subject area or project. One directory is the Control Center - filled with documents that drive my work day and planning. Things like Work Journal, Weekly, Master, Research Depot, etc., are all referenced every day - sometimes dozens of times.
Table Editor package for Sublime to create logs, reference tables, checklists (option v = √). Also great for tracking my micro workouts - calisthenics every hour to keep the pump bumping.
Code folding works to hide "folders" of data within a text document so I can access things quickly from their header line. This is particularly handy in the Research Depot file. Exempli gratia, I have NPRs Music recommendations of 2020 folded up to one visible line with checkboxes of albums I've tried. Another folded area is on Stinging Nettle uses.
My zettlekasten system was moved to Sublime as well. It got its own directory. Added a time stamp package for naming the file from the first line with a CMD-T, and some simple markdown, each file is a zettle. I use Zettlr for exploring the notes - but Sublime for editing. Perfect mix for me.
It's not so much this all saved me 100 hours, but my productivity is up 1000%. No hyperbole. My writing, projects, chores, fitness and client labor are all up by extraordinary levels. My down time is more relaxing, work more pleasurable, and creativity is like a real psychic adventure. And, it should also be noted I've been on Sublime for maybe ten years, or so it seems.
Sublime
TableEditor
Code Folder feature
Tabbed directories - combined windows view
Zettlr
Monodraw - but looking at the markdown diagramming tools...But sure, I'm happy to share. It's now next up on the article hopper. To be shared here and on my blog / gopher site soon.
Though these are hardly secret tools :)
- PDFill Free PDF Tools - indispensable for dealing with any bureaucratic tasks - cutting/rearranging pages, etc
Also thanks! I'm getting Jira'd, and some things are so slow that it can take upwards of 30 minutes to set up tasks / reorganize / etc. Automation would help a lot.
some of its functionalities are 1. Unlimited templates for default jira params like epic names, labels, priority etc. 2. alias for frequently used jql 3. aggregation like count,sum support over jql output 4. making multiple jira transitions with single command by saving those transition as comma separated values.
many more such features
Then custom scripts I made to do specific tasks on hundreds of files. So familiar scripting languages, in general, such as those regularly used at work. I had actually used MatLab for non scientific uses like batch downloading, or batch image/audio format conversion.
And a modern IDE that prevents many errors in the first place. VS Intellisense does it for me, but I guess there are equivalents in other development environments.
Spectacle: Easily organize windows without using a mouse on macOS.
Not only saved me tons of time and increased my development speed, but allowed me to recover from RSI and pains in my forearm, which in my case was caused by moving my hands between the home row, arrow keys and mouse constantly, and especially worsened when using the mouse scroll wheel.
Also, `vim -` (stdin buffer edit mode) is absurdly awesome. It starts with `ls -la | vim -` and ends up with `cat * | sed ... | vim -` and saves a ton of time.
These bashrc aliases rescued my stupidness a lot of times:
> alias cls="clear; printf '\033[3J'"; # clear screen and scroll buffer
> alias cp="cp -i"; # confirm before overwrite
> alias df="df -h"; # human-readable sizes
> alias mv="mv -i"; # confirm before overwrite
> alias ns="netstat -tup --wide"; # show active program sockets
If I would have to choose, it's definitely VIM that automated the most. Switched to VIM around 2004 and didn't regret it eversince.
Remotely debugging on an ssh server to figure out what's going on - with the same editor configuration and setup as on your desktop computer - comes in very handy in emergency situations when you have almost no tolerance for mistakes.
When I first tried NodeJS, I was hooked... You can build simple CRUD backend APIs within minutes! I'm aware you can do the same with Java, e.g. something like Spring Boot streamlines the process a ton as well, but the feedback loop of just writing a line or two and having a server automatically reload within seconds is amazingly addicting.
I am not sure I would use Node for production... I suspect a lot of the Java world might switch to Go as being much faster yet much safer than something like Node.
(I am an amateur Python dev and tried Go but could not live with the error handling boilerplate and the lack of exceptions. It looks like a nice language though)
Now I feel like many doesn't work on Google
Sure, it’s true some of the operators come and go, but I assure you some of the most important ones still work fine and Google one a daily base asks me if I am a bot.
Happy to answer any questions if there’s something specific you’re having an issue with.
[nhs inurl:mcusercontent.com] = 2 hits.
[covid-19 nhs inurl:mcusercontent.com] = 90 hits.
[covid-19 "nhs" inurl:mcusercontent.com] = 90 hits.
I'd expect that first one to include all the second, but it doesn't. I thought maybe the second is ignoring the NHS word, so I wrap it in double quotes to force it to be included and it returns the same results.
(In fact, the article I linked to references this as a way to do quality assurance on Google’s indexing on content on your own domains.)
———
Note that the sum of the counts for the following three queries:
[“aaa” AND “bbb” site:domain.com]
[“aaa” AND -“bbb” site:domain.com]
[-“aaa” AND “bbb” site:domain.com]
...in theory should equal count of this query:
[“aaa” OR “bbb” site:domain.com]
...in practice though, they never have; by never, since Google first released their search results.
——
Further, while counts frequently are over 1000, only the first 1000 search results are viewable, and vast majority of searches only pull the first 10 results and review an even smaller percentage of those 10 results.
- Jetbrains IDEs - the refactoring and debugging tools are second to none.
It might not quite be in the 100 hours bucket over the past 2 years, but it's close... using their toolbox app has made them much easier to keep installed/updated on my Linux workstation.
Also, honorable mention for magic wormhole, a finally sane way to move arbitrary files between devices.
It makes purchases easy, it makes reviews / researching games easy, it makes updates very easy, it often makes finding mods easy, it makes installs easy. And it reduces issues of lost games / keys after many years go by, as they're all in the library.
Intent was to explore if I still could be as productive doing a variety of things (general administrivia, writing, design, code) outside of MacOS. So it's organized less around a specific app but rather a workflow/concept.
Ideally I'd love to see a git-backed static website around this so people could fork/collect/share their workflows across environments visually.
ShareX (windows): screenshot > optionally annotate > upload to ftp > copy url to clipboard
But I can also paste from the clipboard:
- if it's a file: upload to ftp, copy link to clipboard
- if it's text: upload to ftp, custom URL makes it load in my org-mode or markdown web-render
OpalCalc (Windows) | Soulver (Mac) | NaSC (Linux)
- Chocolatey (package manager)
- Ninite (auto-installs 80% of the programs I and the family might need on a fresh windows install)
Having those utilities available in Windows saved me not hundred but ten of thousand of hours.
Also learning PowerShell when dealing stuff in Windows is saving a lot more hours then the ones you put in learning it.
Vivaldi browser - Amazing for productivity, custom search engines, configurable, can be controlled by keyboard. I can search in company ishare/OneDrive via URL bar etc.
Total commander - I use quite minimal interface, it actually looks more like fman. I use the folder jumplist a lot which saves a lot of time. I have some custom buttons (open in gVim for instance) and lynx like movement.
Linux:
Terminator - Terminator with splits, nice font rendering, easy GUI configuration
Arch - I can also put it to the cost me 100 hours list :] but AUR definitely saves time compared to Ubuntu dependency hell.
GridMove to arrange windows (with multiple monitor support) by keyboard shortcuts according to a grid I specified.
AutoHotKeys script that replaces 'dddd' with current date, 'ddtt' with date and time, 'dtdt' that outputs date and time with underscores (think filenames) and 'tttt' for just time.
The following features have saved me 100s of hours:
- Being able to run tests/benchmarks directly in a test file via either clicking the play button or using a keyboard shortcut
- It’s refactor support
- automatically getting imports ordered and code formatted on save
- multicursor support
- and even more!
Visual Studio, ReSharper, Notepad++ (I did many tedious tasks with ease just by using regular expressions), Git, generic To Do list software (Microsoft ToDo, Todoist, etc.) - not everything is to be kept in Jira so this kind of software helps with organizing other tasks.
Not code related: Adobe Lightroom, Adobe Photoshop
Web browser is a piece of software that saved me time but also helped me waste a lot of time. So it's not only software that matters but the user, too.
As a nice bonus there is also a wonderful vim plugin :)
I'm working on a single monitor, so managing workspaces is crucial and xfce4 lets you set these up in seconds.
I am very happy to now can brag about it to someone:
You can allow your desktop to react to your mousewheel to change workspaces. Combine this with a one pixel border on any site of your maximized windows and you can circle your workspaces by just pulling your mouse to the edge. In practice, with an full-hd monitor, one does not see that there is one pixel of your desktop visible. In the few cases where the hand uses the mouse, this is the most convienient feature one can possibly experience.
I also can click in the same area with the right mouseclick and access my applicationmenu.
Another neat trick: xfce4 has to default application finder, alt+f2 and alt+f3. The latter appears to be unusable, because one has to tab to often to select an application.. But you can just resize the right pane far most to the left and the finder will always remeber this behaviour. The latter also includes user generated menu icons.
Since I rely on maximized windows, I also excluded all window borderings to maximize the viewport. simply delete all contents of your selected theme and reapply it.
One Terminal is configured as a dropdown, so it is permanent accessible over the entire worksession until you force close it, also, built-in.
Hotkeys for circuling workspaces and circle the current window within them as mentioned above.
Different backgrounds for each workspace plus a translucent panel, so I can identify on which workspace I am via perceptual cognition.
alt-rightclick lets you resize an window to any size.
It is the perfect workstation and i highly recommend it. Everything is builtin and works on all major distros out of the box.
- Talend API Tester: a Chrome extension to test (you probably guessed it) APIs! I can automate many things with it and use regex in my tests. If I had to do all that manually, I'd have become crazy by now. - Watir: a Ruby library that is essentially a wrapper around Selenium. Watir is easy to use, and I found Ruby very easy to learn. Also, bundler makes the process of keeping my libraries up to date really painless (when my webdriver tells my that it can't communicate with the browser because it has become outdated, a simple 'bundle install' fixes the issue)
[] Note: I don't need to do a fancy program, I just need to write some farily simple scripts that automate actions a verify a few things on web pages.
Been using it from Windows 98 as a "trial" version, so during all those years saved hours count is immeasurable. Sadly, there's no decent alternative on Linux. Krusader looks functionally almost on par, but there's something about UI and lack of integrated tools (it uses external programs for some functionality) is throwing me off.
It saved me a lot of time and caught tons of mistakes before they got to production while working on multiple websites as a contractor
For example, I was assisting a team on one sprawling dynamic website with a lot of SEO and performance issues - the site had been hacked together over the years such that editing one page would usually break groups of unrelated pages in unexpected ways. My extension helped me get on top of which pages were dependent on each other, to prioritise what was worth fixing, and to confirm improvements had been made without breaking anything.
(Back when I was looking for something like this, Regex Buddy always popped up in the search results but it didn't look good enough to fire up a windows VM just to use it. The auto-generated explanations based on your regex/test data from regex101 have proven to be tremendous debugging aids.)
[1] https://www.supermemo.com/archives1990-2015/english/smintro [2] https://supermemo.guru/wiki/Incremental_reading
SSO is free, and they offer other enterprise-focused features, like directory sync and audit trails.
WorkOS only handles SSO, so all of our users are still stored in our own database. This is one of the big reasons we went with WorkOS as opposed to something like Auth0 or AWS Cognito.
To mitigate that, we've been using a tool called Rookout (https://www.rookout.com). We no longer need console.log statements in our code - We just set non-breaking breakpoints via their Web IDE and it just works - we get all the data we need, and without redeploying ¯\_(ツ)_/¯
TouchCursor to enhance keyboard, mostly as arrows, "Start" and "End" buttons. Allows to deal with text without moving hand to arrows.
Once it is in place it saves plenty of keystrokes and routine tasks.
If you ever had to write a non trivial deployment by hand you know what I'm talking about.
Having a local search engine with annotations is incredibly useful.
Having a simple standard way to automate all of my modify->"do x" runs has been wonderful, and (with a bit of care in your project structure) being able to near-livecode in almost any language is an incredible productivity boost.
* qutebrowser is close second as a lot of time on the web - the more efficient my web browser is the more time I save. Scripts, quickmarks and keyboard shortcuts just save a lot of time.
* spotify, music collection takes a lot of time. Finding music, buying music or even downloading music illegally is very time consuming. I maintain catalogs of obscure vaporwave subgenres and it's really really time consuming.
I learned them from Emacs on Linux and was pleasantly surprised to find that they work in almost every app on OSX.
I used TamperMonkey to include https://www.papaparse.com/, then injected a button into a web page. The user would navigate to the "start" page, and a button would appear, it was just a normal form button. They would upload a CSV, which I slurped into a cookie, webdb... and something else. That would then walk a known set of URLs to scrape the unknown URLs and click the required buttons to trigger javascript calls by the website itself, before building a further set of URLs to navigate. It would visit the "final" set of URLs, gather the info into a secondary CSV, then walk back up to the entrypoint before going to the second entry.
At the end, it would download the secondary CSV to the users disk in a format that was uploadable to another system.
The entire thing was in a single if statement because I was just learning JavaScript and did not know any other way to get around async problems at the time. :)
It was ugly, but worked awesome and since writing it several years ago has probably saved 10s of thousands of hours.
REAPER, Pure Data and other - I don't have to slice and glue magnetic tape to create electronic music
Thunderbird - I don't have to handwrite letters and bring them to the post office
I think the more interesting question would be: which computer program hasn't saved me 100 hours...
It has tons of useful features that should be in a line of business application. It saves you more than 100 hours with pre-built pages (authentication, permission management, localization, multi-tenancy, SaaS features, CRUD Page Generator (RAD Tool), themes etc.)
This combined with a Super+C shortcut means you can copy multiple things in once and paste them in the order you want.
Plex - We have munchkins and they love watching the same stuff off youtube or movies over and over. We simply download them and Plex will sync them to all of our devices with easy offline support. (We run it on a synology NAS)
- shell's ^R (history), ^T (args), ^P ($EDITOR)
- vim's ^P and <leader>p (open), <leader>b (buffers), <leader>r (tags)
and small little tools of my own like kd (mentioned around here), or vim's - to go up from file to dir in netrw, that allows to jump to any place of my filesystem quickly.
ls *.css *.html | entr reload-browser Firefox
Prior to that, we would have templates being opened and copied over. As much as developers often don't like Excel, the problem that Excel has always directly addressed still exists: Not everyone wants to program.
I find Remfo very useful: https://rememberforever.web.app/
It helps me take notes & memorize things. It is currently in beta but still very stable
zsh & ohmyzsh plugins
Clipboard manager - built my own because I wasn't happy with the ones I had tried... https://nellyapp.com
Linux proper on windows, the Docker Desktop integration and the WSL Remote (and SSH Remote) extensions for VS Code.
https://www.youtube.com/watch?v=A2PaLZRpWdY
Likely more than a 100 hours saved using this tool for DWH work.
Easy to see the traffic flow between apps/apis. It helps to read the raw http req/resp, debug and replay the request with modified parameters.
This equivalent to the new macOS Mojave shortcut Command+Shift+5.
For example, typing "scp" could expand to "scp -r myself@servername /home/myname/.logs/logfile ."
It's a concept that originated with the Fish shell, but is useful if you want to maintain some semblance of bash compatibility.
It pulls source and destination branch merges them locally and then pushes the source branch and creates a pull request if not already there. Reviewers are configurable per repo.
Disclaimer - I have used this every day for past 3 years and i maintain it as well.
- bashmarks
- zsh-autosuggestions
- yasnippet/emacs
- awk
- explainshell.com
- ansible scripts for setting up new dotfiles and my commonly used tools on a new machine/VM
Autosave feature.
Countless hours saved by not loosing information.
fzf - a command-line fuzzy finder
tmux - a terminal multiplexer
bash / zsh and the console tools (grep, sed, awk et al.)
python
vscode
alfred
prettier for js
mix format for elixir
github actions
okta logins for my employees
aptible for server management
render.com for personal projects
it's a linux clone of autohotkey, meaning it lets you script your mouse/keyboard/windows using python. It can trigger the scripts using a keyboard shortcuts or by watching keywords in regular text. I use it to kill emai/phone/date quickly, or to automate combinations of actions in GUI that don't have macros.
youtube-dl
I travel a lot, with plenty of downtime. Downloading conferences from many video sites, or music, turns those otherwise wasted hours into learning experience, relaxation, etc.
dynalist
Favorite life organization app, that I use for shopping, restaurant idea, todo, etc. Basically half of my GTD is in there. It's much more productive than any system I tried before, and I tried a lot of them.
thunderbird
I have 20 email addresses, and this varies depending of my clients. Web base email are not up to the task, and I need offline search/archive capabilities. Thunderbird is the only mature cross platform app that does that correctly.
pulsesms
I have a rich social life, and this means organizing groups of people. Of course, they all have their different chat apps, social account, preferences. Some are using an old 3310. Some don't want to be on facebook, etc. SMS is the only things that works with everybody, but typing it on the phone is a pain. I have an android phone, so no imessage, but no google account, so no android message. Pulsms allows me to write message from my computer comfortably.
fdfind and ripgrep
I search stuff all the time, and since they are way faster type (because easier to remember), faster to execute, and have an output that is faster to read, cumulatively it saves a lot of time.
tilix
I don't use a tiling windows manager or tmux-like software, so I rely on tilix to provide a terminal a the press of a key, and to provide tabs and split screens.
black
Automatic formatting for python code. No parameters.
bitwarden
Or lastpass, or 1password. Any password manager really. But bitwarden is the latest I'm using. I'd also say "tetripin" for otp on the command line but it would not really make it up to 100 hours.
meld
It compares files or directory. It's not the best out there, but it works everywhere, so I don't have to wonder. I just install meld. I'd say reggexer for search and replace as well, but again, not saving 100 hours.
--
Of course I could say GNU/Linux, python, firefox and vscode, but it's a bit obvious. Probably the most productive softwares I use though.
* frequent (automatic) backups (saves time and mood when things go wrong)
* i3
* fd (alternative to find)
* ripgrep
* keynav (don't use your mouse)
* !bangs on duckduckgo
* calcurse (terminal calendar)
* readline: C-h C-b C-a C-k M-b M-f C-u etc.
* howdoi (get SO answers in the terminal), especially useful for things you somewhat know but just forgot the syntax of.
* youtube-dl as already mentioned somewhere: you get out of youtube ASAP to prevent their algorithms from tricking into staying there. I also use it to watch videos later when I don't have internet, using a syncthing folder on my mobile which only syncs up to 10% remaining space (so that it doesn't fill with 100s of videos, just a few, enough for some trip). Videos are also rather inefficient in terms of communicating ideas, so better to keep them for when I really don't have better to do.
* in the same vein, adapt the speed of (technical) videos you watch, to skip the fluff and focus (even rewind) the difficult parts. Skip all ads, everywhere.
* uBlock Origin, for the same kind of reason: just block any annoying, time-consuming parts of website. If I need to go on some website regularly, and they happen to have a news section I don't care about (like their twitter feed), I just block it to get it out of my way.
* even use a text-only browser (I currently use w3m, which could show images in theory) for things like HN. HN itself works well, and its good links as well. You just trim a lot of the fluff, ads, etc.
* an easy way to sync files between your mobile and your computer (I use a combination of "Notes to Self" in Signal with an auto-destruct of 1 week for temporary stuff so that I don't have to delete it manually, and syncthing for longer-term things)
* script your way out of any repetitive task: if you need to register periodically to something, either use their API if they have one, or use selenium to automate it. I was really surprised how little time it took me to write my own script and learn how to use selenium.
* in general, rely less on proprietary software: it has the potential to break ("introduce new and shiny features and somehow make some old ones disappear" or just change the pricing-model) more regularly, and you'll have to switch which can be a burden. If some free (libre) software breaks hard for a lot of people, chances are that a fork will happen and the transition will be easier. This also applies to SaaS.
* try to avoid desktop apps: they don't compose well, you cannot easily script them compared to a CLI. It's also better than having a full remote desktop when you resort to SSH (especially on bad connections).
* try to learn the default keyboard shortcuts of software you use, unless they're really crazy: less config (which you'd have to sync and maintain), easier to use a computer which is not yours if need be
* regularly check that the commands you write in your terminal are not too verbose (use aliases / functions): https://news.ycombinator.com/item?id=22853646
* check what's possible with frameworks like https://github.com/sorin-ionescu/prezto
* some dotfile repository to get you started in 5min on new computers with the same setup you're accustomed to.
* mutt (mostly to easily write emails in vim and grep emails from the terminal)
* cronjobs and reminders (I get new music albums on my phone regularly from my music library, so that I don't have to choose them manually (it's my library so I know I like them anyway). I used to actually spend time choosing music from my own library.)
* typing from your phone is inefficient, avoid it if possible. Batch your (non-time-critical) messaging. Most modern messaging apps have a desktop version these days.
Skipping from one LTS to another should probably include some breakage.
Need postgre? Link to one service. Need mongo? Plop another. Rabbitmq? redis? No need to tell them to install those, just pass the docker compose file.
Remote Leaf collects remote jobs from 40+ remote job boards, social media feeds & 1200+ company career pages, LinkedIn and sends the ones that apply to you.
Here's how easy it is to remotely play audio on a stereo hooked to a raspberry pi:
% rimport -a -u mrtea pifi /dev/audio /dev ; play music.mp3
oh, you also wanted to play the mp3's in Shelley's music directory (provided shelley lets us...)?
% rimport -a -u mrtea shelpc /usr/shelley/mp3 mp3 ; play mp3/shelleysfavorite.pls
That rendering job is going to clog up your cpu but you'd rather play doom. instead, run the job on many core server cerberus:
% rcpu -u mrtea -h cerberus -c rendercmd -args
compile and install a program for arm64 so you can also run on raspberry pi 3/4:
% objtype=arm64 mk install
The above commands require little to no configuration or external tools to work. You dial a machine and ask for resources; if you have permission, you will be granted access. If you want a windows domain like network auth you point your systems to a single machines auth server instead of the local auth. The c library is so streamlined that it makes c fun to use again, Go is directly inspired by it. compiler tools kept simple and cross compiling is a non issue, just change objtype. Even system libraries such as tcp communication is dead easy: http://man.postnix.pw/9front/2/dial. No shared libraries. Instead you write programs called file servers which provide services as sharable resources. Every other OS by comparison is horridly is broken.
Unix is broken. OSX is built on broken. Windows took broken to new levels. And every "new" OS is a copy of broken written in fad language du jor; e.g. Redox OS. You want a sane computing platform built by hackers for hackers? Run plan 9.