Which tools have made you a much better programmer?

- 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... )

- 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 )

- 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.

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.

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.

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.

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.

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....

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/ 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.

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.

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

TabNine: 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?).

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-..., my presentation for an intermediate-level example (https://news.ycombinator.com/item?id=16708392) or my project to build a programmable strace alternative (https://github.com/nh2/hatrace).

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.

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.

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.

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...

magit (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/) - 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/) - a 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).

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.

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

Most of my productivity gains these days has come from aligning myself and my workstation.

- i3wm (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

- yadm (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.

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.

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

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

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.

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/

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

- 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)

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.

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)

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.

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.

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.

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.

- 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.

- 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.

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.

- 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.

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) or "fd" (https://github.com/sharkdp/fd). And, Replace: with tools like 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.

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.

Emacs. Specifically Doom Emacs.

https://github.com/hlissner/doom-emacs

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.

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.

- 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

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.

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.

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. :-)

- 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

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 ;)

- 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.

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.

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.

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.

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...

- 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

Touch typing - learning it during this WFH phase, as much more communication is done typing.

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

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... This is a great clipboard manager and helps a lot with Copy-Pasting.

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.

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.

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

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

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.

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.

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.

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.

ESLint (and other linters, preferably used with the strictest rules) - while 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

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.

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

I started my career programming in Vim on VT100 terminals (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.

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.

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 ;)

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.

- 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

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

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.

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.

NCrunch: 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

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.

- vim

- grep (now using ripgrep)

- code navigation

- rust

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

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

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.

> 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.

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)

I wrote a blog post about this:

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.

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 ;-)

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

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.

https://fishshell.com/

* 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

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.

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.

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/ for JavaScript too.

StackOverflow (and Stack Exchange network in general).

- 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

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

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.

QBasic, everything since then has been incremental.

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.

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.

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.

Here is a similar conversation from about a month ago: https://news.ycombinator.com/item?id=23118940

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.

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.

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.

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.

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.)

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/ 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... 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... 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.

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"

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.

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.

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.

If you're a Java developer and learning pointers I recommend using the Java Visualizer.

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.

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...

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.

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

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

intellisense and friends.

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

- 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.

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)

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.

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.

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.

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

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.

ReSharper, I probably wouldn't have got around to understanding LINQ without its regular prompts.

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.

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."

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.

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.

* 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.

Extra RAM for your brain - whiteboard film surface on your desk + 4 monitors.

Bazel. I really like the workflow of how it only selectively runs unit tests.

- 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

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.

- 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!

Pytest => https://docs.pytest.org/

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

- 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.

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.

GDB.

Magit, before I used Magit using git was a chore, now it is a pleasure.

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.

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.

FinderPath[0]. It taught me what macOS looks like in its fs.

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

* `perf top`

* `scan-build`

* https://github.com/pwndbg/pwndbg, a very comprehensive gdb extension/config.

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

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.

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.

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.

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!

https://en.m.wikipedia.org/wiki/AspectJ

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.

my json toolkit has been a huge boon for me, it complements jq very well: 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.

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

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.

* fuzzers

https://blog.regehr.org/archives/1687

IDE features may be my biggest productivity boost.

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

- 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.

"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)

- 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.

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

Still no mention of clipboard manager?

Three books:

* Nonviolent Communication

* Crucial Conversations

* Writing Without Bullshit

In recent years:

1) Ripgrep

2) Upgrading my Lenovo T430 laptop to a P53

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/

Doing lots of small test or benchmark programs to better understand how the language works.

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.

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

CLI tools:

https://github.com/ggreer/the_silver_searcher

https://github.com/sharkdp/fd/

https://github.com/tldr-pages/tldr

EDIT: formatting

For me it’s definitely Elixir

Well, it's certainly not tools that let me add lines of code.

Tmux, Emacs, Perl, jQuery.

An automated test suite with snapshots and contracts for data.

* version control

* static typing (golang)

* unit tests

Wait I thought everyone was switching to dwm now..

xargs! Instant concurrency for small scripts.

The linter has been my best programming coach.

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

* 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...

1 - http://cdaniels.net/2017-07-15-guide-to-make.html

2 - https://tech.davis-hansson.com/p/make/

3 - https://graphviz.org/

4 - https://git.sr.ht/~charles/charles-util/tree/master/bin/quer...

5 - https://joplinapp.org/

* Linux

* i3

* git

* Elixir (functional programming concepts)

magit

perf and pprof.

Emacs, Magit.

Git and grep!

Postico

Linux

PyCharm

Node Red

Listening

Pycharm

Emacs.

Github

Free Software

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.