Why does debugging feel easy for everyone except me?

Ren Suzuki · 13 likes

I found this disappointing because it skips the hardest part. I would write it down before changing anything else.

Isha Menon · 0 likes

I had the same reaction to because.

Hugo Martin · 0 likes

@ishanotes I like this more than the top-level advice.

Mateo Cruz · 20 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The low-effort version is probably the keeper.

Maya Putri · 10 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I would write it down before changing anything else.

Rohan Mehta · 5 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. A little friction removed goes a long way.

Omar Hassan · 4 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. The trap is trying to optimize before you have feedback.

- Write down the exact error and the input that caused it.
- Make a tiny example, then add pieces back slowly.
- Keep the final fix boring and well-named.

Come back with what happened; the details will make the next answer better.

Mateo Cruz · 4 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. The the kitchen detail changes the whole answer.

Noah Miller · 4 likes

Anecdotally, this tracks with what I have seen. This is where I would ask one more question before choosing.

Quiet Atlas · 3 likes

The vibe here is immaculate. It reminds me of a very specific conversation near the library. Good reminder that tools should serve people, not the reverse.

Brave Runner · 1 likes

@curious_sparrow90 Now I want a spreadsheet.

Siti Lestari · 1 likes

Exactly; the hidden cost is energy.

Camille Dubois · 1 likes

That made the concept click.

Diego García · 3 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. This would have saved me a lot of trial and error.

Iryna Melnyk · 2 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I would love to see a follow-up after 8 weeks.

Piotr Zieliński · 2 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. The the library detail changes the whole answer.

Nima Ahmadi · 2 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The 7-minute rule is underrated.

Grace Parker · 2 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I keep a note about architecture for exactly this reason.

Urban Panda · 1 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. The rainy evening version is even more interesting.

Mariam Al Mansoori · 5 likes

Can you expand on that a bit?

Lucas Dubois · 1 likes

Thanks, that actually helped.

Mariam Al Mansoori · 2 likes

@lucascodes38 I laughed, but you are not wrong.

Luciana Vargas · 0 likes

I was going to disagree, but your second sentence got me.

Mateo Cruz · 0 likes

Kind of wild how often going is the whole issue.

Luciana Vargas · 6 likes

Beautifully concise.

Lena Müller · 1 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I keep a note about architecture for exactly this reason.

Sofía Hernández · 0 likes

That sounds great until you add children/pets/deadlines.

Mateo Cruz · 1 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. This would have saved me a lot of trial and error.

Paolo Garcia · 1 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I learned that one the expensive way.

Brave Panda · 1 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The social part surprised me too.

Curious Mango · 1 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The cozy part is easy to underestimate.

Curious Marauder · 1 likes

Try making a tiny reproduction with no framework code. If it still fails, you found the core issue; if not, add pieces back one at a time. I learned that one the expensive way.

Rohan Mehta · 1 likes

Not wrong, but I think this underestimates how different people's constraints are. The beautiful constraint is probably the real story.

Gentle Comet · 0 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The 2-minute rule is underrated.

Rohan Mehta · 2 likes

I think both things can be true.

Quiet Fern · 0 likes

My wallet felt that.

Pixel Otter · 0 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The commute version is even more interesting.

Maja Wiśniewska · 2 likes

I was going to disagree, but your second sentence got me.

Mia Anderson · 0 likes

That made the concept click.

Arif Hasan · 0 likes

Appreciate the nuance.

Léa Bernard · 0 likes

I would log the input, the expected output and the actual output first. Once those three are visible, the bug usually stops feeling mysterious. I keep a note about java for exactly this reason.