What is worth spending money on for performance with limited time?

Midnight Otter · 10 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. If two options look equal, choose the one that is easier to reverse.

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

Maia Brown · 9 likes

Helpful correction.

Aisha Rahman · 4 likes

I laughed, but you are not wrong.

Sara Ahmed · 0 likes

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

Rizky Pratama · 0 likes

This is the kind of disagreement I like.

Jisoo Park · 3 likes

Short answer: yes. Long answer: also yes.

Noah Miller · 0 likes

I needed the reminder to start smaller.

Cedar Sparrow · 11 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 corner shop detail changes the whole answer.

Camila Rocha · 11 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. My only addition is to make the first step visible.

Silver Fern · 8 likes

That is fair, but I still worry about maintenance.

Chloe Davis · 7 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 is more useful on a tired rainy evening than on a perfect day.

Pablo Martín · 3 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.

Diego García · 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. My only addition is to make the first step visible.

Isha Menon · 1 likes

Can you expand on that a bit?

Cedar Comet · 2 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. The practical constraint is probably the real story.

Silver Fern · 1 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. It reminds me of a very specific conversation near my desk.

Rizky Pratama · 4 likes

Adding this to my notes.

Omar Hassan · 2 likes

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

Quiet Sparrow · 0 likes

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

Mia Anderson · 1 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I used to overcomplicate this constantly.

Sofía Hernández · 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. It sounds small, but the tiny repair matters.

Tomás Gómez · 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. The social part surprised me too.

Bianca Santos · 0 likes

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

Jiho Lee · 23 likes

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

Rizky Pratama · 1 likes

@lanternPixel8 Respectfully, I see it the other way.

Piotr Zieliński · 0 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I noticed the same thing in Cape Town.

Cedar Marauder · 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. This is where I would ask one more question before choosing.