Ask HN: Which tools have made you a much better programmer? - <AUTHOR> Getting better at coding is usually a long, slow process of study and practice. However, sometimes I run into something that's easy to understand and, once I'm using it, feels like I've leveled up.
A few personal examples are:
* version control - specifically, reading up on git and understanding the more complex commands
* debuggers
* flame graphs for performance debugging
* good code search
What have you added to your workflow that's made you much more productive? <comment><USER5> \- GNU/Linux + i3wm; complete control over my programming environment.

\- bash + GNU coreutils; seriously, take the time to be able to write helpful bash scripts which can run basically anywhere.

\- git; use it even when you're not pushing to a remote. Add helpful aliases for everyday commands. Build a good mental model of commits and branches to help you through tough merges. ( my ~/.gitconfig: [https://gist.github.com/jeaye/950300ff8120950814879a46b796b3...](https://gist.github.com/jeaye/950300ff8120950814879a46b796b3c7) )

\- Regex; combined with bash and your GNU tools, a _lot_ can be done.

\- Vim; modal editing and vi-like navigation can blow open your mind. Explore the existing plugins to accomplish everything you want to be able to do. It's all there. ( my ~/.vimrc: [https://github.com/jeaye/vimrc](https://github.com/jeaye/vimrc) )

\- Functional programming; if you're new to this, start with Clojure, not one of the less-practical languages. This has made such a huge impact on the way I think about code, write code, and design code that it's possibly the biggest one here for me.

<comment> wing-_-nuts Re: i3wm

I installed it a couple years ago, went whole hog, down the rabbit hole, but realized a couple of things.

1\. I rarely ever use anything more than a simple L/R split.

2\. When I _do_ use something more complex, it's almost always in the terminal, in which case why not use tmux?

These days I'm back to using gnome because ubuntu switched to it over unity (which had a weird multitouch bug that drove me crazy).

What do you get out of i3 beyond a simple L/R split supported by simpler wms and how often do you use it?

<comment><USER6> While I do use i3 for more than L/R splits with stacking etc. the largest benefit I get from it is workspace management.

I use i3 with polybar and have dedicated workspace icons (web browser, terminal, editor, to-do, email, music, etc) for quick navigation between different applications. Over time I've built up muscle memory (i.e $Mod+3 will bring me to my editor) that has significantly sped up my development process. While you could use another window manager for a similar purpose, I find the relatively minimalist approach of i3 + polybar in my case to be fast and highly configurable.

<comment><USER7> I can echo this! This is exactly how I feel too - the muscle memory around workspace management and the scratch windows (floating windows that you can toggle in/out of visibility based on a single keystroke) are the real boosters for me rather than splits. Splits are useful but the most common use I've seen myself do is to have a browser and a terminal / editor in splits.

<comment><USER8> > T he scratch windows (floating windows that you can toggle in/out of > visibility based on a single keystroke

Us the toggle an i3 concept? I'm interested in it, can you give me the function name so I can look up doco? :)

<comment><USER9> Not GP but I think it's `scratchpad toggle` - scratchpad is the keyword to lookup anyway.

<comment><USER8> Thanks, interesting concept that has some valid applications :)

</comment></comment></comment></comment></comment></comment></comment><comment><USER10> The Jetbrains suite. Lightens the cognitive load, makes it easier to refactor and keep code tidy. All of which allow me build better software.

For almost everything else e.g. git, learning how to use the command line instead of a UI is the best way for me to learn how the tooling works.

<comment><USER11> Just downloaded the GoLand 30 day trail. First impressions are I now remember how slow and stuck in goo java based IDEs feel.

What cool stuff should I look at as I am willing to be sold on this.

<comment><USER12> Jetbrains offerings are quite fast. What are you comparing them to?

<comment><USER13> Probably Sublime text. It's just too fast and I can't switch to anything else. I open heavier ones like Eclipse, VS Code etc. only when I need to refactor.

<comment><USER14> I notice the same thing, and I enjoy IntelliJ / Sublime / Vim. IntelliJ often feels sluggish.

Maybe this could help: [https://blog.jetbrains.com/idea/2015/08/experimental- zero-la...](https://blog.jetbrains.com/idea/2015/08/experimental-zero-latency- typing-in-intellij-idea-15-eap/)

Here was a 3rd party analysis from 2015, showing a reduction in latency when editing XML files in IntelliJ IDEA from ~70ms with large jitter to 1.7ms with small jitter: [https://pavelfatin.com/typing-with- pleasure/#summary](https://pavelfatin.com/typing-with-pleasure/#summary)

I wonder if it's turned on by default today, 5 years later.

Some other techniques: [https://email@example.com/boosting-performance- of-inte...](https://email@example.com/boosting-performance-of-intellij- idea-and-the-rest-of-jetbrains-ides-cd34952bb978)

<comment><USER15> Seems like the IntelliJ zero latency typing is on by default since ~2017 releases.

[https://blog.jetbrains.com/idea/2016/12/intellij- idea-2017-1...](https://blog.jetbrains.com/idea/2016/12/intellij- idea-2017-1-eap-is-open/)

[https://blog.jetbrains.com/clion/2017/01/clion- starts-2017-1...](https://blog.jetbrains.com/clion/2017/01/clion- starts-2017-1-eap/#zero_latency)

</comment></comment></comment></comment></comment></comment><comment><USER16> That would easily be using an integrated REPL.

The more integrated it is (with your IDE/editor) the better the experience and productivity boost.

And the difference is quite large. When you are working with a language that has first class REPL support you start to

\- 'get' why Emacs exists

\- become faster at writing code in general

\- write much more experimental and open

\- become more motivated in testing smaller assumptions and _asking questions_ about your or other peoples code

With "first class support" there are three dimensions:

(1) The REPL and the editor/IDE have to be understand each other well.

(2) The language itself has to be malleable and (de-)compose well in terms of syntax and idioms.

(3) many things in the language are first class expressions or in other words: there is a high degree of tangibility in the language constructs.

Most dynamic languages have workable/decent support for REPL driven development so it is always worth testing out.

You find _excellent_ support in: Clojure (and of course other Lisps) and Julia from my experience.

<comment><USER17> My main responsibility is developing and maintaining a microservice written in Java.

However, one thing I've found invaluable over the years is developing operational tools to support my deployed code, in a language with a built in REPL.

At different times, I have used Clojure and Jython for this (high level way to call my Java libraries, or to invoke APIs over the network), and most recently Ruby (has been easy to deploy and run scripts or ad hoc commands over irb for operational tasks, in the same environments where my service runs).

This allows me to build up code over time that I can use to

* Quickly make calls to my service to triage or debug production issues.

* Write scripts to quickly validate a new install.

* Script operational tasks at a high level that doesn't make sense to build into the service itself (can allow the service to be more stateless, for example).

* Bypass layers and make calls to the underlying database (can be more powerful than the command line tools dedicated to a specific database).

* Can be more powerful and composable than curl or Postman for making web calls.

* Have used it to analyze the state of messages in a Kafka topic (with a custom gem).

So I highly recommend building a tool set around a language with a good REPL for anyone responsible for a service with a REST API, or any other kind of API available over a network.

<comment><USER18> Have you tried Groovy? Sounds kind of ideal if your main work is with Java. I have a BeakerX (JupyterLab+Groovy) notebook open pretty much continuously next to my IDE while I code so that I can validate all my assumptions as I code. A nice workflow is that you start with a snippet of experimental code, which you tidy up in the REPL, then it splits into the actual function and test code, one part going to the unit test and the other to the real code.

</comment></comment></comment><comment><USER19> Writing the overall design in plain English before writing the implementation. Not super detailed, but the main data structures and invariants and mechanisms that will make the implementation working. Then start the implementation refining such document as I discover new things.

<comment><USER20> This, most of all. Substitute native language if not English; the important thing is that the project be defined and developed in both a _human_ language and a computer language, so that mismatches can be identified and resolved.

      * Start by describing what you are trying to do.
        * Specifically.
        * Not 'build a web business to enable users to achieve their
          potential', not 'create another library for X but simpler'
          but *specifically what the software will do* and, most
          importantly, the priorities of scope increase (it'll happen
          anyway; just get the priorities and their order down in
          text ASAP).
        * Put it in a readme.txt or something.

      * For any given subsystem of the code (meaning: any section
        which can sort-of stand on its own) write another such file,
        in more detail.

      * Let these files guide your tests too.

      * Keep them up to date. If priorities change, *start* by
        updating the readmes. The code isn't immutable; nor is the
        plan. But the plan comes first.

      * When unsure how a new subsystem or feature is going to work,
        write out your ideas and thought processes in text. Don't
        start coding at all for a day or two after you sketch out the
        basics. *Append* to this file instead of replacing large
        parts.

[edit] Wasn't intended to quote that part (sorry to mobile users) but I can never remember how to get bulleted lists on this site...

<comment><USER21> Have any samples/examples you can share?

<comment><USER19> Things like that [https://gist.github.com/antirez/ae068f95c0d084891305](https://gist.github.com/antirez/ae068f95c0d084891305). Usually more detailed with data structures, but this one was a very conceptual thing.

</comment></comment></comment></comment><comment><USER22> Reading official documentation when working with new tools/frameworks.

Googling every hurdle as it comes & over relying on StackOverflow is neither effective nor satisfying. Some of the projects out there have amazing documentation (e.g. VueJS, Kafka). It's best to read the overview & skim high level stuff to understand the core components/principles/terminologies. It makes it so much easier & enjoyable to use those tools.

<comment><USER23> Why isn't this higher?

Give everything a good read before really working. You don't need to remember everything, but you need to know what's there so you don't wind up reinventing wheels, endlessly googling with the wrong search terms, or doing things people who use the tool correctly find inscrutable. It's so important.

I will note that this is much easier to do well when you're a more experienced engineer than it is when you're just starting out, but getting used to doing it and going back over docs when you do have more experience is the best way to get used to it.

<comment><USER24> I think the main problem with this approach is the all-or-nothing problem. When reading official docs is not always clear when you already have everything that you need. Reading the whole doc is usually not a possibility considering most modern tools have easily 100+ pages that go down the rabbit hole.

In short, good official documentation is scarce and time to read is even more so.

</comment></comment></comment><comment><USER25> For me, the transition from Bash to Zsh has been a huge efficiency boost. Mainly because of some great plugins for Zsh, such as z, zsh-peco-history (better history search), zsh-autosuggestions, and zsh-syntax-highlighting.

My blog post about setting up a Linux workstation describes this in detail: [https://tkainrad.dev/posts/setting-up-linux- workstation/#swi...](https://tkainrad.dev/posts/setting-up-linux- workstation/#swi..).

The best thing is, there is no initial productivity hit. You don't miss out on any shell features that you are accustomed to.

Also, learning complex IDE features really pays off. At the very least, become familiar with the debugger.

Finally, I spent the last months making [https://keycombiner.com/](https://keycombiner.com/) in my spare time. It is an app for learning keyboard shortcuts and getting faster/more accurate at using them. It already made me more productive because I learned a lot of new shortcuts and found some problems in my typing accuracy.

<comment><USER26> I would highly recommend checking out fzf for better history search. Found the recommendation on another similar thread here and from coworkers. It's surprisingly fast and very intuitive.

[https://github.com/junegunn/fzf](https://github.com/junegunn/fzf)

<comment><USER27> +1 to this. I've never been a fan of how <ctrl r> works in bash, and fzf makes it soooo much better.

</comment></comment></comment><comment><USER28> An actual debugger. I started as a PHP/WP dev and spent many hours running results through echo or var_dump. IMO the debugger is the absolute first thing you need to learn about the platform you're writing for. Without it, you're taking shots in the dark and you truly don't know how your code is executing.

It seriously pains me to see people not using one. I have a friend who is taking an online PHP backend class. There was one lecture on debugging, and all it consisted of was "here's what using var_dump looks like". I showed my friend how to actually set breakpoints in their JS code, set watches, etc and they felt cheated by their class. They should.

<comment><USER29> +1 VisualStudio w/ C#/.NET was very eye opening to the power of live debugging code, ability to evaluate expressions and introspect vars

EDIT: I originally said VSCode, but i meant the OG Visual Studio

<comment><USER28> I've not tried code for .NET yet. I generally like the normal-IDE-ness of Studio

</comment></comment></comment><comment><USER30> Any profiler.

As a development tool: You can default to writing the majority of your code dumb, terse[1], and straightforward, even if you know there's a clever algorithm you might be able to use, because that way is easier to debug. Computers are fast and N is usually smaller than you think, and when you apply the profiler you'll find out that that the biggest performance problem isn't the thing you were going to optimize anyway.

As a product tool: People are more likely to buy responsive programs. The state of modern websites is so bad that non-programmers will actually comment. Every tester for Space Trains[2] commented on how smooth it is. That's a game, but I've seen the same comments on productivity software I've written.

[1] As in omitting layers, not as in omitting descriptive variable names.

[2] [https://www.youtube.com/watch?v=LRJP0tie-30](https://www.youtube.com/watch?v=LRJP0tie-30)

<comment><USER31> By layers, do you mean interfaces and abstract layers?

<comment><USER30> Yes.

Some abstractions are good, but I've seen many projects where an abstraction layer or interface is added that does the exact same thing as the code behind it. Or even more often, there will be one or two specific functions in the layer that does actual work, but it would've been fine to just write a helper function for that and not wrap everything else. It's actually pretty rare that whatever needs to be abstracted covers an entire conceptual area to the point where thinking of it as a "layer" makes sense.

</comment></comment></comment><comment><USER32> TabNine: [https://www.tabnine.com/blog/deep](https://www.tabnine.com/blog/deep) (the code are GIFs which I had to click to play)

This thing is fucking magic.

It's ML autocomplete, with help from 'traditional' autocomplete methods that use static analysis. Instead of just completing one token at a time like traditional completers, it can do entire sentences or multiple lines of code in one go, and is freakishly accurate. And since it parses language it helps you write comments, and can understand relations between code. E.g. if you are writing 2d movement code and you do x += dx it'll automatically suggest y += dy for the next line based off of previous similarities; of course if you have x += [complex math formula] it'll fix it up for y and convert cos to sin, etc.

Support for many editors, and easy to install in vim. Free for personal use. Works for all languages, including plain English (and maybe other non-code languages?).

<comment><USER33> I love TabNine but had to stop using it because each instance can use 3GB of memory... Way too much for an autocomplete extension

[https://github.com/codota/TabNine/issues/43](https://github.com/codota/TabNine/issues/43)

<comment><USER34> It's only too much if you need that memory for something else though. If it manages to be responsive with that memory and you only have 1 ide open, I don't think 3gb should be a problem on a modern system.

<comment><USER35> It always starts with this premise, suddenly every application no matter how silly demands 3gb. I understand that progress often happens by putting more attention to other aspects than economics, but again some people may value that progress less.

</comment></comment></comment></comment><comment><USER36> strace.

Even after having learned many programming languages and contributed to various projects, it was only when I started using strace that I felt like truly, efficiently understand what any program does, and can reliably write programs that do things fast.

I believe that "syscall oriented programming" (making your program emit exactly and only the right syscalls) results in clean, understandable software.

Now I use strace every day, as it is often the fastest way to figure out problems with any tool, written in any language, open-source or proprietary.

\- Something hangs? strace shows how it's hanging.

\- Computer is slow? strace will likely show who's the culprit spamming syscalls.

\- "Unexpected error occured"? Bypass programmers doing poor error handling, and witness the underlying "no such file or directory" directly.

Last week I even used strace to debug why my leisure-time computer game wouldn't load a mod, and as usual, strace did the job.

strace helps to really understand computers.

If you want to learn more about strace, check out Brendan Gregg's pages like [http://www.brendangregg.com/blog/2014-05-11/strace-wow- much-...](http://www.brendangregg.com/blog/2014-05-11/strace-wow-much- syscall.html), my presentation for an intermediate-level example ([https://news.ycombinator.com/item?id=16708392](https://news.ycombinator.com/item?id=16708392)) or my project to build a programmable strace alternative ([https://github.com/nh2/hatrace](https://github.com/nh2/hatrace)).

<comment><USER37> Do not use strace. Use sysdig which is superior in just about every way.

<comment><USER38> sysdig is useless without installing nontrivial performance-impacting instrumentation, cannot handle non-IP networking, does not fully report all syscalls, has a license with patent crap in it, has gated features behind a paywall, and cannot inject syscall faults. It's not even in the same class of tool as strace at this point.

<comment><USER37> > sysdig is useless without installing nontrivial performance-impacting > instrumentation

Most reasonable people reading this sentence would come away with the conclusion that strace is fast, whereas sysdig has some inherent overheads. In reality it is strace that has performance and other problems which make it completely unsuitable for production use (strace will slow syscall heavy code down by a factor of over 100; sysdig won't). Sysdig, on the other than can definitely be used in production and I always found the performance overhead minor. Can you point to something showing otherwise? BTW, newer versions of sysdig do not require a kernel module, thanks to eBPF (but I have not used this).

> , cannot handle non-IP networking,

What is an example of a networking related query you can do with strace but not with sysdig?

> does not fully report all syscalls

Can you expand? Are you referring to the fact that sysdig will drop traces if the userland client cannot keep up (which is a feature and not a bug, and something that all production grade tracing tools do)?

> , has a license with patent crap in it,

As far as I'm aware sysdig's core is Apache licensed and the user scripts are MIT and GPL licensed. Apache has a patent grant, which seems better than not having one. What is your specific beef?

> has gated features behind a paywall,

What features that strace offers are behind a paywall in sysdig? What's wrong with a company that provides a tool that massively advanced the (linux, pre- eBPF) state of the art as open source for free to all also provide some paid offerings on top?

> and cannot inject syscall faults.

This is indeed a useful recent-ish feature I did not know about so thank you! But there are other ways to do it, and something that's orthogonal to the core tracing functionality.

> It's not even in the same class of tool as strace at this point.

Indeed -- the only reason to use strace at this point is because you already know it and it is likely available. This may change if strace switches away from ptrace, but for now it is a joke. If you want something that just does strace, but much better (minimal overhead, powerful and intuitive query language with CLI autocompletion) use sysdig. If you want to use the most general and powerful tool that can tell you lots of other stuff besides syscall usage (but has a much worse UX) look at eBPF and perf. If you want to be a serious performance engineer or similar you will have to learn it, but I suspect for most people sysdig has the best ROI. Perf and dtrace are both (far) more versatile but, IMO, (far) less pleasant to use.

</comment></comment></comment></comment><comment><USER39> If you consider processes as tools, there's one that I suggest to junior programmers bucking for responsibility/promotions.

Twenty minute cleanup. Nobody is really going to notice if you spent 5 hours or 5:20 on a task. As you're closing up and getting ready to push your changes, look if there's anything you can do to make it look or work nicer.

Eventually you start incorporating some of the lessons learned doing this into your implementations.

<comment><USER40> +1 to this. I've developed the habit of reviewing my PRs before publishing them. When you assume the role of a reviewer, you end up catching a lot of little (and sometimes big!) stuff, reducing the total turnaround time.

<comment><USER41> +1 to self code reviews, I almost always find stuff I've missed or could have done better.

<comment><USER42> I often comment on my own PRs to explain alternatives or tradeoffs I considered. These aren't necessarily worth capturing in permanent documentation or TODOs, but can share knowledge or build confidence that I've considered various angles that might come up in a review.

I'll also call out places where I'm not happy with the implementation, looking for feedback, etc.

</comment></comment></comment></comment><comment><USER43> For many of the tools that have improved my productivity, it was not the tool that was the breakthrough but the _realization_ of the tool's value. For example, version control has existed since the beginning of time practically, and I begrudgingly used RCS, SCCS, VSS, and probably other version control systems for ten or fifteen years until I had that Eureka! moment (coinciding with Git's release, roughly) that inspired me to actually _embrace_ version control tools. A similar experience happened with automated testing: I'd gotten the testing-is-good bondage and discipline spiel many times, but it wasn't until I started writing extensive units tests for language parsers that I realized how wonderfully empowering they can be.

That said, along with Git, I'd list Gdb (or LLdb or any real debugger), Emacs keyboard macros, Python's venv facilities, and Django's database migrations among the tools that changed my life.

Somewhat consistent with the it's-not-the-thing-but-the-realization-of-the- thing's-value theme above, I'd say reading the Practice of Programming back in '99 took my programming productivity to a new level, because it made me realize that one of the central tasks of an abstraction builder is creating a language that allows you to express thoughts in terms of that abstraction. Once you've done that, you "just" need to implement the language and all of the problems expressible in it become easy, even trivial.

</comment><comment><USER44> Using multiple programming languages.

Using Golang has helped me create better data structures, and using C helped me understand linking, using python helped me understand closures, and using Ruby helped me understand that I hate programming.

<comment><USER45> can you elaborate on ruby? i'm curious to understand your experience with it and what brought you to the conclusion that you "hate programming".

<comment><USER46> I'm not the original person so I have no idea what their experience is, but I feel pretty much the same. Every time I work in a language other than Ruby, it feels like _programming_. When I work in Ruby the language feels almost effortless. I wish I could do everything in Ruby and it frustrates me when there is something I can't make work in Ruby. Especially Rails, everything that works works so smoothly. When it doesn't work I get very frustrated and switch to another language only to find out its _even harder_ in another language.

I don't like programming. I like it when the computer does what I tell it to do. I find that drastically easier to accomplish in Ruby (especially Rails).

<comment><USER47> What are your thoughts on Crystal?

See: [https://crystal-lang.org/](https://crystal-lang.org/)

<comment><USER48> Would you like to pay now (compile time) or later (runtime)?

We have ways of dealing with scaling of runtime in production (develop infrastructure environment).

There's no way I know to speed up the edit/compile/run loop during development.

</comment></comment></comment></comment></comment><comment><USER49> The vi mode for Bash. Blew my mind when I discovered it and it probably saved me hundreds of hours already. I used to have multiple copies of this cheatsheet [0] at my desk for every new developer I would see editing a terminal command with the left and right arrows.

[0] [https://catonmat.net/ftp/bash-vi-editing-mode-cheat- sheet.pd...](https://catonmat.net/ftp/bash-vi-editing-mode-cheat-sheet.pdf)

<comment><USER50> I dunno, I don't think it really gets you more than just adding some basic mappings

        # mappings for Ctrl-left-arrow and Ctrl-right-arrow for word moving
        "\e[1;5C": forward-word
        "\e[1;5D": backward-word
        "\e[5C": forward-word
        "\e[5D": backward-word
        "\e\e[C": forward-word
        "\e\e[D": backward-word

        ## arrow up
        "\e[A":history-search-backward
        ## arrow down
        "\e[B":history-search-forward

</comment></comment><comment><USER51> magit ([https://magit.vc/](https://magit.vc/)) - a git interface for Emacs. Hyper-interactive and ergonomic, feels like vim for git. Highly pleasurable to use and makes you significantly more efficient.

SLIME ([https://common-lisp.net/project/slime/](https://common- lisp.net/project/slime/)) - a Common Lisp development environment, also for Emacs. Comes with a REPL, interactive debugger (way better than gcc), the normal IDE-like experience you know and love, and this fantastic tool called the Inspector that is basically an interactive, modal editor for your program data. The Inspector is one of the most novel and useful tools that a development environment can have... and I've never seen another IDE that has anything resembling it. SLIME gives you a highly interactive and fluid development experience that I've never seen anything else come close to.

Spacemacs ([https://www.spacemacs.org/](https://www.spacemacs.org/)) - <USER2> starter kit for Emacs that gives you a _sane_ out-of-the-box configuration and an optional pre-configured Evil (vim keybinding emulation) setup. Much more flexible and powerful than Vim (elisp, while a bad general-purpose language, runs circles around vimscript) and much better ergonomics than vanilla Emacs (Emacs' mode-less interface is just straight-up worse for your hands than Vim's modal interface).

</comment><comment><USER52> If your after specific tools in a workflow...

\- the :normal command in Vim and Evil. \- learning to use tags to navigate code.

But more generally learning how to take something seemingly complex like Linux or Git and then delve in and read the code and understand how it _actually_ works. Learning to read good technical books and manuals and understand how something was designed and how it was designed to be used.

Colleagues think I work magic; in reality I'm just as thick as they are, I just RTFM.

<comment><USER53> hahaha...that's my 'secret'

recently I've been paralyzed by the amount of development in ML/DL/RL. Often I have to step back and remind myself to focus on the fundamentals.

</comment></comment><comment><USER54> I'm going to re-interpret the question more broadly than just "tools" (unless you consider a technique to be a kind of tool):

* Taking good notes

* Writing good plans, good documentation

* Sharing updates and coordinating with the right people at the right time

* Understanding an unfamiliar codebase

* Test frameworks

* Different design techniques (pure functions, dataflow programming, etc)

* The terminal and related features (like emacs bindings, or middle-click to paste last selection)

* Firefox/Chrome devtools

* Emacs keyboard macros

<comment><USER55> I can no longer count on my fingers how many massive coding efforts from our backlog evaporated into nothing because we sat around and thoroughly talked through the actual business cases.

</comment></comment><comment><USER56> Most of my productivity gains these days has come from aligning myself and my workstation.

\- i3wm ([https://i3wm.org/](https://i3wm.org/)) - particularly getting comfortable editing the .i3/config. It's the most significant productivity change I've had since switching to Linux from Windows.

To get into it, I highly recommend this 3-part video series from Code Cast: [https://youtu.be/j1I63wGcvU4](https://youtu.be/j1I63wGcvU4)

\- yadm ([https://yadm.io/](https://yadm.io/)) - a dotfile manager. It's essentially a git wrapper, but it's allowed me tons of freedom tweaking my setup without worrying about persisting it.

It supports encryption and switching file versions based on which system you're on.

<comment><USER57> fast switching between workspaces + efficient use of screen real estate + great hotkeys make i3 truly great, I have used it for many years and don't want to miss its minimalism

</comment></comment><comment><USER58> _IntelliJ IDEA_ has taken refactoring from being a chore to being trivial, consequently making me much more likely to clean up ugly code when I encounter it.

 _Black,_ the Python code formatter, means I don't have to spend a single brain cycle on styling the code.

 _mypy_ (with a strict configuration) has forced me to think about types, making for code which is much easier to follow and integrate with. No more `if isinstance(list, param)` or similar faff.

 _Bash,_ even with all its footguns, is a great lowest common denominator for getting a vast array of stuff done.

<comment><USER59> Do you have an example of the configuration you use with mypy? (If you could post it in a gist I should would appreciate it! I've done a couple mypy tutorials but I haven't pulled the trigger on adding it to my projects.)

<comment><USER58> [https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494c...](https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494cf)

Beware that if you're not yet using mypy I would not recommend starting with this - it's a lot of work to get to the stage where this succeeds. I'd recommend starting with no configuration at all and adding one setting at a time so you give yourself time to learn what they all do and how they help.

</comment></comment></comment><comment><USER60> Jetbrains IDEs have been mentioned already, but I'll add a specific feature of Jetbrains IDEs, the Productivity Guide[0].

This contains a list of keyboard shortcuts and tracks your usage or non-usage of them, identifying various ways you can speed up your workflow in the IDE using keyboard shortcuts instead of the mouse.

Building on this, the Key Promoter[1] plugin will notify you when you could have used a shortcut instead of the mouse.

Reclaim seconds of your life wasted moving the mouse around.

[0] [https://www.jetbrains.com/help/idea/productivity- guide.html](https://www.jetbrains.com/help/idea/productivity-guide.html)

[1] [https://plugins.jetbrains.com/plugin/9792-key- promoter-x](https://plugins.jetbrains.com/plugin/9792-key-promoter-x)

<comment><USER61> Interesting...

Does something like this exist for Excel? Asking for a friend (seriously).

</comment></comment><comment><USER62> The static analyzer. There are so many subtle things that aren't caught by the compiler and don't cause any problems in your testing but will definitely come up once 10M users are running your app. The static analyzer can catch some of them before you even run! It's great.

The various sanitizers - Address Sanitizer, Thread Sanitizer, Undefined Behavior Sanitizer. These all also find things before you ship. They require (re)building and running but it's worth it.

Beyond that, any sort of instrumentation that can show you in real time information about your running application. You can see memory growing, even if it's not leaking. You can see performance tanking and know the exact function that's causing it before you quit.

Beyond that, for me using a framework that was well written made understanding architecture much easier. I had used MFC and CodeWarrior PowerPlant for a few years. They got the job done and were easy enough to use, but I didn't really learn anything from them. But when I moved to using Cocoa, it was so elegant and the separation of concerns was so good that it clicked and really taught me a lot about better architecture.

</comment><comment><USER63> PlantUML[1]: Drawing any diagram helps me to have something concrete as it makes me think of the various components, connections and the invariants. It also gives a bigger picture.

It is also very easy to learn and can be embedded anywhere rendered by Plant UML server or the rendering can be handled by your internal plant UML service.

[1] - [https://plantuml.com/](https://plantuml.com/)

<comment><USER64> There are several VS Code plugins for PlantUML and Graphviz that allow for live rendering. That has proved very useful for communicating ideas without needing a drag-and-drop interface, and the result is a file that I can drop into a git repository.

<comment><USER65> There is a JetBrains extension too!

</comment></comment></comment><comment><USER66> Choice of editor is subject to taste, but I find VI/Vim keybindings and modal editing an absolute must-have for productivity.

<comment><USER67> I agree. When first learning Vim the learning curve is very steep for what feels like basically advanced cursor moving but with more experience it becomes a very powerful text editor. Last week another I had a 10,000 line file that was the output of a bash command with two columns and each column was in quotes. I needed to remove the first column and the quotes around the second column. There are many ways to do it but all I had to do was open up vim and type `qaA<backspace><esc>T"d0jq` and `10000@a` and cleaned it right up.

<comment><USER68> As an opinion, [https://vimvalley.com/](https://vimvalley.com/) was well worth the investment.

I use [https://www.spacemacs.org/](https://www.spacemacs.org/), but modal editing is a win.

</comment></comment></comment><comment><USER69> \- rr, the time-travelling debugger[0]

\- intellij, or any good ide. seriously, we underappreciate everything these tools do and can do for us.

[https://en.wikipedia.org/wiki/Rr_(debugging)](https://en.wikipedia.org/wiki/Rr_\(debugging\))

</comment><comment><USER70> Better at coding and better Programmer not always converge.

To become a better programmer, I find _testing_ is a big booster. Not only it helps demonstrate compliance to specs, it also adds more confidence that you're in control of the code. It let's you experiment and change approaches.

Also I find a good help from _IDE_, even a simple as Geany [1], that lets me jump between the functions and also hint at the args. It saves time, and, again, adds confidence when exploring/extending new code.

And finally, the most imporant booster - _learning my limits_.That is when it's time to ask for help and not feel too defensive about peer review. This goes hand in hand with knowing what a good team is. Not just wishing for it.

</comment><comment> 1e-9 My biggest improvement came from eliminating a tool. It was when I stopped using debuggers (except maybe once a year) and invested more time in creating efficient runtime error checks and internal self-tests. Debuggers make me lazy. I find I can solve the vast majority of my bugs more quickly with a little thought rather than running to a breakpoint and examining things.

Most useful tools:

\- tmux

\- vim

\- catch ([https://github.com/catchorg/Catch2](https://github.com/catchorg/Catch2))

</comment><comment><USER71> Lately, using Jupyter notebooks. It's a paradigm change, and pretty close to what I would imagine Donald Knuth had in mind with literate programming. Just for example, being able to see the shape of variables and having that output stay there between coding sessions is a huge time saver. Add being able to plot data and using other visual tools right inside your code and well, I could go on and on. Just try it. It's like a REPL but with memory.

<comment><USER72> How do you integrate it into your workflow? Is your program scattered across blocks in a notebook or is it easy to pull everything together once it works the way you want?

Also, thoughts on jupyter vs co ok colaboratory?

<comment><USER71> Late response, but in case you are still looking I don't think I have enough experience just yet to talk about my workflow. For the moment, I'm mostly fine with just running my entire notebook. And yes, my program is "scattered" across cells in a notebook. And that's useful. The blocks are the small units I would want to debug, or to document with markdown above the block.

However, you might look to Jeremy Howard of fastai [1] fame for some direction. He apparently built the entire fastai library using notebooks and nbdev [2] which allows you to "add #export flags to the cells that define the functions you want to include in your python modules."

I have tried out nbdev in my free time, and it's pretty cool.

[1] [https://www.fast.ai/](https://www.fast.ai/) [2] [https://github.com/fastai/nbdev](https://github.com/fastai/nbdev)

</comment></comment></comment><comment><USER73> Resharper (and now all the various Jetbrains tools) - from the early days, this tool allowed you to aggressively and automatically refactor code. Before that, in the C# world ( and many other languages ), there was very little in the way of automatic refactoring tools. Not to mention it's automatic suggestions on code transformations or more efficient use of the language are super useful.

Vim Bindings - While I often don't use Vim, I use Vim binding in most any environment I use. I don't know if it really made me a better programmer, but it improves the experience of programming.

Unit Testing tools - making code testable makes code modular.

Visual Studios Debugger, fantastic debugging tool from years and years ago. While I don't use it as much anymore, it's been a useful tool in understanding code.

Google Search, transformed the way to get information, coding information was hard to come by a few decades ago, now it is prolific.

</comment><comment><USER20> I prefer to internalise useful ways of thinking rather than leaning too much on tools, on the grounds that the latter are easy-come-easy-go while the former can last a lifetime.

Learn to explain what you're building, why, and more-or-less how it works in a context appropriate to the listener.

(Related: write things down. Again and again, differently, until you understand them.)

Problems and their solutions usually have similar structures.

Any fix right now might save a lot of money. The right fix next week could save years. Often both are appropriate, but the latter is nearly always most valuable.

The world does not change nearly as fast as your competitors want everyone to believe it does, but people's beliefs can.

A tool which warns you of possible mistakes before consequences occur is always more valuable than a tool which tries to guess what you meant and does that instead.

</comment><comment><USER74> If you think of languages like tools I find Haskell particularly productive. The type checker gives me a whole program view of every branch and I can interactively query my program thanks to strong inference and good tooling.

Mastering a good emacs setup has boosted my productivity with git and having OS-agnostic tooling for linting, debugging, shell, document publishing, email, etc.

</comment><comment><USER75> \- git. Not just commit/push/pull on a single branch - but getting really good at using git is a game-changer.

\- vim. I started off in linux sysadmin land before pivoting into more regular software engineering work, so I was very good as basic vi(m) stuff because it's ubiquitous in linux/unix servers. However I've learned its just as valuable as a full-blown IDE/dev environment if you're willing to invest in learning and configuring it. I think newer editors like Atom/VSCode/IntelliJ are still very valuable and great tools, but Vim really is incredible.

\- An understanding of unix history. Maybe it's just the type of work I do, but knowing why things are the way they are is incredidbly valuable.

<comment><USER76> Regarding understanding unix history.

I actually think that knowing the history of whatever you're working with, is good and really valuable.

If you don't know the history, you don't know how things came to be and why things are the way they are. This applies to language, code, product, organization, tools, etc.

You can treat things like a blackbox and use them. They'll work for a while but every time you see something that doesn't work, you'll spend time and more time trying to figure things out. Do/Learn things once.

Ask questions. Sit with people that know. Ask smart questions - [http://catb.org/~esr/faqs/smart- questions.html](http://catb.org/~esr/faqs/smart-questions.html)

I've been using git for years. But I decided to really dig into it to find out how things work. These are good links and there are actually many more good ones about git internals out there.

\- [https://git-scm.com/book/en/v2](https://git-scm.com/book/en/v2) \- [https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protoco...](https://git- scm.com/book/en/v2/Git-on-the-Server-The-Protocols) \- [https://git- scm.com/book/en/v2/Git-Internals-Plumbing-and-Po...](https://git- scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain)

</comment></comment><comment><USER77> \- Version control

\- Unit testing

\- Leak detectors (for languages like C/C++)

\- Race detectors

\- Auto-formatting (eslint, gofmt)

\- A solid editor (prev: vim, now: vscode)

\- One-step deployment scripts/automation (even for small projects)

I have not found a lot of value in debuggers, outside of after-the-fact debugging (e.g., core files.) I much prefer printf-style debugging.

<comment><USER78> > I have not found a lot of value in debuggers, outside of after-the-fact > debugging (e.g., core files.) I much prefer printf-style debugging.

Have you heard of/tried rr? I think you might find that it fits your thought process better than traditional debuggers.

[https://rr-project.org/](https://rr-project.org/)

<comment><USER77> Never heard of it, but I'll take a look. Thanks for the pointer. :-)

</comment></comment></comment><comment><USER79> Learning functional programming will make you a better developer in all languages IMO. This is the single biggest vector for understanding how to write maintainable code.

Similarly learning design patterns will probably make you a worse programmer but learning the heuristics behind them (eg composition over inheritance) will make you a better programmer.

Learning DDD will make you a better programmer by understanding how to use bounded contexts to manage complexity as software grows.

</comment><comment><USER80> \- tests in watch mode. Either with --watch if I'm doing js with mocha or inotify if I'm doing another language. Tests or compile should execute on save, which in turn I configure in autosave.

\- making sure that I can execute everything from the console. It makes tickets reproducible, for my future me and my coworkers.

\- go. Error handling in go has very bad press, mainly because it's boring and repetitive. But one builds the habit of handling all cases.

<comment><USER64> `fswatch` is a cross-platform way of monitoring file system changes, versus `inotify`. I use it for testing in the same manner as you describe, very helpful to have one tmux pane with code and another constantly showing the results of test execution.

</comment></comment><comment><USER81> I'll add two really simple, but also very effective tools. Search: in the form of things like "the silver searcher" ([https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)) or "fd" ([https://github.com/sharkdp/fd](https://github.com/sharkdp/fd)). And, Replace: with tools like sed ([https://www.gnu.org/software/sed/](https://www.gnu.org/software/sed/)).

These are really simple tools but they are also very powerful. I have surprisingly often needed to change from version X.Y.Z to version A.B.C in some set of files (be it package.json or requirements.txt or *.csproj) and tools like these make it happen in an instant.

Most recently they have helped me with some spaghetti code where the software is used in several places and I need to ensure exactly which places use the KerfuffleManager. Can I trust my IDE to find all places where it is used? Maybe, but with proper search tools it stops being a trust thing.

<comment><USER82> In the same vein as silver searcher, I'd mention ripgrep: [https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

</comment></comment><comment><USER83> Vim. I felt like I was slowly going crazy due to the friction between my thoughts and the commands needed to navigate through the code. I was just looking for a tool to solve that and happened upon an article about Vim. A teacher had tried to show me Vim in high school, but I slowly backed away from his crazed stare. But now, I came to it of my own volition. It's great. It feels like the one tool which allows me to freely express what I want without getting in the way. Add to this a suite of simple yet powerful tools, such as recursive macros, which mean I can usually automate tedious and repetitive tasks.

</comment><comment><USER84> Emacs. Specifically Doom Emacs.

[https://github.com/hlissner/doom-emacs](https://github.com/hlissner/doom- emacs)

<comment><USER85> Emacs. Specifically vanilla GNU Emacs.

[https://www.gnu.org/software/emacs/](https://www.gnu.org/software/emacs/)

</comment></comment><comment><USER86> Shell, awk, sed and textutils. They teach that programming is everywhere.

I have trouble understanding professional challenges of people that never had a chance to learn those. Like accountants struggling to merge tables or proposal writers painfully tuning document layouts.

<comment><USER87> Any recommendations for resources on learning more about these commands?

<comment><USER88> Shell - for bash, I'd recommend the Bash Guide from Greg's Wiki ([https://mywiki.wooledge.org/BashGuide](https://mywiki.wooledge.org/BashGuide)) For awk 1\. Chapters 1 and 2 from the Awk Programming Language([https://ia802309.us.archive.org/25/items/pdfy- MgN0H1joIoDVoI...](https://ia802309.us.archive.org/25/items/pdfy- MgN0H1joIoDVoIC7/The_AWK_Programming_Language.pdf)) 2\. Awk one-liners ([https://www.pement.org/awk/awk1line.txt](https://www.pement.org/awk/awk1line.txt)) 3\. Explanations for one-liners ([https://catonmat.net/awk-one-liners- explained-part-one](https://catonmat.net/awk-one-liners-explained-part-one))

</comment></comment></comment><comment><USER89> I install the largest whiteboard I can find. My current office has one that is over 2 meters across. Having a huge space to discuss architecture is valuable.

<comment><USER90> I second this. Also, whiteboard notecards and neodynium magnets.

</comment></comment><comment><USER91> \- Solid editor: I've used a few editors and IDEs in the past. I think a learning to use a programmable editor is a better investment than learning to work with an IDE. IDEs are generally single purpose: working very good for a limited selection of languages, platforms, etc. Having a good editor at your disposal allows you to manipulate any text oriented (and sometimes binary) format. When your editor is programmable and has an active community, you can probably find a plugin to solve your problem more effectively or write something yourself, with your editor! With all your customizations in code, you can manage your editor in the same way as you manage your products: source control! This gives you the possibility to improve your daily working environment reliably and iteratively. IMO, Vim and Emacs are both very good options. Both were created decades ago and still have very active communities. Personally prefer Emacs and use vim on occasion for remote work.

\- Learn basic vim and emacs keybinds: most interactive shells use readline (or similar) library. These shells often have emacs keybindings by default. Vim is often the alternative option. This was an eye opener while learning emacs: suddenly I started to understand how to efficiently navigate any shell, even remote systems, without configuration!

\- Tcl: Easy to learn, hard to master and powerful! Syntax and semantics can be explained in 12 bullet points[1]. Bundled with the native tk library, its my goto language for quick-n-dirty GUI tools and prototypes. The "every thing is a string" principle makes it extremely flexible. Apart from quick-n-dirty, it's also used for stable tools such as expects, gitk and environment modules. Even sqlite and redis started as tcl scripts!

\- POSIX shell scripting and core utils: write once run anywhere.

[1] [https://tcl.tk/man/tcl/TclCmd/Tcl.htm](https://tcl.tk/man/tcl/TclCmd/Tcl.htm)

<comment><USER92> Tcl/Tk is still the fastest way to get from zero to functional GUI that I've ever seen. I wish I could say there was something of similar ease in Lisp, but alas there isn't -- not in the current ecosystem of Unix workalikes running on generic CISC/RISC hardware. Maybe the Lisp Machines had something.

<comment><USER93> > Tcl/Tk is still the fastest way to get from zero to functional GUI that I've > ever seen.

PySimpleGUI seems pretty great for that.

<comment><USER94> PySimpleGUI wraps tkinter and thus ultimately Tcl/Tk.

</comment></comment></comment></comment><comment><USER95> leetcode.

I hate I have to do these stupid exercises to be able to get a job, but I have learned some useful skills by looking at how I write code and comparing to faster solutions. It has changed how I write normal code, and helps me write automatically without thinking too much.

</comment><comment><USER96> For me it's profilers. A lot of people keep optimizing their code without actually having hard data. Being good with a profiler has often allowed me to go in and get significant improvements quickly because I could attack the code section that really took a long time vs the code sections where _think_ the time is going.

Also having detailed logging with time stamps helps a lot in identifying where the code spends most of its time.

<comment><USER97> Regular scheduled 1:1 meetings with those I work closely with. Does wonders for teamwork / relationship building.

</comment></comment><comment><USER98> That's easy, every time I did something new I learned a lot.

First time

\+ Linux.

\+ Shell scripting.

\+ Grep, regex

\+ Embedded development, configuring ADC hardware, e.g.

\+ FPGA, designing FSMs, adders, etc.

\+ Reverse engineering anything. Use a logic analyser. I just learned the details on HDMI a week ago, for example.

\+ Vim, and sticking to it in the beginning. :-)

\+ Basic sysop stuff, ssh, rsync, dig, etc.

\+ Cuda.

\+ Tensorflow.

\+ Javascript. Definitely if you come from a C angle. Playing with modern frameworks doesn't hurt!

Of course those are not just tools, but they all help understanding what's the best tool for the job. :-)

</comment><comment><USER99> \- Git - quite self-explanatory

\- Visual Studio Code - I like more than the paid version (that I have a subscription for)

\- SQL Server Management Studio execution plan modes - it is a gem that few people know about and even fewer can utilize it effectively to make 10 second queries run in 30 milliseconds.

\- Composer (PHP) as my first encounter with package management, years ago.

\- Notepad++ - the only mini-tool available in production

\- Virtual machines and snapshots. Never fear again about ruining the work environment and helping a lot with having separate dev/stage/prod environments without breaking the bank. Also a way to split and separate my environments, the laptop is for emails, VM's for everything else.

PS. I am not a programmer, I am officially a manager and mostly an architect, but I write code to keep current

<comment><USER100> There is a paid version of VS Code?

<comment><USER101> Maybe the person meant to say Visual Studio Code is preferable to Visual Studio.

<comment><USER102> I feel that Visual Studio Code (a free programmer's text editor) suffers from its poor branding -- it's too easily confused with Visual Studio (a paid IDE), so folks dismiss it out of hand because of the perception that it's not free or is only for MS languages like C# (neither is true). Microsoft should have called it something else.

As a Vim user of 2 decades, I have to confess something: VS Code is a far better programmer's editor than Vim. It's pretty responsive, has seamless (and better) integration with language servers [1] than Vim, has better autocomplete than Vim (due to said language server) and the Vim keybindings are not terrible.

For the first time, refactoring (renaming variables) is easy because the editor now understands the language-specific structure of the code as opposed to the code being treated as a long string. It's possible to attach a language server to Vim but it's fiddly and doesn't work that well.

[1] [https://langserver.org/](https://langserver.org/)

<comment><USER103> I have no problems using LSPs for C/C++ (via clangs), rust (rust-analyzer), Python (pyls), JS/TypeScript, CSS, bash, and more in Vim (Well, NeoVim) with the autozimu language client.

<comment><USER102> The experience is a bit different in VS Code.

To me, in Vim it feels a little bit like one is calling an external program (which one is), and the monospaced text-only UI constrains what can be shown.

In VS Code, the experience is more integrated (because the GUI isn't constrained to a text interface), things update live, so you can preview the changes before applying.

I've tried both, both work but I find myself preferring the VS Code experience.

</comment></comment></comment></comment></comment></comment><comment><USER104> Immutable infrastructure / functional programming / crash-only code. In conjunction with lots of docker, ansible, studying FP, and trying to adopt these principles in all my main languages (python, go, c, c++, bash)

Those 3 ideas all kind of mushed together radically changed my overall approach to development. What do they all have in common? Avoiding complex state.

State is hard to reason about. Each piece of state that can interact introduces combinatorially-growing complexity.

Crash-only code may seem like the odd one out but think about it: if your program dying at literally any point has the potential for data corruption, you probably have some sort of issue with state management.

I guess you could call it anarchy coding, because it tries to completely eliminate state ;)

</comment><comment><USER105> \- vim, grep, regex, cli (i.e. fundamental text tools, no "ide" plugins)

\- no "intellisense", only word completion

\- write down my operative "what do I do now" stack on paper (helps to not lose yourself in a forest of thoughts and fixes)

The second one I found very effective, because instead of guessing what function or method does or how many of them are there, you go to man/html docs and read on what it really is, how it works, and what its error modes are. This way I learn much more about APIs that I use, read rationales, caveats and more.

Also, intellisense when done wrong (and it often is) gets in your way and creates non-deterministic time-dependent _modes_ for your input, even worse than vim-anxious people usually criticize it for.

</comment><comment><USER106> I do think that your keyboard can help not only mitigate health risks associated with typing all day, but can make the actual act of writing code go from annoying to enjoyable. What works for you is a subjective question (I don't think that mechanical keyboards are the best for everyone, if I'm hoenst), but a good keyboard can really go a long way.

<comment><USER107> Guess an ergonomic keyboard could help prevent some injuries.

</comment></comment><comment><USER108> Pico. Without it, I'd still be searching how to quit vim :)

But jokes aside, all kinds of real-time log aggregators make big difference for me. Once upon a time, I had acquired first huge customer and had to set up analytics service as a single-tenant deployment. I acquired better servers than usual, installed the service and started processing the traffic only to find out that we can handle only 1/50 of the contracted traffic. For the next 48h or so I pushed hundreds of changes to production and watched realtime charts in Splunk going from 1/50, 2/50 to 50/50\. I saved the contract and saved the company and went to bed.

</comment><comment><USER109> Continuous Integration tools.

I started with Jenkins and hated it, because it really encouraged configuration through an awful web interface. CI configs should live in version control!

(I know you can do that with Jenkins these days but I still haven't figured out how myself).

Then I got going with Travis CI and loved it - then Circle CI, then GitLab CI and today I'm mostly using GitHub Actions.

Every single personal project I build uses CI now. My tests, packaging and deploys are all automated from day one. It's an enormous productivity boost and lets me manage way more projects without worrying that I'll forget how to test them / package them / deploy them.

</comment><comment><USER110> Property-based testing.

I believe it can be a real game changer. It can enable a normal programmer to create the same quality as an excellent programmer.

An introduction: [https://fsharpforfunandprofit.com/posts/property-based- testi...](https://fsharpforfunandprofit.com/posts/property-based-testing/)

</comment><comment><USER111> \- Erlang/Elixir: taught me functional programming, pattern matching, recursion, supervision, how to achieve fault tolerance

\- Docker: taught me about server management and immutable infrastructure; paved the way for a lot of concepts (containers are surprisingly foreign for a lot of people)

Other than that: learning about different databases in general and learning how they solved the problems they had and why they solved them that way; the same problems come up over and over and it's important to be able to recognize good ideas from bad ones as well as when to recognize solved problems from novel ones

</comment><comment><USER112> Touch typing - learning it during this WFH phase, as much more communication is done typing.

</comment><comment><USER113> Putting this in my hosts file helped me maintain my focus.

127.0.0.1 news.ycombinator.com

127.0.0.1 reddit.com

127.0.0.1 facebook.com

<comment><USER114> Yhea this is nice but this simply does not work on all websites. The edge between working and browsing the web can be very thin on some websites. For Facebook it is easy just block it completely but reddit and youtube are difficult so what I do is that I use a plugin called stayfocused it allows you to set a amount of time (for me 30 min) that you are allowed per day to be on the websites you listed. On my second browser I place no restrictions like that but use ublock origin to block everyting untill it is broken. So for example i remove the recommendations from youtube and it's search bar. On reddit I remove the list view so only a single post shows correctly. For me this works way better because the rules are fair and that makes sure you do not just remove the entries from your host file for example just a few days after you entered them.

<comment><USER115> Why is reddit hard to block? I put that in my hosts from time to time and it works fine.

The real problem is how incredibly hard it is to set edit the hosts file on mobile. At least without using a VPN app or something.

<comment><USER114> When you are programming in some lesser known graphics frameworks like libgdx or when you are using OpenGl then the special Reddit subpages are more active than stackoverflow. For example I implemented a framebuffer in OpenGL wrong a few weeks ago but the output then is just a black screen. Some redditor mentioned that specific thing in a comment on /r/OpenGL

</comment></comment></comment></comment><comment><USER116> Can't imagine writing code without Jetbrains IDEs. VSCode is great for lightweight editing. On the other hand, I have other tools like CopyEmPaste: [https://apps.apple.com/us/app/copyem-paste-clipboard- mgr/id8...](https://apps.apple.com/us/app/copyem-paste-clipboard- mgr/id876540291?mt=12) This is a great clipboard manager and helps a lot with Copy-Pasting.

</comment><comment><USER117> Perl. CLI one-liners or small one-off scripts.

You can do so much automation and data munging so quickly with it that it really makes you feel like you have superpowers.

<comment><USER118> Yeah, I still use perl for most all the server side stuff I have to do.

</comment></comment><comment><USER119> Read the docs!! Even the bad ones are better than none.

I can't count the amount of times I've been working with a more junior engineer and I'm just rattling off answers to their questions..then at the end I realize that I have 5-6+ tabs worth of documentation open that I've simply been referencing throughout our conversation but they think I'm some walking encyclopedia of knowledge.

</comment><comment><USER120> To me, it's functional programming in general and Haskell specifically. Thinking in function actually helps me become a better programmer !

</comment><comment><USER121> Lots of great tips/tools here. Let me add this to the list:

Dash [https://kapeli.com/dash](https://kapeli.com/dash)

Makes browsing documentation really fast and convenient. Have that bound to F1 in my emacs to lookup the current word at point. So you instantly zap to man pages, lua reference manual, python docs, perl docs, ... you name it. Highly recommended.

</comment><comment><USER92> 1) Emacs. Still the king of text editors, with even the latest challengers (e.g., Visual Studio Code) proving unworthy. Nothing beats an editor you modify for the task at hand live as you edit.

2) Scheme. It started with writing plugins for GIMP in its embedded Scheme in the 90s, then I moved on to Guile -- but Scheme not only made programming fun, it put solving a greater class of problems within my reach, especially when I had to solve them quickly. When I need to explore an algorithm or rough out a prototype for how a system might work, I reach for Scheme -- and even when I'm not working in Scheme or another Lisp, I bring its lessons with me.

3) Darcs. This was my first DVCS, before git, and it enabled me to more easily use version control on my own independent projects and prepared me for a git workflow.

4) Linux, and open source in general -- for providing me with a free OS, free tools, and lots of code to examine for ideas and inspiration. Back when I was faffing about with Windows programming as a teenager, this was a real game changer.

</comment><comment><USER23> Going to the source!

Using a framework or library? You'll get so much better so much faster if you look at what the authors have done.

It's often (I find) easier than looking at random open source projects since you're working closely with the tool anyway. It will help you debug or prevent weird things, teach you techniques you didn't know, and give you a sense for what to strive for.

</comment><comment><USER122> Using an actual, proper IDE instead of text editors with plugins that have so- so language support.

Learning how to operate a computer efficiently. Use keyboard shortcuts. Set up scripts for commonly used tasks. Configure our environment and operating system so it's less annoying.

Being efficient at using a computer also makes you annoyed at poor UIs, and as a result, better at building great apps.

The ability to write things down, and finding joy in writing documentation. I'm continously surprised at how many people will have a 3 hour meeting and just not write anything down, or never make any comments or READMEs in their projects.

Understanding to use the right tool for the job. You don't need to use the latest and greatest container orchestration, library, or whatever.

Not caring about non-business effecting minutiae, like spending time doing code-style nitpicks in pull request comments (when automated tools can do the job), has made me more efficient and less tolerating of the tendency programmers have to focus on non-important things.

</comment><comment><USER123> ESLint (and other linters, preferably used with the strictest rules) - <USER3> at the very beginning it was annoying, it helped me write much cleaner code.

Longer version here: [https://p.migdal.pl/2020/03/02/types-tests- typescript.html](https://p.migdal.pl/2020/03/02/types-tests-typescript.html)

<comment><USER124> Prettier, it helps me having clean code without worrying about writing clean code :)

It does take a bit to get used to it though, but then it's a lifechanger.

</comment></comment><comment><USER125> Maybe the opposite of many other comments but... macOS. Limited choices and customisations, but less is better. Not having to worry about "stuff" is something that goes easily undervalued.

<comment><USER126> That's exactly why I'm using Ubuntu instead a more customized linux distro atm. I will say that after 2 years and a couple of updates, the idea of a rolling release version is sounding better.

</comment></comment><comment><USER127> It can sound stupid but I'm newbie so for me: * Firebase - moving my ideas from local host to online and be able to present this / get feedback. That was/is motivating me to solve more complex problems.

* JS challenges website like coderbyte edabit

* honorable to mention- Hardcore Functional Programming in JavaScript, v2 from front end masters

</comment><comment><USER128> I started my career programming in Vim on VT100 terminals ([https://en.wikipedia.org/wiki/VT100](https://en.wikipedia.org/wiki/VT100)) - yes, I am old.

There was no IDE, auto-complete, visual debugger etc. You really had to think before you typed any code. Even fixing compilation error was a pain - you had to note down the line number and the error, go back and open vim, fix the error, exit vim, re-compile and rinse and repeat. Taught me the paradigm of thinking hard about the problem before starting to code and I think that has helped a lot.

This was still better than the punch-card days I have heard but I personally never had the experience.

</comment><comment><USER129> Not strictly a better programmer but a more efficient one.

\- FZF (Fuzzy Finder) really speeds thing up in bash when searching your history.

\- Vim (as others have mentioned). With the plugin vim-fugitive (a git related vim plugin). I love Gblame in vim-fugitive, as being able to look at the history of lines of code and stepping back in time can at times be very useful.

\- Creating various aliases. For example in git I have little aliases which just make me faster. "st" = "status", "rbi" = "rebase --interactive", "ci' = "commit", etc...

\- Using The Silver Searcher (ag) or Ripgrep (rg) instead of grep. Much faster than using grep.

\- Using 'fd' instead of find. Like above it is a lot faster.

<comment><USER57> I've installed rg and aliased it to to grep, so the muscle memory stays the same but underneath the tool is changed.

Also works for

ls -> exa

cat -> bat

<comment><USER103> exa completely breaks ls arguments/switches and as such is a hard pass for me.

<comment><USER57> I have since switched to lsd: [https://github.com/Peltoche/lsd](https://github.com/Peltoche/lsd)

</comment></comment></comment></comment><comment><USER130> Using a step debugger and stepping through all the code I just wrote, or using it to explore code other people wrote.

Surprisingly this seems to be a very uncommon use for a debugger, some programmers are mislead by the name and only use it for actual debugging ;)

</comment><comment><USER131> Typescript - defining interfaces before doing any work is like visual planning. Adding it to old projects highlights a lot of unknown issues.

VSCode - right click a keyword > go to definition made me more comfortable navigating code written by other people.

</comment><comment><USER132> \- Debugger - doesn't matter which one - just stop using echo / print for complex debugging.

\- Good IDE - I prefer Jetbrains products, once you learn all the shortcuts for the various functions it just makes things much faster than constantly switching between windows.

\- Sublime text - Not as an IDE but columnar editing and fast construction / munging of data files is crucial for efficiency

\- Linux / Bash / Shell - learn the tools - sure you can write a script to do most things but learning how to pipe some commands together to get some certain output is universally useful. Learn the basic VIM key bindings, you should be able to comfortably copy,paste,save,select etc

</comment><comment><USER133> Docker. Being able to develop/ deploy code across a team and business is invaluable.

<comment><USER134> 100%.. for all the crap Docker gets these days, it has been a great tool for my software dev processes.

<comment><USER135> I don't know how the infrastructure was before docker was introduced, but for me it made things more miserable. Build times are longer, if you work on OS X it eats up battery and causes it to heat up (because on OS X it runs inside of VM). Makes things so much harder each time you make change you have to rebuild it to run it, unless you do some tricks that aren't always possible in all languages. You can do development inside of a docker, but that also has its own issues, primarily you can't use your fancy IDE.

</comment></comment></comment><comment><USER136> MacBook Pro.

After years of dealing with a Windows workstation, I went into credit card debt to purchase a quality laptop computer for my development needs.

I have had the same one for 6 years and found little reason to buy a new MBP.

<comment><USER137> Lenovo ThinkPads are similar in build quality and processing power while being significantly cheaper and they have a usable keyboard. Same for Dell XPS, I believe, but my company is using ThinkPads.

Windows is usable even for node and git development nowadays.

<comment><USER138> Can I ask if you've tried using one with Linux (Ubuntu or Mint)? I'm thinking of getting a ThinkPad next but I would prefer to use Linux over Windows and I'm wondering how well it runs Linux.

<comment><USER139> Thinkpads are very popular among the Linux crowd.

The only thing that doesn't work in mine is the fingerprint reader.

<comment><USER140> Yes same here. It works 1 time out of 10. Really annoying

</comment></comment></comment></comment></comment><comment><USER141> Learning how to use the compiler and type system (if your language has them) to get as close as possible to "if it compiles, it works", is invaluable.

Novice programmers just want the code not to error out, and compile, they just want the compiler errors to go away, while more experienced programmers learn to use the errors as a todo list of sorts, at first, then as a guide for refactorings and fixing bugs.

Learn to harness the compiler and type system to help you, and your coding will improve 10x in both velocity and quality.

</comment><comment><USER142> NCrunch: [https://www.ncrunch.net](https://www.ncrunch.net)

It has helped me so much in applying TDD rigorously in every app that I write by giving me very quick feedback on code I write.

The simple fact you can refactor something and within seconds know if everything still works is a massive time saver and that allows me to write better tests. It also makes flaky, slow and coupled tests visible as you get used to the speed of test execution that the "bad" ones jump out at you.

Well worth the license

</comment><comment><USER126> Foreman

[https://github.com/ddollar/foreman](https://github.com/ddollar/foreman)

When I learned Ruby a while back. I know it doesn't sound like much, but it was the first tool I'd used in development that showed me _how_ I develop is critically important.

It's just a simple tool to start and stop several tools in the background, streaming the logs to all of them in one place. At the time, I'd never seen anything like that and felt like I'd been doing it wrong for years.

</comment><comment><USER143> \- vim

\- grep (now using ripgrep)

\- code navigation

\- rust

\- functional programming (scheme, Erlang, Haskell, Elixir, etc; structure and interpretation of computer programs).

</comment><comment><USER144> Understanding that this whole industry is a giant house of cards, bs stacked on top of bs. Don't take anything personally, memorize the language needed to succeed

</comment><comment><USER145> Years ago I switched from Mac OS/Apple when I became a developer/data scientist to linux based system. (ubuntu)

I understand there are similarities between MAC OS and Linux... etc. Being on the same OS as most of the web servers saved me time in learning the basics of linux, bash, etc.

Also at the time I couldn't afford to keep buying new software license.

The only enterprise software I use is Navicat for user frienldly interface into databases.

<comment><USER146> In a similar vein, I am a primarily a mac user today after growing up on windows and linux (personally and for developments that run on linux as the end-system). I am quite confident that already having an intimate familiarity with Unix is what really unlocks MacOS as a powerful developer environment. I find myself much more appreciate of the positive differences that it provides over Linux and BSD, and much more understanding of deficits and things it won't let me do than I think I would be without that familiarity.

</comment></comment><comment><USER147> > What have you added to your workflow that's made you much more productive?

A second monitor and tiling window manager (or in my case Magnet, which adds simple tiles to MacOs).

When I added a second monitor to my setup my productivity exploded. It's just really nice to have one window full screen in my IDE and the other window with reference material, a shell, scrolling logs, etc.

Never having to switch away from the code is huge.

</comment><comment><USER148> Jetbrains tools help point out better ways to do the same task and learn about new language features by identifying slow or compatible code then instantly refactoring to the better or newer version for you. It makes learning new language features easy because it gives you examples in context with code you're familiar with. (among many other ways the jetbrains tools are great)

</comment><comment><USER149> I wrote a blog post about this:

[http://blog.testdouble.com/posts/2020-04-07-favorite- things/](http://blog.testdouble.com/posts/2020-04-07-favorite-things/)

Outside of that, I'd say linters and code formatters have a huge impact on my productivity and code quality. ShellCheck in particular has taught me oodles about shell scripting.

</comment><comment><USER150> TODO lists for which I use org mode, but you could use practically anything. I like a text editor for this rather than an app, per se, just because it keeps me in the flow. All you need is a place to jot down what you are planning to do next and to be able to arrange the order.

Usually I'll start with pretty high level ideas. If I have a story I'm working on, I'll put the description of the story in my TODO list. Then I'll think for about 5 minutes about what general things need to get done. I'll order these by some priority (doesn't really matter usually, to be honest). Then I'll start working on the first one.

Normally I need to poke into the code to really see what I have to do. I'll often add a sub-task to my first one that says, "Figure out what to do" or something like that. Then I'll do some exploratory coding for a few minutes. As I discover what needs to get done, I write it down in my TODO.

It's hard at first to stop yourself from just writing code, but pulling yourself back for the 20 seconds or so it takes to write down what you are just about to do can be surprisingly valuable. Don't censor yourself either. It's fine to guess what you need to do and then delete stuff that you realise is unnecessary later. As you are coding, any time you think, "Oh, I'm going to need X", add it to the TODO (again, difficult to train yourself to do it consistently!)

Once you get good at this, in my experience you will be quite interruptible. Any time I get distracted, or unfocussed or lack motivation, I just look at the top think on the TODO and say, "I'm just going to do that top thing". It always pulls me in.

I don't always code like this, but every time I do I'm dramatically more productive. I _should_ always code like this, but... sometimes you want a relaxed day ;-)

</comment><comment><USER151> That's a good question, I'm curious what comes to mind, tools that have helped me as a programmer..

\- Git CLI as well as GUI - The latter for me is as essential as knowing (enough of) the commands and options

\- grep and find

\- TypeScript

\- VS Code - Language server integration like type checking as I edit, and go to definition; syntax highlight with personal color scheme - I feel so cozy writing code, the colors enhance understanding, and the aesthetics of it definitely shapes the result to be small and beautiful; remote edit over SSH; keyboard shortcut to apply prettier formatting

\- Linux real and virtual machines as "commodity" computing resource, available on (or from) anywhere

\- GitHub - It could have been anything else, but having a social platform with an ocean of open-source code to study, discuss, contribute.

\- Keeping notes in Markdown, as a kind of personal knowledge database

\- Curated collection of libraries for common needs, written from scratch, forked, or as dependencies

</comment><comment><USER152> Sonar: code formatting nagware for Java. I spent a few months being very strict with code style and it has made me permanently a more productive programmer. I used to look at my code and wonder how to improve it, now I know what to do until I'm happy with it. I've learnt to apply this to other languages. Sonar showed me how to make code consistent, that is easier to read, write, grep and work with.

An unexpected result of being anal about whitespace for a few months was productivity with large code bases.

I no longer have Sonar itself in my workflow. But I defo feel that tool made me a better programmer.

This is not really a recomendation for Sonar but a recomendation to go find a relevant code style tool and work with it until it you are no longer learning code formatting and you are learning code clarity.

</comment><comment><USER153> [https://fishshell.com/](https://fishshell.com/)

</comment><comment><USER154> * Zsh + Grep + Awk + Vim : Essentially 90% of my daily driving around my PC at work.

* ZimWiki : Have a notebook VCS'd in my home directory sync'd across my PC's. Amazingly easy way to take notes and keep track of work.

* Jetbrains CLion, Pycharm, IntelliJ : The best cross platform IDE. Bar none

</comment><comment><USER155> JetBrains products help me understand a new codebase more efficiently, and basic use of ls and tail on unix based machines help me parse log files faster. SelfControl on mac helps me block distracting websites and Klokki helps me track my time. Bear is a great note taking app that I've mostly switched to from Evernote. I like GitHub's new Android app.

In terms of actually being a better programmer, I believe anything that helps you collect or parse information about your running code and debug it will improve your life. Sometimes that's print statements, sometimes that's a remote debugging session.

My most regularly used commands are probably `ls -lt | head -20` and `tail -f' or `tail -1000 | grep`, so maybe learning a bit about pipes too.

</comment><comment><USER156> I quite like nm + ripgrep. There is a lot I don't understand about the C/Unix world (in fairness it's not all in textbooks) but this was the first step to understanding the "unix command line is my IDE" mindset which I found so odd.

Also fd-find, just plain useful.

</comment><comment><USER109> Interactive interpreters and notebook interfaces.

ipython for Python, then later Jupyter notebooks.

Firebug for JavaScript, which then got built into every browser as the dev toolbar.

These days [https://observablehq.com/](https://observablehq.com/) for JavaScript too.

</comment><comment><USER157> StackOverflow (and Stack Exchange network in general).

</comment><comment><USER158> \- visual debuggers

\- automated tools for simple refactorings (renaming and the like)

(you can read both of the above as "JetBrains" ;)

\- source control

\- REPLs

\- personal logs / "lab notes" \- keeping a record of how I did stuff for the next time I need to do something similar. "source control for non-code" kinda

</comment><comment><USER159> assert() that is not compiled away in release builds. A miracle discipline drug that makes people think through what they are trying to code.

</comment><comment><USER160> For me, not having Visual Studio, Jetbrains, etc has made life easier overall. I have to design code with low intellectual overhead, since I no longer have fancy tools detangling spaghetti for me.

So I use BBEdit and Oh My ZSH for just about everything.

For git interaction I love Fork.

</comment><comment><USER161> QBasic, everything since then has been incremental.

</comment><comment><USER162> Google + examples

I remember learning to program C in the 1990s as a teenager, and often taking a long time just to learn how to do something very simple. This was mostly because the compiler-provided documentation was sparse, and the books that I had only had a single point of view.

Now, I can Google "[language] [task] example" and read through 2-4 examples of how to do something. Then I can go back and look at the docs and they make significantly more sense. Often what would take 4-6 hours, or longer, to figure out from just the official language / API documentation can be figured out in 20-40 minutes.

</comment><comment><USER163> The _ag_ the silver searcher

As programer, finding/looking up the code takes your primary time. so after I got into _ag_ , it changes my behavior of checking the code. from somewhat _lookup_ to _searching_.

</comment><comment><USER164> A couple of tools so far not mentioned, that have been hugely beneficial to me:

1\. Copernic Desktop Search _pre version 3_. The version I use is over ten years old and still looks and works better than any other desktop search product I've ever used. Instant results when searching your file and network system, presented in a format appropriate view. Please note that the version is important here, it went from being a stunning piece of freeware to a worthy corporate product years ago.

2\. Trello. Every non-trivial task I undertake is managed through here, it's so simple and flexible.

<comment><USER165> Took me awhile, but (here it is) [[https://copernic-desktop- search.software.informer.com/downlo...](https://copernic-desktop- search.software.informer.com/download/)].

<comment><USER164> I assume they are the same ones as available through the website?

[https://www.copernic.com/en/products/desktop- search/previous...](https://www.copernic.com/en/products/desktop- search/previousversions/)

Unfortunately, from version 3 the free version was severely restricted and I assume it has been chipped away at ever since.

eg. [https://pinkeyegraphics.co.uk/copernic-desktop- search-3-a-na...](https://pinkeyegraphics.co.uk/copernic-desktop- search-3-a-nasty-downgr/)

I'm still on 2.x, it's brilliant though.

There are still legit copies floating about somewhere I'm assuming; it was a free product, it's just no longer available from them.

</comment></comment></comment><comment><USER166> Here is a similar conversation from about a month ago: [https://news.ycombinator.com/item?id=23118940](https://news.ycombinator.com/item?id=23118940)

</comment><comment><USER118> Since you mention "more productive" I'll focus on that first.

Reading the docs and example code for opensource libraries and tools I use when I get stuck, as opposed to trying to figure out how to use them myself. And using google to search for answers to question and heading to Stackoverflow if it's been answered there and reviewing all the answers offered.

It's a habit now, but it took me awhile to break my previous habit of thinking I could figure stuff out without help and I'm much more productive as a result.

As far as tools go, BBEdit is the one I use most.

</comment><comment><USER167> I'm a Windows programmer, but I use: UltraEdit - to say it's a text editor is to say a Ferrari is a car. Powerbasic - a lot of people don't know PB and Python came out the same year. Fast, powerful, full access to windows API, pointers, classes, tiny EXE's, can use any standard DLL, and can make DLL's. JellyFish - a PowerBasic IDE that is, in my opinion, better than the PB native IDE Paint Shop Pro - a far cheaper and easier alternative to PhotoShop with all the stuff I need

These are the 3 tools I use the most to make my living.

</comment><comment><USER168> if you're writing JS and don't have Prettier installed, you're missing out. It integrates seemlessly into IDEs and editors, so you can just write code without worrying about formatting.

</comment><comment><USER169> Solarized Color Scheme - You spent more time looking at your code than you see your spouse. A good color scheme reduces fatigue especially when you are working through your code for long periods.

<comment><USER170> What color scheme helps with looking at my spouse? Ba dum tss!

</comment></comment><comment><USER171> Keeping a developer journal, digitally, so it can easily be searched.

(I'm using a simple extension called `vscode-journal` in my text editor, it writes daily markdown files stored on my Dropbox.)

<comment><USER62> +1! I do this as well, in particular a debugging journal. It allows me to find solutions to problems I've hit before. It's very handy to have a recipe for a fix without having to rediscover it again.

</comment></comment><comment><USER172> Not every job needs this, but when your company has a lot of code, it helps as a newcomer to spend time writing documentation. Those who "level up" in this skill can write documentation _everyone_ understands, not just other programmers. For instance RML instead of UML: [https://seilevel.com/business- analyst-resources/rml-book/](https://seilevel.com/business-analyst- resources/rml-book/) Now, if you have BA resources on your team, or designers/UX folks, then use them. There are teams where other people do the business-understandable diagrams and you're doing technical ones. But... if your team is smaller, or the code is already written, then it's just as helpful for you, as the developer, to also be the one communicating how things work to the business and stakeholders. It will help everyone use the same terminology—simplify decision-making—and since you made the documentation while looking at the code or existing APIs, you can assure folks it is relatively complete and accurate. [https://www.youtube.com/playlist?list=PL2miG2CzrxakbZswQH-O4...](https://www.youtube.com/playlist?list=PL2miG2CzrxakbZswQH-O43G5VnJ0_CB8C&feature=share) has some videos on business-friendly documentation and SeiLevel folks also contributed to two Microsoft Press books on software requirements and visual models.

I've found that mapping out the business domain, or explaining complexity, is at least half my job sometimes. Advocating for SRE best practices seems to be the other half. ;-)

For very large systems, DSMs are interesting. [https://mitpress.mit.edu/books/design-structure-matrix- metho...](https://mitpress.mit.edu/books/design-structure-matrix-methods-and- applications) But generally extremely technical and useful only to those creating the DSM.

Oh— also ASTs. Kind of a form of code documentation, but knowing how to use AST Explorer to read and modify a call graph or source code is incredibly liberating. It's great to suggest we can make breaking changes and fix them in client code using an AST transformation, etc.

Finally, "A Philosophy of Software Design" was a nice quick read that I still get value from, but it doesn't address how tests and ASTs could help; it covers the evergreen basics though.

</comment><comment><USER173> Flycut. It's a clipboard manager. I hit cmd+shift+v and I can scroll through my previous clipboard states. It's an amazing upgrade from a one-state-only- clipboard life.

"Flycut is a clean and simple clipboard manager for developers. It based on an open source app called Jumpcut. Flycut is also open source too: [http://github.com/TermiT/flycut"](http://github.com/TermiT/flycut")

<comment><USER174> If you're using Windows 10, you already have this: press Windows-v.

The clipboard can also be shared across your Windows devices.

</comment></comment><comment><USER175> In mainframe ISPF, F1 is usually help and F2 split screen. I have changed that like with F1 when I keep my cursor over a dataset it going into that dataset in view mode and with F2 I have made to swap list it shows all ispf screens I have open.

Swapbar at the bottom of the screen and in SDSF always have SET DISPLAY ON.

Other than that, its hardware lapton keyboard type. I am faster when pgup / pgdn and home/end are separte keys rather than combination of fn and other keys.

</comment><comment><USER176> git blame inside of the IDE.

line numbers, jumping to lines. shockingly this isn't default in IDE and I frequently still have to learn how to enable it.

autocomplete and quick way to get a list of available methods for an object, based on the actual library or things the object inherits. Javascript IDEs seem to just show a random list of frequently available functions, instead of the actual ones indexed - likely because they are all the same type.

</comment><comment><USER177> JSLint hands down. There is a lot of sloppiness in JavaScript and that tool's motto is: _JSLint will hurt your feelings._

The idea was a heavily opinionated code validation tool striving to make code subjectively cleaner and clearer for strangers to read. Many people stopped using it because they claimed it was too opinionated, even though every other super popular/trendy JavaScript tool claims to be just as opinionated.

</comment><comment><USER178> If you're a Java developer and learning pointers I recommend using the Java Visualizer.

[https://cscircles.cemc.uwaterloo.ca/java_visualize/](https://cscircles.cemc.uwaterloo.ca/java_visualize/)

Copy and paste the class you're working on. Include a main() to act as a test driver and then let the Java Visualizer step through your code showing you exactly what is going on.

</comment><comment><USER179> Sublime has definitely increased my productivity and if I have to select one command, it would be the ability to select and update all instances of the word - [https://stackoverflow.com/questions/12162047/how-to- select-a...](https://stackoverflow.com/questions/12162047/how-to-select-all- instances-of-selected-region-in-sublime-text)

</comment><comment><USER180> The single biggest contributor: vim. Not relying on fancy IDE's with smart autocomplete and all that. You end up learning the internals of a language/library without relying on the IDE to do it for you. It became my weapon of choice around 2009-2010 and now I can't remember the last time I had a syntax error. Browser for documentation and vim is literally all I need.

<comment><USER181> Just for reference, vim does have built in completion. <C-p> and <C-n> in insert mode will complete a word. Also in insert mode <C-x><C-{n,p,l,f}> are contextual completions (see :h ins-completion for full list, I suggest not using the dictionary because it takes awhile). I have found that contextual completion has changed how I program in vim and it seems to be one of the lesser known features. It is way more powerful if you're using buffers/panes/tabs, which all three have greatly improved my programming as well (in different ways).

</comment></comment><comment><USER182> The Pomodoro technique has helped my productivity more than anything. So much so that I built Timmy ([https://timmytimer.com](https://timmytimer.com) ) and added social features for some added motivation (all timers are public - <USER4> of it like "Twitter for productivity"). Free and no login required if you want to try.

</comment><comment><USER183> I've had a few people newer people reach out on how to level up recently, I recommended:

\- vim, but more of the hotkeys than vim itself for me (ex: idea vim). Productivity gains + always have a usable text editor in any env (ssh, local, etc)

\- clean code book, to help know what good code looks like, and gives structure to shoot for, and gain opinion on why one way looks better than others, or not

</comment><comment><USER184> intellisense and friends.

As a junior developer, method documentation and autocomplete on demand are crutches i leaned on VERY heavily with great success.

</comment><comment><USER185> \- Google

\- Pen and Paper for scribbling thoughts

\- Bicycle in green areas

\- Javascript - closures, async/await, JSON

\- SQL - Designing a normalised schema before coding clarifies relations

\- Docker - just because it forces you to think about the dependencies of your code explicitly

\- Evernote - improves my thinking and cements learning

\- JetBrains IDE - I pay a small amount to not have to deal with a mishmash of plugins competing with each other when moving between languages.

</comment><comment><USER186> Do everything in your power to find out what's actually happening with a bug; don't just guess.

\- SQL

\- Your metrics system's query language

\- jq

\- sort / uniq

\- grep

\- awk

\- pyplot

\- mapbox (if you have geospatial data)

\- your environment's canonical profiler, and how to connect it _in situ_

\- how to poke the relevant APIs with your bare hands (curl, grpcurl, etc)

\- how to MITM and inspect the communications between your components (wireshark, charles, certificate trust stores, feature flags to disable pinning, etc)

</comment><comment><USER187> Your preferred language's debugger. It really does show in coding interviews who has control over their environment and can debug rapidly. It doesn't matter if it's rudimentary pdb (basic python debugger) or LLdb, understanding how to structure code such that it's easily testable -and- debuggable is a hallmark of a senior developer.

</comment><comment><USER188> Experimenting.

Tools that make it easier to do experiments are good, I tend to think too much and read too much but the only way to get better at programming is to put your ideas to the test and implement them (starting with simplified versions, i.e. experiments).

Modelling is something I want to get into, alloy and tla+ look like great ways to sketch out higher level ideas.

</comment><comment><USER189> When I finished my post-graduation in "Software Engineering". I feel so productive. I can release anything with very high quality if I have the necessary resources, and rework is a thing from the past. I can control the chaos, release often and confidently still having really good nights of sleep.

</comment><comment><USER190> In no specific order or magnitude.

1\. After or during a tutorial to make a silly easy project to perform synthesis after I learn how to do something. Or using a tutorial and then basing my idea off of that.

2\. Understanding when and how to do incremental changes.

3\. Understanding the reason of source control and learning a git, subversion and CVS.

4\. Learning Python.

6\. Learning lisp

7\. Emacs and org-mode

</comment><comment><USER191> Pen & paper.

It helps me getting away from the drive to 'just give it a shot' and forces me to work so much more structured.

I still love to doodle with a pen and different color markers and it allows me to have it permanently in view on my desk with the option to add boxes and arrows as required.

</comment><comment><USER192> ReSharper, I probably wouldn't have got around to understanding LINQ without its regular prompts.

</comment><comment><USER193> I'd like to suggest CodeFights, it is great platform for software engineers to practice for cosing interview in then in turn get the desired tech jobs. And one more tool for developers is ProofHub. It is the one place for all your projects, teams and communications.

</comment><comment><USER194> Focusing on my habits and practices over tools and technology has driven more productivity and sanity in my career.

Early on, finding new tools, languages, libraries and frameworks was exhilarating and something their knowledge was I cared deeply about and worked towards. And soon, I cared more about the tools and the language than the problem itself. Caring about the medium caused more pain and wasted time than joy and productivity when any one of them broke, when they didn't do what I wanted them to do, when I found a new tool that was older and more mature than the one I used, when someone disagreed for no good reason, when someone used a worse tool than ones I knew. I have wasted hours toying around with shiny new things only to realize later what a waste it all was. They all promised, never delivered.

The point where things got better was when I started keeping simple logs.

At work, it was mostly putting into words the problem I was facing, why it was interesting, how have others solved or avoided this, what possible solutions I could find, ideal and realistic solutions, pros and cons of each, whom should I convince for this, who can help, why would they agree or oppose. As things progressed, I kept adding updates and how things actually turned out. In personal life, its been about people and projects. People I've met, people who have helped me, people whom I'm indebted to, people whom I hold dear and those that I keep away from, memories and arguments, what I'm grateful for and what I want to change.

They are interesting to read after the fact. I've learned more from this practice than any person, blog or book. I've been more productive when I see a pattern emerge and going back to how I handled things before. Highly recommend it. Moreover, It helped me find good and bad habits, how I respond to what happens around me, what gets me worried and upset, what makes me happier, more productive. The 'right thing to do' is obvious looking back now but never make sense looking forward. What seemed like promising projects did not turn out so, People who seemed like friends, weren't.

So what tool did I use for this? Email. I kept drafts, one for each idea, problem, story, lesson learned etc across the different email accounts I had. When they were good enough, I'd sent them over to a separate email account to keep it all in one place. Ironically, I started keeping logs after getting frustrated with a good way to keep my notes.

Sun Tzu would say "Make the enemy fear not the weapon, but the hand that wields it."

</comment><comment><USER195> regular expressions. Both in programs, and in text editors that support regex, where I eliminate the need to write some small utility program by using regex instead. Combine with sed & awk and it's an incredibly powerful combination.

</comment><comment><USER196> If you can call them a tool, tests would be close to the top of my list. One of the most important metrics for productivity is how quickly you can get feedback if something you did worked. A fast test suite is great for that.

</comment><comment><USER197> * Arch Linux / Manjaro. AUR is a great resource for the latest packages

* i3 / sway. I've built a number of custom patches on top of it.

* Windows Aero Snap - a close second

* MacOs - Yabai + skhd a very distant third. Mac doesn't just play as well with tiling.

* LibVirt / Virt Manager / CockPit / VFIO. I have a number of VMs emulating mac, windows, and linux. My workstation is all three in one. I also have a local kube cluster spun up via the libvirt api.

* JetBrains - Tool Suite They're tooling is phenomenal

* vim / nvim - My secondary editor for quick changes.

* Visual Studio Code - Primarily for remote sharing work spaces.

* Git - I keep almost everything in a git store of some sort.

* zsh and oh my zsh, great plugins.

* Kitty - terminal with the kittens plugins is great

* Direnv + EnvFile, dynamic loading of container env vars on entering a directory

* GitLab - Despite it's warts the best dev ops cloud agnostic platform I've used.

* Kotlin - I'm able to do pretty much everything in this. From vim over ssh or jetbrains. I use it for infrastructure, k8, mobile, web, and back end.

* Gradle - I curse at it a lot, but less than other build systems. I have templates that allow me to quick start any of the above templates.

* Remote Desktop - I keep a cheap dedicated server I RDP for heavy work loads while away from my workstation

* Reg Ex Pal - to validate reg ex

* Functional Programming

* Markdown / Restructured text - Great way to write docs and draft architectural plans

* MermaidJS, Lucid Chart - Easily embedded in markdown to provide graphs of architectural patterns.

* OpenAPI/AsyncAPI/GraphQL - Schema driven design let's me write the schema first, then generate type safe routes for the server, and clients for the consumers (web/mobile)

* Avro, Protobuf, Json Schema - For defining messages going across the wire.

* Containers - I started with solaris zones and it has been vital to my workflow.

* Docker Compose - This is the lowest barrier to providing a container stack for local dev. Next would be KIND.

* Docsify, Sphinx / etc. Easy way to add architectural docs next to the api docs as part of git pages.

That being said, I generally am unable to use a majority of these in my day job. So I'm operating much slower than I'm capable of.

</comment><comment><USER198> Extra RAM for your brain - whiteboard film surface on your desk + 4 monitors.

<comment><USER199> Interesting. How does that work when you want to rest your forearms while typing?

<comment><USER165> Plot twist, user has no arms.

</comment></comment></comment><comment><USER200> Bazel. I really like the workflow of how it only selectively runs unit tests.

</comment><comment><USER201> \- a good IDE (contains debugging, code look up, code completion, automation of boring parts like selective recompile, refactoring, linting etc etc)

\- version control (unlike you, mostly the basic parts, the safety net)

\- testing libraries

</comment><comment><USER202> Read code. Every code. All the codes. You are striving to learn strategies for organizing abstraction. Tools are great but your thinking will move faster with a larger vocabulary for organization.

</comment><comment><USER203> \- git: specially branching, rebase, and GitHub PR etiquette.

\- regex: the deeper topics such as backtracking, look behinds, etc help too.

\- How DNS works: how they work, TTLs, etc.

\- How TLS works: performance and security tweaking.

\- SQL: modern SQL can do quite a lot!

</comment><comment><USER68> Pytest => [https://docs.pytest.org/](https://docs.pytest.org/)

Making the smallest, most granular problems out of the bigger ones is the key to vict'ry.

</comment><comment><USER204> \- Lambda Calculus, and Functional programming principles.

\- Thinking in terms of types and structure, rather than linear procedures.

\- Category theory.

\- Vim as a language for editing text.

\- Emacs (my own config w/ Evil).

\- Nix.

\- A documentation specific browser, such as Dash.

\- The latest grep flavour - ripgrep.

</comment><comment><USER205> Rubocop made me a better programmer in terms of writing clean, readable, and consistent code.

Also at the organization level no it keeps codebase consistent no matter how many programmers work on the same codebase.

</comment><comment><USER206> GDB.

</comment><comment><USER207> Magit, before I used Magit using git was a chore, now it is a pleasure.

</comment><comment><USER208> jq - I deal a lot with JSON in my work (who doesn't these days?). jq is a nice tool for transforming and extracting specific data from JSON. Like awk, it's a Turing-complete DSL.

</comment><comment><USER209> Investing time customizing VS Code. Today, I end to end manage my project from VSC: create new branch, code, publish branch, open PR. I have shortcuts for certain git commands too.

</comment><comment><USER210> FinderPath[0]. It taught me what macOS looks like in its fs.

[0] [https://bahoom.com/finderpath/](https://bahoom.com/finderpath/)

</comment><comment><USER78> * `perf top`

* `scan-build`

* [https://github.com/pwndbg/pwndbg](https://github.com/pwndbg/pwndbg), a very comprehensive gdb extension/config.

</comment><comment><USER211> Apple II, TRS-80. Quake engine. Haskell, F#, Rust. Type theory, domain and test driven design. Philosophy, economy. Linux. Physics engines, PyTorch, GStreamer. Twitter.

</comment><comment><USER212> Docker. Which hasn't really helped me get _better_ at writing code. But my God it's helped my productivity and I'm finishing more and more side projects because of it.

</comment><comment><USER213> The big thing for me was discovering JetBrains products and how much care and thought is taken in building a product that provides the right tools when you need it.

</comment><comment><USER214> Incorporating a clipboard manager into my workflow was a game changer for me. It's basically a cache for my mind. I couldn't imagine life without it now.

<comment><USER215> Which one do you recommend?

</comment></comment><comment><USER216> While programming in Elixir, iex. I spend most of my time in the REPL, testing my functions, learning new features, and of course the recompile command!

</comment><comment><USER217> [https://en.m.wikipedia.org/wiki/AspectJ](https://en.m.wikipedia.org/wiki/AspectJ)

</comment><comment><USER218> Watching Rich Hickey videos.

Cider REPL

Literate programming in Org mode

Keeping outlines of notes in org mode for everything. Being able to execute the code in those notes is pretty friggin amazing.

<comment><USER215> Could you give your top 5 Rich Hickey videos for begginers?

</comment></comment><comment> code-faster my json toolkit has been a huge boon for me, it complements jq very well: [https://github.com/tyleradams/json- toolkit](https://github.com/tyleradams/json-toolkit)

There's tools for converting between json and other data formats like xml as well as misc tools like json-diff which diffs json files and formats the output as json.

</comment><comment><USER219> New Relic, APM is important, and grokking this or a similar tool (Datadog, AppDynamics, Solarwinds) can only make you much more productive.

</comment><comment><USER220> Being able to read code from similar projects in Github.

It allows you to do better design, learn how to write readable code, and allow you to move faster.

</comment><comment><USER221> * fuzzers

[https://blog.regehr.org/archives/1687](https://blog.regehr.org/archives/1687)

</comment><comment><USER222> IDE features may be my biggest productivity boost.

</comment><comment><USER223> Learning how to use type holes has really helped a lot in recent years. Learning how to grok documentation and source code as well.

</comment><comment><USER224> \- xmonad

No distractions and I can program my window manager to organize my windows.

\- git

I was once fan of mercurial, but I like git better now. Everytime I find new interesting ways to use it. Also outside it's traditional uses.

\- (n)vim

I use other editors, but I turn them into vim. It is easy to use and makes typing in your solution of your problem in the language of choice less boring. (The coding part)

\- awk

God, I love awk. It is like the swiss army knife of unix. You can do everything with it.

\- latex

If I want to order my mind by writing a bit or making a nice design, create some documentation. Latex is your friend.

\- dot

If I want to sketch something, dot will help. Dot also helps with other stuff, dependencies between things. It is easy to write out a dot file.

\- profilers

Any fucking profiler will make your a better programmer. It will test your assumptions about the underlying model.

\- debuggers

You can't do things without them ^_^

\- static type systems

Learn to think in types is a big win and not a weakness. You can encode properties in type systems.

\- mathematics

Learn it, use it. It will give you new ways to think. E.g. algebra is about composability. So first thing I do is when I have a problem is write out the data types and think out its algebra. And it keeps your mind active, just churn through some mathematical topic once in a while. I loved type theory. Lambda calculus, abstract algebra, linear algebra and am know learning point set topology.

\- esoteric languages

They are fun and force you to rethink what computation is. Design a couple yourself. I can compute in any language with weird constraints. I just need to build a machine in it.

\- keep playing around

Not everything you do needs to be a project, just make something useless. E.g. I like jotting down shit in netlogo, which is utterly useless, but fun to watch.

\- zsh

Where am I without you? ZSH can interface with everything. I write small tools from finding ec2 instances in the cloud by tag to presenting searchable menus binded by keys with a little help of small programs.

\- the core utils

Learn them by heart, you will never have to click ever.

\- Learning new programming paradigms

I loved stack based programming, functional programming, thinking in excel (data flow). There is no one solution to everything.

\- domain specific languages

Learn to make them, it is fun and an extremely powerful tool in the programmers toolbox.

\- parsers

Don't be afraid of them, they are your friend. And often easier than regexes.

\- learn how to search

Big skill, not everybody does this right.

\- Programming notebooks

Why is this not standard? Mathematica is brilliant with this and while I don't like python, but jupyter is very good.

\- IDE's

They are useful. Don't be vain.

\- Make designs

Plan what you are going to make. That helps a lot.

\- Property style testing

Checkout quickcheck ^_^

That is my list. It is not exhaustive.

</comment><comment><USER225> "a much better programmer" != "much more productive" (At least from my point of view)

I'm going to answer on the latter, because I can't say if I'm a much better programmer than, say 5 years ago (But I blame that to the fact that the product I develop is "frozen" and I don't do much than small bug hunting and / or forensics when something goes wrong; or "janitoring" as I refer to it nowadays).

In no particular order, these are the tools that over the years have made my life incredible easier and let me focus on the problem at hand, and not solving the problems I had to deal before solving the problems I had to solve:

1\. Git. 12 years ago, I was the sole developer at my company, and I had to strong arm my boss (And company owner) to ditch CVS for Git. Probably one of the best company decisions I was responsible off (Being the next one getting the company on Slack)

2\. xDebug. When I discovered xDebug (PHP) my life changed overnight. As I said I don't do much coding these days. When I was full on coding, I had hacked a way to be able to work with xDebug with a small class made specifically for debugging, that allowed me to do "code hot reload" until I hammered my code in place.

3\. Any tool by JetBrains. I have a lifetime licence for PHPStorm 2016.x (You get that after paying the license for a year). And I currently am a paying customer of WebStorm. I plan to keep paying for it until I make it to the year, because then you get a lifetime license. I know IDEs and editors are bound for flame wars, but honestly, for people like me that are not really invested in getting an expert command of their tools, JetBrains gets you the most bang for your money right out of the box.

4\. Virtual box, then Vagrant, and these days docker. Virtualization for me was the best way to fix the "but it works on my box" syndrome some 10 years ago. I discovered VBox and then vagrant, and I've been a happy customer for years. I've been eyeing docker for some time now and the quarantine gave me the time to investigate it on my own. With VBox / Vagrant I had the problem that when moving I had to move large archives for the different disks I had accumulated over the years. Now with docker I just need to move the data, the code, and the docker file that builds the container that I use. I also use docker to learn other things like node and python. For python I've been using Miniconda for some time, but I didn't like the way it handles - nor had the time to learn how to correctly - environments. Same with node and the node_modules hell. With both, I use small set up files where I store a default configuration so whatever package I get is saved on shared volumes on my machine, and the same on code. That way I decide what to share where, and getting rid of something is as easy as removing a folder.

5\. Linux. I started learning me some Linux when I started this job 13 years ago, and over the years it grew on me. Last year my notebook disk gave up, and when I changed it I installed Debian on it. This year the same happened to my desktop box, and I did the same. Even thought there are programs that I do miss from Windows the reality is that many of them I can run with Wine, and the others get replaced for something else that is, if not better, at least on par with their Window counterparts. And I keep finding tools that are incredible awesome (Like mpv for video playing)

</comment><comment><USER226> \- Regex. I don't think anyone's a true developer until they've mastered using regex where globbing would be used. Using regex for globbing is an excellent place to start learning.

\- Unit testing. No true developer can call themselves such until they can programmatically verify that their code works to some explicit specification.

There's tons of other things that are bonus points. But I wouldn't call anyone a true developer until they understand and use both of those.

</comment><comment><USER227> kdb/q: its a programming language more than a tool. But learning it has made me more efficient in other languages. It's vector approach to programming makes me think about how to leverage similar features in python for example. itertools library in Python is mostly inspired by APL, an ancestor of q

</comment><comment><USER228> Still no mention of clipboard manager?

</comment><comment><USER229> Three books:

* Nonviolent Communication

* Crucial Conversations

* Writing Without Bullshit

</comment><comment><USER230> In recent years:

1) Ripgrep

2) Upgrading my Lenovo T430 laptop to a P53

<comment><USER139> My only beef with ripgrep is that "rg" is only a small typo away from "rm".

One time I almost deleted my working directory but luckly I had passed the -i flag for case insensitive search :)

<comment><USER231> Have you considered creating an alias - such as "rip" or "grrr" \- for using ripgrep to help avoid that concern of rg vs rm?

<comment><USER139> The "rm" thing was only (almost) a problem that time because I had passed a list of files to ripgrep, instead of passing it a list of directories to do a recursive search. rm by default don't erase directories.

But now that you mention it, creating an alias gr=rg sounds like a no-brainer. Thanks.

</comment></comment></comment></comment><comment><USER232> stgit Kind of like quilt on top of git. It lets you keep a lot of balls in the air all at once with very little effort. [http://www.procode.org/stgit/](http://www.procode.org/stgit/)

</comment><comment><USER233> Doing lots of small test or benchmark programs to better understand how the language works.

</comment><comment><USER234> All of the following made me a better programmer:

1) Functional Programming

2) VIM

3) Kinesis Advantage

4) tmux

Really, I can't think of programming without those four tools.

</comment><comment><USER235> Focusing on "more efficient" in "better":

\- emacs: works for me to code in R, python, connect to remotes, etc

\- keyboard shortcuts: got started with them early, and never looked back. Bonus: linux/macOS/emacs text navigation works across all of them (ctrl-f, ctrl-b, ctrl-a, ctrl-k, alt-delete, etc)

\- git: managing file versions and file diffs (!)

\- GitHub: terrific for project management, even when I'm the only one on the project ;)

\- CLI utilities that I love:

        - ag, a better "grep"
        - fd, a better "find"
        - tldr, a better "man"

My dotfiles and new box setup: [https://github.com/pavopax/dotfiles](https://github.com/pavopax/dotfiles)

CLI tools:

[https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)

[https://github.com/sharkdp/fd/](https://github.com/sharkdp/fd/)

[https://github.com/tldr-pages/tldr](https://github.com/tldr-pages/tldr)

EDIT: formatting

<comment><USER235> ... then, for data science tasks, these were a revelation:

\- R's dplyr and wider tidyverse \- python scikit-learn

They are terrific APIs that, after I've gained deep familiarity from experience, are literally a joy to use for me and feel like I've "leveled up" (way up)

</comment></comment><comment><USER236> For me it's definitely Elixir

<comment><USER237> Interesting. Why? What does it have (or haven't) that made you a better programmer?

</comment></comment><comment><USER238> Well, it's certainly not tools that let me _add_ lines of code.

</comment><comment><USER239> Tmux, Emacs, Perl, jQuery.

</comment><comment><USER240> An automated test suite with snapshots and contracts for data.

</comment><comment><USER241> * version control

* static typing (golang)

* unit tests

</comment><comment><USER242> Wait I thought everyone was switching to dwm now..

</comment><comment><USER243> xargs! Instant concurrency for small scripts.

<comment><USER244> Could you go into more detail about how you're using xargs? I'm having trouble understanding how it can be used for concurrency.

<comment><USER245> xargs --max-procs _N_ (or -P _N_ ) starts up to _N_ instances of the called program in parallel, at least with GNU xargs.

</comment></comment></comment><comment><USER246> The linter has been my best programming coach.

</comment><comment><USER247> fzf tmux Vim+plugins+ language servers. lldb/gdb, languages repl's in general(ie. ghci for haskell)

</comment><comment><USER248> * AWK - I read "The Awk Programming Language"[0] cover to cover. It's a very well written text, and it not all that long. The examples are very impressive. In terms of bang-for-the-buck of learning tools, AWK has definitely given me the most mileage. I probably use it at least a dozen times a day just for little things. However, you can wield it to write some very powerful scripts in very short amounts of time.

* Make - I use Make for almost every project I write, even if the rules are just .PHONY shortcuts. Make solves a huge set of problems relating to the order in which things need to be run/built very well. There are arguable better tools, but Make is widely deployed, widely used, widely understood, and solve the problem well enough for a _lot_ of small to medium projects (and some large ones too!). I got asked about it enough that I wrote an introductory guide for it[1] (disclaimer: self promotion of my own site, but I don't have any ads or make any money). If you feel like Make has a lot of legacy crust built up over the years, you should read[2].

* Graphviz[3] - a huge number of ad-hoc data structures that you will build for your projects can be hard to visualize, Graphviz makes it easier. One tactic I've found useful is to loop over nested structs using their memory address as the identifier in Graphviz, struct fields as text annotations, and nested struct pointers as outgoing links. This might sound fancy, but you can probably write an export_to_graphviz() function for your project in under 50 lines of C. Because the syntax is simple, it's very easy to generate Graphviz from pretty much any language out there.

* Xpath - if you've ever wanted to do even simple web scraping or XML parsing, do yourself the favor of learning Xpath. It's a very powerful way of querying XML-like documents. I learned it by writing bots in Selenium for an internship, but nowadays I mostly do very simple web scraping for personal projects. To that end, I wrote a little tool[4] to grab the contents of a page, run a query, and print the results out on the console.

* Not a tool per se, but pick some kind of "personal knowledge management" type of solution and use it religiously. I like Joplin[5], but there are a million out there (Evernote, OneNote, ZimWiki, TiddlyWiki, VimWiki, Emacs Org-Mode, and many, many more). Being able to refer to earlier notes is invaluable for long-running projects.

* Also not very specific - learn the scripting language for your platform. In UNIX-land that's sh (or Bash), and in Windows that's PowerShell. Bash and PowerShell both have benefits and drawbacks, and you probably shouldn't write "real programs" in either. But knowing how to script whatever platform you're using buys you a lot.

* One more, also non-specific one - learn an interpreted language. Nowadays people like Python, but Perl, TCL, Lua, JS, and others could all be valid choices. These are great for prototyping ideas that you will later port to the language you really use (if it isn't on that list already), or for writing little tools or utilities for yourself to use. Which one you choose will depend on what library ecosystem is most relevant to your work.

0 - [https://www.amazon.com/AWK-Programming-Language-Alfred- Aho/d...](https://www.amazon.com/AWK-Programming-Language-Alfred- Aho/dp/020107981X)

1 - [http://cdaniels.net/2017-07-15-guide-to- make.html](http://cdaniels.net/2017-07-15-guide-to-make.html)

2 - [https://tech.davis-hansson.com/p/make/](https://tech.davis- hansson.com/p/make/)

3 - [https://graphviz.org/](https://graphviz.org/)

4 - [https://git.sr.ht/~charles/charles- util/tree/master/bin/quer...](https://git.sr.ht/~charles/charles- util/tree/master/bin/query-webpage)

5 - [https://joplinapp.org/](https://joplinapp.org/)

</comment><comment><USER249> * Linux

* i3

* git

* Elixir (functional programming concepts)

</comment><comment><USER250> magit

</comment><comment><USER251> perf and pprof.

</comment><comment><USER252> Emacs, Magit.

</comment><comment><USER253> Git and grep!

<comment><USER230> I use ripgrep (`rg`) much more than I use grep now. Wish I'd discovered it sooner.

<comment><USER231> Oh yeah, 100% this!

</comment></comment></comment><comment><USER254> Postico

</comment><comment><USER255> Linux

</comment><comment><USER256> PyCharm

</comment><comment><USER257> Node Red

</comment><comment><USER258> Listening

</comment><comment><USER259> Pycharm

</comment><comment><USER260> Emacs.

</comment><comment><USER261> Github

<comment><USER262> Grubhub

</comment></comment><comment><USER263> Free Software

</comment><comment><USER264> So much useless information in this thread.

The best way to become a better programmer is to read more code and understand what it does and think about different ways to implement the same feature.

Programming is problem solving at its core. Everything your mentioning is secondary to achieving that goal.

<comment><AUTHOR> You're right, let's go back to punchcards.</comment></comment>