1. 58

I would love to hear community input on the tools that they have been using to save there time and be more productive.

How a tool made you productive/saved time and what made you pick that tool.

  1. 60


    Take the time to take a step back, think about what you’re doing, and why. Don’t assign the PR you finished right away, but give it some time, let it linger, and see if later you can make it simpler. Don’t pick the first solution you came up with, but take some time to think about other options. In my experience, any other optimizations you make dwarf in comparison.

    1. 17

      Don’t assign the PR you finished right away, but give it some time, let it linger, and see if later you can make it simpler.

      Reviewing a PR yourself before assigning a reviewer can save you so much time and embarrassment.

      1. 5

        Alternatively, set up a work in progress PR as soon as you branch, so that you can get incremental feedback in small bites along the way. It’s way easier to deal with than a deluge of comments at the end of the process.

      2. 3

        Yes! The most powerful time for me is right before falling asleep. Last night, I came up with the perfect phrasing for an email I was having trouble writing and a solution for creating a moveable player in my game with a cellular automaton. It’s practically magic what a little background processing lets you achieve.

      3. 36

        magit, a git porcelain for emacs. It’s reason enough to be using Emacs, if for nothing else, imho (of course you benefit if you also use emacs for other stuff). I’ve seen my share of git GUIs and most of them are extremely clunky, require a mouse, and support maybe 10% of git, so as soon as you don’t just need to git add; git commit; git push you need to fall back to the cli. Magit offers a extremely consistent and powerful UI. You can easily manage multiple remotes, rebase, cherry pick, stash, reset, etc. And while the git cli has improved drastically in terms of consistency and usability, for some things it’s just so much faster to have a graphical UI.

        Disclaimer: I’ve only used Magit as configured with spacemacs. The vanilla Emacs version might have slightly different keybindings, but the overall point still stands.

        1. 6

          I find magit especially powerful because it’s context aware.

          Want git log for a file? Just M-x magit-log with that file open, and it will default to the right options.

          Want to check a file on a different branch? M-x magit-find-file allows you to open any file on any commit without having to switch branches.

          Not to mention that you can hook up your VCS provider like Github as well, and get things like “checkout this PR” with a few key presses.

          All of these are available outside of magit, but require much more setup, which isn’t worth it for the odd command you run every couple of weeks.

          1. 2

            Want git log for a file? Just M-x magit-log with that file open, and it will default to the right options.

            I’ve always just used magit-status, so I’m not sure, but I don’t have a magit-log command on my system…

            1. 4

              Definitely exists on mine, along with almost 500 other commands starting with magit-. I’ve noticed that magit is incredibly context-aware if you run commands directly from file-buffers, and often does exactly what I want it to do.

              1. 2

                Ah, I found it, but it’s an obsolete command:

                magit-log is an alias for ‘magit-log-other’ in ‘magit-obsolete.el’.
                (magit-log REVS &optional ARGS FILES)
                This function is obsolete since Magit 2.90.0;
                use ‘magit-log-other’ instead.

                which is probably why I couldn’t find it at first.

                1. 1

                  I believe this is what I’m calling.

          2. 4

            Or just ediff-merge, even without magit (I used it with psvn mode as well, for example). That thing is awesome and I can’t imagine how I ever got by merging manually by opening a file with conflict markers.

            For those not in the know: you get three buffer panels. One is version A (your version), the other is version B (the version you’re merging into yours) and the third is the final file. Then you can flip through conflicted sections and choose A or B, and when you’re confused you can overlay the ancestor on the merged buffer so you can see what has changed. There are dedicated tools like meld which do more or less the same (though I find meld’s specific UI rather confusing), but having everything inside your nice editor just makes it that much nicer (because you sometimes end up making tweaks in the merged version).

          3. 30
            • entr(1) watches files and runs commands when they change.
            • expect allows you to script CLI tools that don’t have scripting interfaces.
            • rofi is like dmenu on steroids.
            • vipe edits data in shell pipelines.
            • strace and ltrace help debugging.
            • autojump jumps to frequently-visited directories by partial name match.
            • rsync semi-intelligently synchronizes files between places (usually over a network).
            • mosh is more robust than SSH over unreliable connections.
            • xcape allows you to bind modifier keys to act as other keys when pressed on their own.
            • …and emacs, because of how flexible the editing core is (partially due to elisp), and how many extensions and enhancements people have made to it.
              • spacemacs is an amazing starter kit that gives you, among other things…
              • helm, which incrementally completes and narrows selections from a list, and can be hooked in to many emacs text prompts
              • recentf (builtin), which remembers which files you’ve recently opened. helm can complete recentf files, meaning that you only have to find the location of a file the first time you open it, and then after than you only need to type part of its name into helm’d recentf and it’ll bring it up for you.
              • magit which has already been mentioned several times as an amazing git interface.
              • avy which allows you to visually select things using a tree of keystrokes (e.g. you have 4 panes open in emacs, use asdf to select, or you have 120 vertical lines, use [a-z] twice to select one).
              • evil gives you vim-like editing.
              • which-key visually displays keybindings so you don’t have to memorize them.
              • slime is an amazing development environment for Common Lisp which has some rare and useful features. I personally am a huge fan of the debugger and inspector (which, from what I have seen, is a relatively rare tool) both.
              • tramp transparently edits files on a remote machine using your local emacs.
              • a client/server architecture (builtin) that enables you to start up emacs once as a daemon and quickly attach windows to it.
              • undo-tree gives you tree-style undo/redo and a visualizer to match.
              • paredit which is mostly-structured editing of s-expressions - the most usable thing approximating a code structure editor that anyone has at the moment…
              • hydra allows you to group together sequences of key-chords and make them somewhat more ergonomic.

            All of these tools have made an impact on my productivity, saved me time, or both. Some of them don’t necessarily save time, even over a long period of use, but instead make you more productive by making your programming experience smoother and more flow-like.

            1. 1

              Great that you mentioned mosh, I do really like that for saving me time by giving me a more stable mobile logon

              1. 1


                Thanks a bunch! I did not know about it. And it is really awesome, especially since I always found traditional undo-redo in Emacs a bit clunky.

              2. 21

                Perhaps one of the biggest things worth mentioning here (other than the standard: Vim, ag, LSP, etc.) is gofmt.

                gofmt takes any valid Go source code and formats it. One of the benefits of this is that it eliminates low-value discussions about where to place braces, spaces, and all of that, but another huge benefit is that it’s quite a productivity win.

                Before, I would manually muck about to get the indentation, spacing, and all these thing correct. Now? I just write if foo == "" { return } on a single line and let gofmt take care of it. This is especially a massive benefit when you copy/paste some code and the indentation is off, or you eliminate/add an if, and so forth. gofmt will just take care of all of that.

                goimports does gofmt and also takes care of adding/removing imports; fmt.Println("DEBUG", v), write, and it adds import "fmt" automatically (and removes it again when the line is removed).

                There are similar tools for other languages; I encourage you to check it out if you haven’t; I never thought I would like it so much until I started using it (“real programmers just get the indentation correct on their own and don’t need a tool!”)

                1. 2

                  Perhaps one of the biggest things worth mentioning here (other than the standard: Vim, ag, LSP, etc.) is gofmt.

                  Clang-format does the same thing for [Objective-]C[++] codebases. One of the biggest productivity wins is not just using it, but integrating it with the build system and with CI. I’ve recently started doing this with a few projects so that there is a clangformat target that applies the formatting to all source files. CI builds that target one each PR and if it produces a diff then this CI step fails with a message asking the submitter to build with the clangformat target and then update the PR.

                  This means that no human needs to either look for minor style nits, or fix them, during the code review process. You can’t quite represent my preferred style with clang-format, but it’s close enough. Now code review can focus on the important style issues, such as consistent naming in APIs, rather than the trivial ones.

                  1. 5

                    We do an equivalent at work with prettier formatting typescript. I’ve thing I’ve found is that it feels much nicer to have auto formatting on save in my text editor as well as in CI.

                    1. 2

                      The unfortunate thing about clang-format is that you can configure the formatter any way you like. At a large company, you can end up with a huge number of repositories and teams, each with different .clang-format configurations. Unless there’s outside pressure to decide which configuration to go with, you might end up in endless debates over which format is The Best.

                      Go has the beauty of having One True Format™

                      1. 2

                        That doesn’t really bother me, as long as it’s integrated into the build system and CI pipeline: I write without paying attention to it and then reformat the code before I commit. It’s a slightly higher cognitive load than having a single format, but the go style makes several decisions that are the opposite of what you’d get if a cognitive psychologist had been involved in any part of the process, so I prefer having the option to make the right choice some times than having to always make the wrong choice.

                        That said, in my ideal world, there would be no global layout style: the revision control system would store an AST and it would be up to the reader how to typeset it. Having a per-project clang-format style is pretty close to this: in theory, I can apply my own preferred style on checkout and then the project’s style before I commit a patch. I’d love to see better tooling around this.

                        Some years ago, I had a student work on a project called Code Editing in Local Style (CELS), which he presented in EuroLLVM in Paris. It did a lot more trivial reformattings than clang-format (for example, it could have variables declared at the start of a function or at their minimal scope, could handle tabs-for-indent-spaces-for-alignment style, could switch variables of different kinds between conventions like underscore_separated or camelCase, and implemented the TeX line breaking algorithm with weights for badness). I’d love to see that part of a normal editing workflow.

                    2. 2

                      I absolutely agree. I used those tools so often that I just threw them into my vimrc:

                      autocmd VimLeave *.go :!go fmt %
                      autocmd VimLeave *.go :!goimports -w %
                    3. 21


                      I initially picked it as a text editor, and then found that each new task I brought into Emacs got more efficient, benefiting from a) my familiarity with the editor accelerators, b) integration with the rest of my Emacs based toolchain, c) blindingly fast performance on even ancient hardware, d) programmability via Emacs Lisp.

                      Some key packages:

                      Orgmode (http://orgmode.org). Organise your life - or at the very least your work - all inside Emacs. org-present lets you use Orgmode files as slides, and org-present-remote (which I wrote) presents a mobile friendly Web interface to control Orgmode slides from your phone.

                      Mu4e (https://www.djcbsoftware.nl/code/mu/mu4e.html). Manage all your email in Emacs. Includes a handy HTML to text rendering feature.

                      SLIME (https://github.com/slime/slime). Having programmed commercially for two decades in C, Perl, C#, Ruby, Java, JavaScript (and CoffeeScript), Clojure, and VBA in a wide range of editors and IDEs, I’m happy saying SLIME is my favourite. Now I’m “post-technical” (contracting as an engineering manager and technical product manager, entirely off the tools) I only program recreationally, and SLIME and Common Lisp on Emacs are my go-to tools.

                      Multi-term (https://github.com/manateelazycat/Multi-term). Almost (I’m looking at you, dpkg) all CLI tools run happily inside terminals inside Emacs, all managed with multi-term. This also allows easy scripting of terminal sessions in, of course, Emacs Lisp.

                      Elfeed (https://github.com/skeeto/elfeed). A fully featured RSS/Atom feed reader inside Emacs.

                      ERC (https://www.gnu.org/software/emacs/manual/html_mono/erc.html). An IRC client for Emacs. Now built in.

                      The joy of doing everything in Emacs is how seamless and easy it is. For example, if you have an email open and want to create an Orgmode TODO linking to it, that’s just one keyboard shortcut away.

                      Next up, I’m planning to move my Slack (yech, ptooey) workflows into Emacs with slack.el (https://github.com/yuya373/emacs-slack).

                      edit: Oh, nearly forgot Magit (https://magit.vc/). I’ve used a bunch of Git UIs and this is the only one I rate as better than the CLI. It departs from Emacs’ usual approach of abstracting SCM details, but in so doing exposes all the power of Git.

                      edit: Oh, and Emacs runs anywhere. I have the same Emacs config running on my client-issued Mac, my personal ThinkPad W540, an ancient ThinkPad R51 which I love for writing because of the 4:3 screen, several Raspberry Pis, a few EC2 instances, my phone (a PinePhone), and in the past MS Windows boxen too. Running locally or over SSH in console, It Just Works.

                      1. 5


                        Sorry to plug my own thing, but I wrote sane-term[0] in response to multi-term clobbering keybindings years back. Its about 1/10 the code size and it cycles terminal windows, which is all I wanted out of multi-term.

                        Otherwise our setups are similar.

                        [0] https://github.com/adamrt/sane-term/

                        1. 4

                          Plug away, that’s how people learn about new tools :) I’ll take a look, thanks.

                        2. 3

                          Looking at the tools you are using now makes me wanna try them out :) I haven’t really tried emacs but now I might

                          1. 1

                            Enjoy it :). And if you’re after help, check out the Emacs IRC channel on Freenode and the Emacs Stack Exchange.

                        3. 14

                          I write a lot so one tool that has made me more productive and saved me time from distractions is GhostWriter. I’m on Linux so use it on Linux but I believe it’s available on other platforms too.

                          It’s a very simple, open source and lightweight writing application. There are not too many bells and whistles. I open it up in the full screen mode with the dark theme on and start writing.

                          Couple of interesting features are the distraction free mode and the Hemingway mode. Distraction free mode simply highlights the current text you are focused on while everything else fades into the background. Hemingway mode disables the delete key so you can avoid editing and keep on writing.

                          1. 4

                            Similarly I just discovered a new markdown editor and a new thumbnail maker. They work in the browser and are open source.

                            1. 2

                              Thanks for sharing!

                          2. 13

                            Emacs is a great tool that has at least made me feel more productive while I’m using it. In reality, it’s probably made me less productive since I spend so much time telling myself that modifying my init.el is a productive use of my time.

                            1. 9

                              The way I defend yak-shaving is that after some time I arrive at a very stable framework where all I do is minor tweaks taking a minute here or there. I’ve been watching colleagues migrate from Textmate to Sublime to Atom to VSCode, spending a lot of time on initial setup every time. I’ll always be yak-shaving editor config, but with Emacs I’m confident that the editor is still around in 20 years, which I can’t say about many other tools.

                              1. 4

                                That’s pretty much my justification too. Having said that, the more that I strip things away from my configuration, the more I realise that for the most part Emacs works very well without much in the way of extensions. There are only a few things that I change these days, and code-wise my init.el comes in at under 200 lines of code. Admittedly this is still quite a bit but as you say for something that suits me and is going to be around for a long time, it’s a good deal.

                            2. 13

                              Off the top of my head:

                              • Statistical control charts (a.k.a. process behaviour charts). I have a tiny JavaScript file that takes a numeric series and plots it onto an XmR (a.k.a. individuals) chart. I use it for double-checking everything these days.

                              • Perl 5. As long as I’m dealing with plain text, there’s no faster way to go from hypothesis to theory on any server.

                              • Good headphones. What makes an open-plan office survivable for me.

                              • Reading a lot about how they do things in engineering/scientific fields different from mine. There’s a lot of untapped knowledge as soon as you start thinking across field boundaries.

                              1. 4

                                Statistical control charts (a.k.a. process behaviour charts). I have a tiny JavaScript file that takes a numeric series and plots it onto an XmR (a.k.a. individuals) chart. I use it for double-checking everything these days.

                                Based on your other comment, you seem to be well versed with statistical process control. What would be a good resource for learning?

                                1. 5

                                  Specifically in terms of control charts, there is a wealth of information and corrections to common misconceptions written by Wheeler made freely available at the Quailty Digest website (the only catch is you have to sign up for an account). Without this treasure trove, I wouldn’t have known nearly enough to apply them efficiently now. https://www.qualitydigest.com/read/content_by_author/12852

                                  For more general context, I’ll repeat my suggestion to read the books by Deming, and Shewhart. No particular book recommended: they’re all good and cover generally the same things except with slightly different perspectives (which makes it useful to read all of them, but not necessary to get an idea of the concepts involved.)

                                2. 1

                                  Reading a lot about how they do things in engineering/scientific fields different from mine. There’s a lot of untapped knowledge as soon as you start thinking across field boundaries.

                                  any books/blogs you’d recommend?

                                  1. 4

                                    Too numerous to be specific, but things I’ve had use for include:

                                    • queuing theory from telecom (but careful! subscriber arrival rates and service times may be poisson/exponential, but open systems may be better modeled as lognormal – or better yet, with a histogram of actual observations.)

                                    • sequence homology from bioinformatics

                                    • human interface design from military systems (DoD design criteria are an example of a book here)

                                    • system failure analysis from avionics (not avionics-based, but Leveson writes well about this)

                                    • (obviously) statistical process control from manufacturing (all three of Deming, Shewhart, and Wheeler)

                                    • digital signal processing from electronic music

                                    • conducting effective trials from medicine

                                    • conciseness from fiction writing (Palahniuk, Hemingway, and King are inspirational)

                                    • system analysis from environmental science (donatella meadows is one place to start)

                                    1. 1

                                      Oh we have same interests, thanks for the pointers i’ll follow up on these!

                                      • system analysis from environmental science (donatella meadows is one place to start)

                                      Read this last year, now finding papers by Russel Ackoff. this is a good place to start

                                3. 12

                                  Using a single monitor.

                                  1. 2

                                    I’ve always been of the opinion that multiple monitors don’t make sense. I only look at one monitor at a time anyway, and I can set up my window manager to allow me to switch between workspaces on that monitor with less effort than it takes me to yaw my head.

                                    A well configured single-monitor setup is essentially a multi-monitor setup except all monitors are virtual and materialise right in front of you instead of being stuck to your sides.

                                    That said, I have been forced to use macOS at work for a while now, for which multiple monitors was more convenient. I switched back to Linux and a proper window manager now while working from home, so we’ll see what happens when I get back to the office.

                                    1. 2

                                      I’m using i3, so it’s basically a single key press for me to switch workspaces, and I’m still super happy to have a dual monitor setup.

                                      While it might take the same time to switch workspaces by pressing a key instead of turning your head (I highly doubt that btw) it still makes a difference in terms of cognitive load, because looking around is much more natural than pressing a button. It’s just the way our little monkey brains are wired. With the other workspace you sort of have to be aware that it’s there and actively switch to it (even when you’ve internalized it and built muscle memory). The 2nd monitor is still always in your peripheral vision, you can’t really forget it’s there.

                                      I think you can draw an analogy between the dual monitor setup and the “no modes” philosophy of Larry Tesler. With the dual monitors there are no modes and everything is present at all times. With one monitor you have to repeatedly switch to “2nd workspace mode” (and I say that as a huge fan of vim).

                                      I have one monitor in portrait mode and the other in landscape. Its really helpful to keep my editor on one monitor and my browser with documentation on the other. Or now for video calls I keep the call on fullscreen on one monitor and use the other to take notes and look up stuff.

                                      1. 2

                                        There’s a cognitive difference between having two monitors and one, though - they’re in physically different spaces, and the brain pays attention to geometry and positioning.

                                        I’m not sure if this particular effect applies to anyone, but in my case, it feels like my brain prefers that I keep two windows in physically different spaces (different monitors) rather than “in the same space”, overlapping and being switched via alt-tab. Is this just me?

                                        1. 1

                                          Well, switching applications with alt-tab is nothing like having multiple workspaces set up for quick switching. If all I had was alt-tab, I would also want multiple monitors (and indeed this was the case when I was stuck on macOS.)

                                          For one thing, alt-tab forces you to cycle through all applications, which is the biggest time kill.

                                          Second, alt-tab does not actually do anything until you’ve released the modifier key. That’s a long-ass time to spend on context switching. You would want your workspaces to be set up such that the switch happens as soon as you press the corresponding key, not when you release the modifier.

                                          Third, workspaces are different from individual applications. Workspaces are entire configurations of windows, much like multiple monitors give you.

                                          Fourth, in case it wasn’t obvious at this point: it needs to be really fucking fast. Faster then you can yaw your head. I haven’t tried to clock my workspace switching, but I know if I hold down the “previous workspace” key, it toggles back and forth between the last two workspaces and successfully renders both alternately. Autorepeat rate for my keyboard is set to 25, so switching definitely happens in less than 1000/25 = 40 ms.

                                          Alt-tab cycling on a single workspace is nothing like switching directly and quickly to a screenful window configuration.

                                          1. 2

                                            I’m not 100% sure, but based on some things you’ve said (“instead of being stuck to your sides” and “alt-tab forces you to cycle through all applications” in particular) suggest you aren’t using a tool that makes efficient use of multiple monitors. On Linux, this is understandable, because many of the Free Desktop standards (ICCCM and EWMH) are really inflexible when it comes to multiple monitors. And AFAIK, there’s been virtually no evolution in this space. The only way to make it better is to break the EWMH spec in a couple key places.

                                            In particular, window managers like the one found in GNOME are just absolutely abysmal IMO when it comes to multiple monitors. So much so, that a lot of their advantages are negated for my own workflow. The main problem is that you can only view one workspace at a time and each workspace covers all monitors. That is precisely the model that is enforced by EWMH. A much better model, IMO, is to have one workspace on each monitor with the ability to pull any workspace to any monitor you want. From there, is naturally follows that alt-tab should be among applications on a single workspace, which in this new model, will just be among applications on the currently focused monitor.

                                            This is exactly what motivated me to spend a couple years of my life building WIngo.

                                            When I’m forced to use GNOME, then I hack around some of its limitations with scripts. This one, for example, makes it easy to switch focus between monitors while respecting the relative stacking order of windows on each monitor.

                                            It’s really a pity what EWMH has done to multi-monitor support on Linux. It’s really held it back from being a lot better than it is today.

                                            1. 1

                                              Yes, you misread my comment. It was in reference to the comment above that, where someone explained how they find alt-tab insufficient on a single monitor, which I agree with. Multiple monitors never even entered the discussion!

                                              That said, I appreciate that you shared the information. I agree with most (if not all) of it, and this is also the reason I’m running XMonad, which handles workspaces in a non-EWMH compliant way too. (Maybe even very similarly to Wingo?)

                                              1. 2

                                                Ah sorry about that. I thought I might, hence the hedging. :)

                                                And indeed. XMonad’s handling of multiple monitors is what directly inspired Wingo’s model!

                                                I have fond memories of learning Haskell back in the day just to configure XMonad. Good times.

                                            2. 1

                                              My point doesn’t have anything to do with alt-tab in particular, though - it has to do with mapping different windows to different physical spaces. Workspaces, like you described, still have exactly the same problem - if anything, they make the problem worse, because now you have several different workspaces overlapping the same physical space, and then several different windows per virtual workspace. Additionally, my point is about total cognitive effect, not just the physical speed of whatever method you use to switch windows versus turning your head.

                                        2. 1

                                          I wanted to save some bucks on my electrecity bill so I switched to a single low-power monitor (nothing fancy, just a 22”) from a 3-screens setup + 1 laptop. And, honestly, this new setup is fine. I use Gnome 3 with the “Activities” button to switch between apps, and it works surprisingly well for me (I do programming, mainly).

                                          I have some theories, but I can’t explain why the single monitor setup works so well.

                                          1. 2

                                            I’ve found it to be a good approach for better focus. Also it makes it easier to transition from office to train - I’m not finding the lack of multimonitor a weakness.

                                            Not that train travel is relevant at this moment in time of course!

                                            1. 2

                                              How much electricity do you really save by switching from 3 monitors to one? I mean, electronics tend to be less power consuming than stuff like showers, heating, lights (if not LED), fridge, etc.

                                            2. 1

                                              Here in home office, I miss the second monitor at work. The big thing is remote meetings: With two monitors I can present one and prepare something on the other. With one monitor everybody sees me scrolling through my mails. It isn’t about privacy but about the distraction. Fortunately, confidentially is not that big a topic on my level.

                                            3. 20


                                              1. 1

                                                haha Agreed. It gives you a boost

                                              2. 11

                                                For server management: Ansible. I used to build “snowflake” servers, which seemed easier. Until I needed to change providers or upgrade the servers, and ended up spending hours reconfiguring everything from scratch, badly.

                                                1. 2

                                                  Did you evaluate any alternatives to Ansible? I love configuration management, but I can’t help thinking sometimes that maybe ansible, specifically, with its sharp corners, inconsistencies, misfeatures, and YAML might almost take longer than just setting it up manually.

                                                  1. 3

                                                    I love Ansible but I hate Python (relevant XKCD). I’d love to see a faster, more modern competitor written in Go or Rust or something.

                                                    People complain about YAML, but what do you want instead? JSON, with no comments? TOML? I’m unaware of a clearly superior YAML alternative. I think a reimplementation of Ansible in Rust that was 100% compatible with my existing playbooks would hit the spot.

                                                    1. 3

                                                      CFEngine is my go-to solution that is both fast and modern (whatever that means.)

                                                      Another superior alternative to YAML is Dhall. (I’ve even thought about compiling a set of Dhall files to a single, big, hard-coded Ansible playbook, just to avoid having to deal with the ambiguities of YAML.)

                                                      1. 3

                                                        I’d love to see a faster, more modern competitor written in Go or Rust or something.

                                                        Ansible mostly works by sending python programs to the target server and running them there. I’m not sure how you could make that work with a compiled language. Perhaps you could generate shell scripts and run those there? But then your requirement of “faster, more modern” might be at risk :)

                                                        I’m unaware of a clearly superior YAML alternative.

                                                        1. 1

                                                          You’re quite right, I realized this some time after I posted… I didn’t think very hard about the specific languages I suggested. Those are fun languages but maybe not ideal for Ansible’s use case.

                                                          Are there any interpreted languages you like better than Python?

                                                          Obviously part of why Ansible uses Python is because Python is installed by default on most Linux systems, so you can start running Ansible plays without installing anything at all on the target host. A more obscure language would be worse for that purpose.

                                                          But let’s imagine that you are Google or someone with the resources to make your favored language popular. What interpreted language could improve on Python?

                                                          1. 2

                                                            Common Lisp is probably the one that can beat Python, but that of course has significant learning hurdles for most people. CLISP’s installed size is 17.6MB on Arch Linux, SBCL 58.8MB and python 80.7MB. The comparison is a bit unfair since python has more batteries (many of which are important for Ansible!) out-of-the-box, but perhaps shows that including a Common Lisp into distros by default wouldn’t be totally absurd.

                                                            1. 1

                                                              including a Common Lisp into distros by default wouldn’t be totally absurd.

                                                              I’m assuming SBCL is free/open/libre? My impression of the Common Lisp ecosystem is that it’s a morass of licensing issues.

                                                              1. 1

                                                                Seems to be Public Domain / BSD, with 4 copyright notices: https://sourceforge.net/p/sbcl/sbcl/ci/master/tree/COPYING

                                                        2. 2

                                                          People complain about YAML, but what do you want instead? JSON, with no comments? TOML? I’m unaware of a clearly superior YAML alternative.

                                                          I’m using Nix with NixOS. As a language Nix is not necessarily better than YAML, in fact it has a pretty confusing syntax imho and has suffered from its success, because you can’t change it. It never was a very good case of programming language design, but it is an excellent tool for package management, state management and deployment/orchestration, because of the overall system design.

                                                          I would love to use Guix, which uses the same basic model of declarative package management/state management, but uses Guile Scheme for all configuration management and packaging. But the Guix community is even smaller (NixOS is already pretty niche) and there are way fewer packages.

                                                        3. 2

                                                          Maybe mgmt ? Not quite as feature rich yet….

                                                          1. 1

                                                            Thanks for the tip! It’s a different design than Ansible, and I’ll have to research it more to see how I feel about that, but it looks like what I was asking for.

                                                          2. 1

                                                            I’ve also used Puppet, which is more demanding about using the tool properly. Ansible OTOH feels like a fancy bash script, with all of the upsides and downsides of that.

                                                        4. 9

                                                          I’ve been using Bash (and some Node) extensively on my system in combination with Argos to automate many tasks:

                                                          • Piping connections to databases at work
                                                          • Doing simple maintenance tasks for users
                                                          • A script that writes Stripe test cards wired to a hotkey
                                                          • Checking what’s my lunch today (We order food to a company that delivers it every morning at work. Their website is pretty bad so I made a web scrapper in Node that is used as a CLI, just writting menu returns my lunch)
                                                          • Switching from Dual Screen to Single Screen configuration and the other way around (Because CS:GO)
                                                          • And many more.
                                                          1. 8

                                                            Since everybody already said things like vim, git, etc. here’s a couple that are that are more obscure:

                                                            • AutoHotKey: it’s basically “shell for GUIs”. I have scripts to format my clipboard into markdown links, to write math on my keyboard, to reopen webpages in sci-hub, to fast switch between windows, to control apps through my slideshow clicker… AutoHotKey is what makes the computer mine.

                                                            • Dragon: voice to text software. I do a lot of writing for my work and can speak much faster than I can type. With Dragon I can easily write 3-4000 words a day without it feeling like I’ve drained my blood out. It’s not perfect, and I still need to spend a lot of time editing the words, but it makes the first phase of writing so, so much easier.

                                                            • Frink: a programming language designed for physical calculations and unit conversions. It has first-class syntax for doing things like converting between time zones and setting base units. Want output all distances in feet per acres? No problem! I use it as a supercalculator.

                                                            EDIT: Ooh, forgot: beamer! A LaTeX package for making slide decks. LaTeX is a nightmare to learn but I don’t care being able to find-replace across all your slides is a game changer.

                                                            1. 1

                                                              EDIT: Ooh, forgot: beamer! A LaTeX package for making slide decks. LaTeX is a nightmare to learn but I don’t care being able to find-replace across all your slides is a game changer.

                                                              just finished writing a org presentation that exports to beamer. I hate it but love it. Latex is such a wonderful addiction

                                                              will immediately check frink, ty

                                                              1. 2

                                                                Have you tried org-present? It basically takes your level 1 headings and uses that as slide names. Everything underneath is shown in expanded form, and you can page through the “slides” using the arrow keys.

                                                                I’ve done a presentation with it once so far, but found it quite nice to use. It also means you don’t need to export, which saves effort and time, and you could easily switch to a live demo and back to your slides. It does assume you can use your own laptop, of course (a PDF would be more “portable”).

                                                            2. 7

                                                              What made me more productive is not a tool but a realization that I’m not cut for this productivity cult that permeates our industry. I’m tired of the grind, of people thinking that you need to work long hours, manage a mailing list, make posts in your blog to amaze even Knuth, and be a founder of 100+ JS framework communities, while baking at home. I’m not a robot, if there are people who work faster than I do and do more than I do, that’s OK. I’ll work on my own speed, I’ll have my slow mornings with coffee and reading, I’ll not work my ass out just because someone how employs me thinks they are the next steve jobs.

                                                              And because of that, I’m doing more things for me. They are completed slowly but they are moving.

                                                              1. 7

                                                                Intellij IDEA (for typescript and Java in my case) with its “structural/logical” refactoring, instead of search-replace through vim, sed and other cli tools, made me put another level on trust in my tools. “Only change the variable in this scope” (ast/comment aware) , “extract method” or “remove this parameter from a function” tools that adjust all call sites etc, makes me happier :) (This is paired with a new project, so not many worries with legacy Java). Oh, and auto completion for sql queries when joining five tables doesn’t hurt either. I feel like I’m so late to the party here.

                                                                I am also an Emacs noob, but org-mode and org-babel keeps me on top of planning. Having templates for small shell scripts, REST calls and sql queries, with inlined and exportable results is amazing, compared to lots of stray shell scripts as files.

                                                                Does ‘using typed languages’ count?

                                                                1. 7

                                                                  The tools I use the most without even thinking about them are dmenu, and its CLI, fuzzy-finding friend, pick.

                                                                  I use them for everything, from spawning programs, yanking passwords or prompting FQDN for ssh/RDP connections. They fit extremely well as selectors in a pipeline, without disrupting it at all.

                                                                  1. 7

                                                                    It’s been many years I extensively used Ruby instead of shellscripts. A bit verbose for the most common tasks, but very fine control instead of grepping/awking/sedding/cutting. Does it count?

                                                                    1. 7
                                                                      • jq - “lightweight and flexible command-line JSON processor”, super useful when working with json APIs
                                                                      • dependabot - get dependency update PRs automatically
                                                                      • trello - I use a separate boards for all kinds of things, from software side projects to keeping track of things I have to do when moving for example.
                                                                      1. 7

                                                                        disconnecting from the internet, on my desktop, physically unplugging the ethernet cable

                                                                        1. 6

                                                                          A couple more general tools that save me lots of time:

                                                                          1. Session Buddy. This thing is a godsend. When I’m working on a project, I’ll often end up with 20+ Chrome tabs open for various searches I’ve made and documentation I’m reading. Session Buddy lets you save and label browsing sessions and reopen entire groups of tabs with one click. Now when I’m wrapping up for the day but don’t want to waste time tracking down all my online resources, I can save the session and reopen it later. It also autosaves your sessions, so if your machine crashes you can resume browsing after recovery.
                                                                          2. Notion. This tool has been making a pretty big splash in the productivity software area for good reason. The abstractions that Notion provides for information are extremely powerful, letting you compose and transform how your information is laid out effortlessly. I use it for managing lots of aspects of my life, from my school assignments to blog posts to monthly budget. Also very useful is Notion’s Chrome extension, which I use to save links to a My Links page for later reading.
                                                                          1. 2

                                                                            Can you export the tabs’ URLs to a file for processing with a script? I have a need for that on Firefox. I’ll use Chrome for it if FF doesn’t have one.

                                                                            1. 3

                                                                              Yes! You can even select what type of data to export, and format as well (csv, JSON, Markdown, HTML, and raw text).

                                                                              1. 3

                                                                                I figured out how to do this recently (for a running FF session):

                                                                                lz4jsoncat ~/.mozilla/firefox/e2f5cani.default/sessionstore-backups/recovery.jsonlz4 | jq .windows[].tabs[].entries[-1].url

                                                                                (note that your session name under ~/.mozilla/firefox will probably be different)

                                                                                1. 1

                                                                                  what does this do ?

                                                                                  1. 1

                                                                                    Fetches the URLs for currently open tabs by spelunking through FireFox’s session backup files (i.e. how it remembers which tabs were open if it crashes).

                                                                                    The two tools used are lz4jsoncat (a tool for reading Mozilla lz4json files - it’s in the apt repos) and jq to filter out the relevant values.

                                                                                    1. 1

                                                                                      It didn’t see it in apt repos. However, this answer looks helpful. I’ll try it later on.

                                                                                2. 2

                                                                                  I haven’t used firefox for years, but IIRC there was a short cut that let you see the various tabs open and then group them and open just that group & a way to export to json.

                                                                                  One dream I’ve had was if a browsing session could be displayed visually as a tree, so you could navigate up and down and across the tree and you could see at a glance which browsing decisions were productive & which were distractions & the conceptual links between a various exploration / rabbit hole :)

                                                                              2. 5
                                                                                • Vim macros (As well as a bunch of other Vim things).
                                                                                • Back when I used to use Sublime Text the multicursor functionality was a significant time saver.
                                                                                • Soulver/Numi - Recently switched to Soulver from Numi but they essentially do the same thing. Fantastic for working out quick sums/costs with a programming-like syntax.
                                                                                • MailMate - My preferred Email client. Pretty much everything can be done via key commands, and I can create messages with an external editor which is handy, set emails to go out at specific times, and there’s a decent search as well.
                                                                                • Firefox + Multi-Account Containers extension. I have to switch between various accounts for stuff like Google Accounts/AWS for work so I don’t have to logout/login all of the time. Also, Firefox dev tools is pretty great.
                                                                                1. 2

                                                                                  Multi-Account Containers Extension Thanks for introduction to this extension. I definitely need it if it works as promised. Thank you!

                                                                                  1. 1

                                                                                    also temporary containers, works nicely together

                                                                                    1. 1

                                                                                      Ah something in sync with Multi-Account extension. Will give a try. Thank you!

                                                                                  2. 1

                                                                                    @mitchartemis : I’m really loving multi-account containers extension. Thanks for introducing it. Still figuring out how to open tabs using short cuts, sometime it works and sometimes not ( ctrl + period + 1, 2)

                                                                                    1. 2

                                                                                      I’m glad you’re finding it useful! To be honest I have not tried to use it with shortcuts (Although I know I should).

                                                                                      I’ve just had a look and you can use ctrl+. to open the extension modal and then use tab to choose the container. Not ideal but better than nothing. I’ve just noticed you probably know this from your comment. There’s a third party plugin that may help, although I have not used it myself - https://addons.mozilla.org/en-US/firefox/addon/easy-container-shortcuts/

                                                                                      One tip: You can hold the + icon next to your tabs and you’ll see the list of containers to open a new tab with as well.

                                                                                      1. 1

                                                                                        I’m finding Multi Account container extension from FF very useful. It seems Google Chrome is also coming with similar feature starting this week:https://www.theverge.com/2020/5/13/21257446/google-chome-tab-grouping-feature

                                                                                  3. 5

                                                                                    I have tried many TODO things over time and the one thing that I am sticking to is taskwarrior (https://taskwarrior.org/). It is super easy to pick up, yet it is a lot more powerful than todo.txt or other bare-bones systems. I used to be able to keep all tasks in my head, but I have a more coordinating role lately and I was getting a overwhelmed. Taskwarrior has been a great help so far.

                                                                                    The one thing I would change is their sync server. It uses client side SSL certs and requires quite a bit of setup. I opted out of that and I now use rclone to push a backup into my dropbox.

                                                                                    1. 5
                                                                                      • org-mode: I keep my thoughts, tasks, drafts, blog posts – everything here, it’s my organisational heaven

                                                                                      • mypy has made me enjoy Python and benefit from the best of both (static/dynamic) worlds

                                                                                      1. 2

                                                                                        is org-mode that good?
                                                                                        Is there a possibility to use it on ios/Ipad os?
                                                                                        What is with online sync and merging?

                                                                                        1. 4

                                                                                          is org-mode that good?

                                                                                          I’ve yet to encounter an ex-org-mode user, which is a pretty strong endorsement IMO.

                                                                                          You really need to be running emacs to use it, though, which has been too high a barrier for me so far (and ensures it won’t run on iOS).

                                                                                          1. 2

                                                                                            Now you have!

                                                                                            I never felt satisfied with org-mode because I found it too flexible - it was hard to know what the best way to do things was, and so I kept fiddling with my workflow rather than actually getting things done. I went through a few different tools, and settled on using Trello with a kanban-style workflow in 2018, which I can definitely say was a gamechanger for me.

                                                                                            1. 1

                                                                                              I’m using it on my Android with orgzly and it’s not so bad. Mostly only for adding new notes and searching (Emacs is superior in terms of organization), but it does most of what I expect from my org-mode files on the phone anyway.

                                                                                              Also there are peopel who run Emacs on the phone (not sure if you can do it on ios), so with an external keyboard it’s meant to be the same experience.

                                                                                            2. 1

                                                                                              AFAIK there are iOS apps, but extracting it out of Emacs kind of looses the point.

                                                                                              And it’s a text file, you can sync and merge is just like any other text file. Org is just the magic that interprets and manipulates the text.

                                                                                              1. 1

                                                                                                org is glorious. the IOS options aren’t too good, I jump between beorg and plain text edits via an text editor (buffer) when on mobile but neither is really there. Organice.200ok.ch/ comes very closer to what I’d think a good compromise would be but afaict is not a native app.

                                                                                            3. 5

                                                                                              At work, I spend a lot of time dealing with large, underdocumented codebases whose original developers are all long gone. Usually, these codebases are written in ‘good’ java style – which means that between any two pieces of meaningful code are ten or fifteen layers of abstraction (interface hierarchy, wrappers, converters, factories, whatever) intended to paper over limitations in Java’s language features or type system or something. So, the first thing I do when I’m asked to dive into a new codebase is run http://www.doxygen.nl/ with forward and reverse call graphs, in order to get a sense of the general organization of control flow. It’s big and bloated & setting it up involves editing a long config file and using it involves opening a web browser, but it’s still the lowest-effort way I’ve found to summarize one of these unnecessarily-giant projects & make it possible to jump into fixing things quickly.

                                                                                              Some of the most useful tools are pre-installed. I took the time to learn how to more effectively use awk & subshells, and now about 80% of my new code (both at work and at home) is shell scripting. Don’t underestimate what a shell one-liner can do. I’ve learned that, for any task, it is generally easier to prototype it as a small shell script than in any other language (and once prototyped, writing the ‘real version’ is a lot easier – if it needs to be done at all!)

                                                                                              I’ve got a variety of nice little tools of my own, which I use to increase productivity with regard to my leisure activities like social media use, music composition & production, and playing with language. Most of them are dumped here, though the music stuff is here. I also wrote some tooling for working with LaTeX, for the sake of making more professional-looking book manuscripts.

                                                                                              1. 2

                                                                                                Thank you for the Doxygen idea! If only it supported F# it would have been complete for my purposes. Either way it’s useful – I wrapped it in a shellscript that sets a bunch of useful defaults for enabling this reference tracking and call graph stuff, so now I can generate this type of thing on-demand for the bigger projects I poke at!

                                                                                              2. 3

                                                                                                git - for note taking and code versioning and config versioning
                                                                                                ipfs-deploy - to deploy my website on ipfs
                                                                                                github-actions - to start ipfs-deploy on commit to master

                                                                                                Working Copy - to write notes on my Ipad and commit it

                                                                                                ohh and VSCode and Vim

                                                                                                1. 1

                                                                                                  What’s ipfs

                                                                                                2. 3
                                                                                                  • Sublime Text, so great for handling repetitive and/or poorly formatted data/text files (not often but collapses time significantly)
                                                                                                    • Also the Table Viewer package is wonderful for handling/extracting from almost tabulated data that just won’t align
                                                                                                  • Shortcut Foo, simple rote memorization by practice tool but makes instant improvements for a lot of programs
                                                                                                  • Some kind of watch/auto-reload toolchain (e.g. --watch flags, LiveReload, watch command for low-tech seconds based version)
                                                                                                    • I wrote listen-spawn and a Sublime Text hook for on-save behavior but I believe there are other less bespoke standards out there (e.g. entr)
                                                                                                  1. 3

                                                                                                    We have this other article on the frontpage which says “you get the most increased productivity from identifying problems and the least from efficient implementation” Ironically, nobody here suggested any tool for identifying problems.

                                                                                                    1. 6

                                                                                                      Well if you want me to shill TLA+ and Alloy, I’m happy to :P

                                                                                                      More seriously, I find things like “having a whiteboard” and “taking meeting minutes” really good for identifying problems, which are more social and physical than technical.

                                                                                                      1. 1

                                                                                                        I agree with the article to the degree that you need to find the important problems. Finding some problem is easy but to assess the value of fixing them is hard. I guess the trick with TLA+ and Alloy is that you only apply them for important parts of your software.

                                                                                                        Meeting minutes can also be very valuable. However, I have seen lots of useless meeting minutes which are incomprehensible to outsider and usually to the participants one month later as well. I don’t know good writings about “good” meeting minutes.

                                                                                                    2. 3

                                                                                                      I have a tool I wrote for myself called clok, which is a command line punch clock. It saves the start/stop times for me working in a day, and does it in a low friction way, as well as giving me how many total hours I have worked today, and how many more, and what time, given no breaks, I’d be done.

                                                                                                      1. 2

                                                                                                        RR. RR is a debugger that lets you record a program’s execution. This means that if you’re encountering a hard-to-reproduce bug, you only need to be able to reproduce it once to start debugging it (instead of having to be able to reproduce it every time in GDB). The other killer-feature of RR is time-travel debugging. Set a breakpoint somewhere, discover that a variable doesn’t have the right value, set a watchpoint on that variable, ask RR to rewind the program until the watchpoint is encountered. Another great thing about RR is that you interact with it through GDB, so can keep all your GDB knowledge/habits and just add time travel on top.

                                                                                                        GDB has had time-travel features long before RR was created but it’s always been buggy and slow. RR is perfect and I can’t imagine debugging anything without it anymore.

                                                                                                        1. 2

                                                                                                          For front-end work: BrowserSync allows me to edit CSS/Sass live on a page, even preview on multiple devices at the same time. Instead of edit-save-rebuild-refresh cycle, I can have editor and browser(s) side by side, and see what I’m writing as I write it.

                                                                                                          1. 2

                                                                                                            As a Python programmer, I’d say flake8 is a big time saver for me. I run it (through a Vim shortcut) before running the interpreter. It tells me obvious errors such as syntax errors and undefined names before having to run my program.

                                                                                                            1. 1

                                                                                                              I never used flake8 even though I extensively program in python. I might give it a try

                                                                                                            2. 2

                                                                                                              Since people have already mentioned emacs and magit, I’ll share something a little more idiosyncratic:

                                                                                                              I have a bash history with a lot of suboptimal things like "make clean ISO && remote-install cluster5 && send-phone-notification "done" " etc. So I wrote a bash tool for saving frequently reused commands into a git repo of “snippets” that I can push and share around between systems. I use it very often. There’s more info in the README: https://github.com/mikemccracken/hs

                                                                                                              The other related thing that’s saved time in the past when I used to use fresh cloud images more often, is saving all my dotfiles in git using vcsh: https://github.com/RichiH/vcsh

                                                                                                              1. 2

                                                                                                                Where can I get this very useful-sounding send-phone-notification script?

                                                                                                                1. 2

                                                                                                                  It’s pretty custom and a little janky, but the basic idea is that it uses Prowl, an iOS app and service, via the official perl client (download ) - I have my personal apikey saved in the script, which looks basically like this:

                                                                                                                  echo "Sending notification: $msg";
                                                                                                                  ~/bin/prowl.pl -apikey=$MYKEY -event=CLI -application=CLI -notification "$msg";

                                                                                                                  so I tack that onto the end of long-running commands so I get the notification on my phone when it’s done and I can stop checking email or whatever I’ve been doing while I waited for the important thing to finish.

                                                                                                                  This has been really useful in keeping me productive, and I’ve used versions of it for years - here’s a blog post I wrote in 2008 about having X forwarding pop up a dzen notification on my local screen when something on a remote server is done. I like the phone notification better, because I can go make coffee and still be in touch.

                                                                                                              2. 2
                                                                                                                • Sublime Text - I’m still astonished at how fast it renders/scrolls.
                                                                                                                • Sublime Merge - my day job has a heavy rebase/commit split workflow, and Sublime Merge is a godsend when doing tricky interactive rebases.
                                                                                                                • autojump - as mentioned earlier. It’s one of the first things I install on a new workstation. I believe there are alternates such as z and fasd which you may want to check out.
                                                                                                                • Pull Reminders - I absolutely hate email notifications, and things like review requests or responses to comments usually get buried in my inbox. I also find the GitHub notification workflow suboptimal – I still have to click to archive notifications, which means they pile up, which means things get lost. By hooking up Pull Reminders to Slack I get notifications that I don’t have to click to archive. This has dramatically reduced my response time to PRs.
                                                                                                                • Pull Assigner - Automatic PR assignment has made reviews in a team go much smoother. Without this, I often find teams fall into bimodal patterns where a few people review everything and the other people don’t respond due to bystander effect.
                                                                                                                • mtr - A fantastic way to diagnose latency and packet loss issues in your network. I feel like it’s not as well known as it should be.
                                                                                                                • A “percentile latency” graph - I’m not sure if there is an official term for it, but a graph where the X axis is a percentile and the Y axis is latency. I first saw these in Gil Tene’s How Not to Measure Latency (summarized here) and was blown away – not only are they very effective at describing how a system operates in normal cases and at the limits, but you can directly lay your SLAs on top of them and see how much wiggle room you have before you’re in violation.
                                                                                                                • black and isort - mentioned otherwise in this submission, but a great way to focus more on the code instead of the style.
                                                                                                                1. 2

                                                                                                                  multimarkdown best markdown processor I’ve used. Quite conservative yet has a lot more features than standard markdown. Takes data from stdin and returns to stdout. Blazing fast. Automatically deals with tables of contents, combining multiple markdown files into one, referencing titles, footnotes, image attributes, etc etc.

                                                                                                                  redo best dependency build tool I’ve used. Very intuitive and simple once you “unlearn” Make. Very modular, with distinct rules for different file types living in different scripts. Language agnostic.

                                                                                                                  But the most productive thing I did has to be putting a stop to constantly fiddling with various config files like .vimrc, bashrc, etc. and learning to love the defaults.

                                                                                                                  1. 2

                                                                                                                    As I wrote recently in response to a very similar question here:

                                                                                                                    • in physical world, discbound notebooks
                                                                                                                      • on recommendation from a fellow lobste.rs user
                                                                                                                      • they let me not get lost in my paper notebook, find older info, and purge notes for finished tasks out of sight/mental context
                                                                                                                    • Firefox addons:
                                                                                                                      • Gesturefy (faster navigation with mouse)
                                                                                                                      • Tree Style Tabs (grouping tabs per ongoing task, and collapsing tabs for non-active tasks)
                                                                                                                    • a tool I wrote myself: Ultimate Plumber
                                                                                                                      • live-coding complex shell pipelines, exploring big text/data files
                                                                                                                      • inspired by Bret Victor’s talks (the guy’s talks have impressive impact on people)
                                                                                                                    • git log --graph --decorate --oneline --all
                                                                                                                      • to quickly orient myself in git history
                                                                                                                    1. 2

                                                                                                                      git log –graph –decorate –oneline –all

                                                                                                                      Git command is pretty sick

                                                                                                                    2. 1
                                                                                                                      • Learning to touch type, later realizing that sticking to US keyboard will give me peace of mind - started IT in Germany, then moved to France and traveled quite a bit. For accents/umlauts using AltGr International combinations
                                                                                                                      • Use VI commands everywhere I can (configuring shell and REPLs to VI mode)
                                                                                                                      • Unix command line with big history size, using available unix commands. Saved me a lot of time and made me more productive by combining tasks into commands and when in the end they are not optimized further and I still use them, I make a script. Still from time to time discovering new commands. Makes me happy.
                                                                                                                      • Emacs with org-mode and evil (VI emulation) to take work notes, clock time and make reports for invoices
                                                                                                                      • Haskell, for programs that do complicated enough things, where it makes sense to get the basis right and avoid mistakes. Made me as well much more humble about programming. As well I know that I will never end learning this language and it makes me happy. There is so much new research going on.
                                                                                                                      • git: works reliably and has solutions for weird work-flows
                                                                                                                      • screen: Discovered it late, a tool that has been around for many years, but I discovered it only when I was constrained to work on different servers. It’s often preinstalled. Now I use it even on the laptop, locally.
                                                                                                                      • Regression tests that can be automated.

                                                                                                                      Techniques that I learned only after I needed them and would have liked to know them earlier:

                                                                                                                      • Writing without seeing the text, i.e. same font and background color (black-on-black or white-on-white). Allows to “speak” out the mind in an intimate and honest way. Helps beautifully to calm down when in emotional stress.
                                                                                                                      • Meditation. Will not describe my impressions, because it has too many facets and the revelations are changing. But it was a precious discovery and gives me often a very nice road trip into myself and often helps to take decisions, unblock situations.
                                                                                                                      1. 1

                                                                                                                        I gave a talk on terminal tools that I can’t live without last year. if you’re interested, a recording is available here: https://youtu.be/hsf9FWT9-gY

                                                                                                                        I’ve seen some of them listed in the comments here, but there might be a few new ones.

                                                                                                                        1. 1


                                                                                                                          1. 1

                                                                                                                            These are my top three tools:

                                                                                                                            • Total Commander for file management.
                                                                                                                            • Ditto for clipboard management.
                                                                                                                            • SQLyog for database management.
                                                                                                                            1. 1

                                                                                                                              Fork is the best Git client ever, for Mac and Windows. It used to be free, but when it went to US$50 last month I paid immediately and sighed with relief that the devs now have a revenue stream and can continue working on it. It’s that good.

                                                                                                                              I’m sure most of you use the Git CLI. I used to. But a good GUI is so much more efficient, letting you scroll through revision trees and inspect diffs and interactively rebase without having to fill your mental working-set with a ton of details of commands and flags.

                                                                                                                              1. 1

                                                                                                                                I’ve been a big fan of GitKraken for the same reasons. Although there is a free version, the paying the license is absolutely worth it!