What tools and practices have helped you work better as a developer?

My Jetbrains IDE is bar none the biggest productivity boost for me. Even after VScode arrived (and got better, much better, over the years!), Jetbrains still has so many built-in features that I find it hard to code without, and I happily pay for my own subscription.

Aside from that, I think the thing that's helped me the most is simply over-commenting, everywhere and all the time. I leave a quick note for other devs (and myself) for every helper func, even if it looks trivial to me. And for anything complex, I try to leave detailed line-by-line comments that any junior dev can pick up. This not only helps others pick it up, it helps me myself a few weeks from now, and it also helps prevent runtime issues through what is basically as-you-go "rubber ducky" debugging, forcing me to verbalize my rationale for writing something a certain way.

And of course ChatGPT has been a moderately big help. It's not quite a replacement for another experienced dev, but it's certainly taken over 90% of my Stackoverflow and Google usage – if only for its much better natural language parsing abilities.

With these tools in place, the code mostly just writes itself if you can give me time to focus and not force me to join pointless meetings and scrum planning sessions. I can only be productive if I can sit down and focus without pointless rituals where my input isn't even needed or asked for.

A small piece of advice. Review your changes using a nice GUI diff tool immediately before committing anything to your repo. Lately I use Github for Windows for the tool, but that’s unimportant as long as the tool clearly shows all changes to all source files which will be committed.

It’s an easy thing to do, but IMO helps software quality tremendously. 60% of times I just read my changes and commit them as they are. In 25% of commits I spot something minor like typos in comments, and fix. Most importantly, for the remaining 15% of them I notice some important issues which need to be fixed.

Reading git log later, or delegating to other people, doesn’t work because timing. I commit my changes immediately after making these changes. This means I still remember what the code in question does, and why I changed what I did.

GIT - back in the 1980s, I would use PKzip to archive up all my Turbo Pascal source code into a file, and put it on a numbered floppy disk to back up my source code.

SVN was a step forward, but GIT is the bees knees. I've used it to keep a workstation without networking up to date and synced with GitHub. The whole ecosystem is amazing.

Learning to type properly. Even if you can bump up your typing speed 10 wpm. Over the life time of a software engineer it's worth it.

Learning Vim key bindings and using them regularly

Studying topics from first principles instead of corporate documentation

Learning the history of programming and computing

Moving beyond competency and becoming highly proficient at the command line

Understanding git backwards and forwards

Being able to explain every concept in computing from the lens of the broader field of engineering

Being able to write regular expressions without consulting too many resources

Effectively composing Unix programs to get a larger task done

Reducing every task to the absolute basics, to demonstrate a “proof-of-concept”

* I’m not claiming to have mastered any or all of these, but they do serve as my “North Star” guidances when figuring out which direction to advance in this career

I started coding by just dropping print statements in my code to debug it. In college I was introduced to gdb and I never looked back. I will not code without a debugger now, it's such a waste of time dropping print statements in code and re-running. I'm always surprised when I learn about some language I'm interested in and finding out that the standard way to write code is in a text editor without an LSP implementation and just print debugging everywhere. I don't even start trying a language if I can't put breakpoints in somewhere.

REPL driven development. I was doing it before Clojurists were talking about it. It's the most efficient way I know to build large systems -- by composing smaller pieces whose API and behavior you are deeply familiar with through interactive fiddling.

Relatedly, learning to use Emacs with power and precision has been a boon to me, though the Emacs skill ceiling is absurdly, absurdly high and there's so much I've yet to learn. Programming the editor to do repetitive work for me, not just using packages and customizations, is key.

Literate programming has been a tool in my toolkit for documenting my thoughts as I solve an interesting problem. These days I use org-mode, but noweb has been useful in the past.

I've gotten considerably better at debugging complex issues after resolving to always put in the work to find out what is really happening - build in the observability, export the data, write whatever analysis tools you may need. Wasted so much time earlier in my career on blind guesswork.

use https://github.com/Aider-AI/aider clone any repo, use aider for Q&A about the code. Use aider to add features to the repo and do experiments with the code. Its a very interactive way to learn

I use grep.app to see how things are used in practice, especially minimally-documented or complex things like property-based testing macros. More recently ChatGPT helps a lot with this, but I still like grep.app for looking into production code.

for me rescuetime.com and hubstaff have helped in terms of productivity, I also have written a couple tools myself to make myself more productive over the years, vim also comes to mind, there are several ways to be more productive, one just has to care enough.

start the day standing up and try not to sit all day. some days are better than others

Drawing.