How the way I work/code/investigate/debug changed with time & experience

I use this metaphor when describing how I work these days.

TL;DR;

Quick feedback is king
- unit tests
- quick test in another way
- reproduce issues locally
- try things out in a small project on the side, not in the project you're working on
One thing at a time
- experimenting
- refactoring preparing for feature addition
- feature coding
- cleaning up after feature coding
Divide problems into smaller problems
- and remember - one thing (problem) at a time

Example

You're working with code that talks to a remote API, you want to test different API calls to the remote API.

don't - change API parameters in code and run the project each time you test something. It takes too long.

do - write a piece of code to send an HTTP request, fiddle with this code

do - intercept request with Fiddler/Postman/other interceptor and reissue requests with different parameters

Example

Something fails in the CI pipeline.

don't - make a change, commit, wait for remote CI to trigger, see result

do - reproduce issue locally

Longer read

Quick feedback
do - write a test for it
do - isolate your issue/suspect/the piece of code you're working with
- it is helpful if you can run just a module/sub-system/piece of your project/system
- partial execution helps - like in Python/Jupyter or F# fsx
if you rely on external data and it takes time to retrieve it (even a 5-second delay can be annoying) - dump data to a file and read it from the file instead of hitting an external API or a DB every time you run your code
don't try to understand how List.foldBack() works while debugging a big project. Do it on the side.
spin up a new solution/project on the side to test things
occasional juniors ask "does this work this way" - you can test it yourself easily if you do it on the side
One thing at a time
separate refactoring from feature addition
fiddle first, find the walls/obstacles
git reset --hard
refactor preparing for a new feature (can become a separate PR)
code feature
if during coding you find something that needs refactoring/renaming/cleaning up - any kind of "WTF is this? I need to fix this!" try a) or b)
- a) make a note to fix it later
- b) fix immediately
```
> git stash
> git checkout master
> git checkout -b fix-typo
fix stuff
merge or create a PR
git checkout feature
> git merge fix-typo or git rebase fix-typo
continue work
```
always have a paper notepad on your desk
- note things you would like to come back to or investigate
- it gives me great satisfaction to go through a list of "side quests" I have noted and strike through all of them, knowing I have dealt with each one before starting a new task
- when investigating something I also note questions I would like to be able to answer after I'm done investigating
  - example: while working with Axios and cookies I found conflicting information about whether Axios supports cookies. After the investigation, I knew that Axios supports cookies by default in a browser but not in Node.js
Divide problems into smaller problems
example - coding logic for a new feature in a CLI tool and designing the CLI arguments - these can be 2 sub-tasks

Big bang vs baby steps

The old me often ended up doing the big bang. Rewriting large chunks of code at once. Starting things from scratch. Working for hours or days with a codebase that can't even compile.

Downsides - for a long time the project doesn't even compile, I lose motivation, I feel like I'm walking in the dark, I don't see errors for a long time - requires a lot of context keeping in my mind since I've ripped the project apart - if I abandon work for a few days sometimes I forget everything and progress is lost

The new me prefers baby steps

Fiddle with the code knowing I'll git reset --hard. Try renaming some stuff - helps me understand the codebase better. Try out different things and abandon them. At this point, I usually get an idea/feeling of what needs to be done. Plan a few smaller refactorings. After them, I am usually closer to the solution and am able to code it without a big bang.