Reducing Friction in Development Environments

As my 27th year of getting paid to create web applications starts to wind down, I reflect on how hard I work to try and create a development environment experience (heh, that sounds so pretentious when spoken out loud!) that has as little friction as possible.

Late in 2023, what does that look like for me?

Learn your editor

I have lost count of the number of editors I have used over the years. Some I would never touch again. Some I felt changed how people built all future editors. If it was available for my Mac, I was at least trying it out.

One thing that did eventually change was that I settled on one editor (well, sort-of) and dedicated time to exploring it's other features beyond just editing text.

Just to be clear, I really don't care what editor you use. I just think you should pick one and learn it really well.

I do flip back and forth between PhpStorm and NeoVim, depending on the task. Years of using Vim and NeoVim has imprinted both modal editing and Vim keybindings into my muscle memory, so I have Vim bindings installed for PhpStorm.

If your editor has an extensive list of keyboard shortcuts, take the time to learn all the common ones. While I'm not some kind of productivity grifter, I do feel like reducing the number of times your hands leave your keyboard can only be a good thing.

I should probably stop grabbing my phone so much too.

Learning how to use your editor and how easily it can integrate with other tools is, for me, the first step towards reducing friction.

Repeatability

"Works on my machine" is both a joke and a reality when you do development work. Here are some solutions I recommend:

• Docker to create containers that duplicate production
• Nix and NixOS to make reproducible systems

The bottom line is that you can reduce friction by adopting tools that allow other people to use the same dependencies that you are using. Yes, it can be annoying and frustrating to get thing "just right", along with duplicating a production environments that relies on a ton of services. But once you have it as close to production as possible, the time to get code out of your development environment and into production is greatly reduced.

Standards

Coding standards make sure your code all looks the same. I should not be able to figure out who wrote some code by looking at it. Static code analysis applies standards in terms of how the code you wrote should be used by others. Testing standards ensure that you have confidence that the code you wrote will continue to behave in the way you expect it to.

Automation

For me, this is the one that I think a lot of developers need to embrace more. Write small shell scripts to execute multiple commands that you type into your CLI. Use Makefiles. Add things to your composer.json file so you can type composer test and have the tests run.

Everything you can do to automate repetitive tasks is one less thing you have to remember. I'd rather be working on solving a business-related problem than remembering what order I need to run these 10 commands to get my code from my laptop and into production.

Willingness to Learn

I don't know how typical I am in terms of evaluating my tools and techniques on a regular basis, but I feel like my willingness to learn new things and try out new tools that solve old problems has really helped me reduce friction.

Except for rebasing things in Git. That still gives me so many problems and I will go to my post-programming life insisting that version control systems do not need to be so complicated.

Too Much Friction Causes Fires

I think my over-arching point is that the tools you use to write code every day should not cause you problems. It's entirely possible I have learned to ignore the rough edges my tools present (Vim certainly has a steep learning curve) but I truly work on making sure a computer does repetitive actions for me as much as possible. It's not going to complain about it to me.

I hope I've gotten you to start evaluating or re-evaluating your chosen tools and find some new-or-different ways to reduce any friction you are finding in your development environments and processes.