What would you do first if you were new to Programming as a beginner?

Mateo Cruz · 338 likes

This feels like advice from a patient friend. I keep a note about debugging for exactly this reason.

Paolo Garcia · 302 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. Most people skip the boring setup, but that setup is what makes the good habit survive a busy week.

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

Diego García · 145 likes

What happened after the first week? I am curious whether beginner stayed easy. I keep a note about debugging for exactly this reason.

Kabir Khan · 136 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 noticed the same thing in Cape Town.

Ananya Rao · 86 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. Most people skip the boring setup, but that setup is what makes the good habit survive a busy week.

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

Source: mostly hard-won experience and comparing notes with people who stuck with it.

Aarav Sharma · 71 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.

Maya Putri · 63 likes

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

Mango River · 34 likes

I had the same reaction to answer.

Noé Petit · 3 likes

@maya-59 This is the gentle version of my rant.

Hugo Sánchez · 63 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 9-minute rule is underrated.

Rizky Pratama · 62 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 surprising part is easy to underestimate.

Rafael Almeida · 60 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 more useful on a tired commute than on a perfect day.

Jasmine Cruz · 5 likes

That made the concept click.

Avery Johnson · 62 likes

Could be regional too.

João Pereira · 57 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 awkward constraint is probably the real story.

Bianca Santos · 57 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 pairs weirdly well with mango sticky rice.

Tomás Gómez · 46 likes

Beautifully put. I needed that reminder today. It reminds me of a very specific conversation near a tiny balcony.

Ananya Rao · 44 likes

This feels like advice from a patient friend. This pairs weirdly well with arepas. The boring solution is probably the reliable one here.

Gentle Baker · 41 likes

Adding this to my notes.

Tola Ibrahim · 43 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 3-minute rule is underrated.

Priya Nair · 0 likes

Good clarification — I read it differently at first.

Faisal Al Saud · 42 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 reminds me of a very specific conversation near the train station.

Noah Miller · 39 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 Mexico City example makes it feel concrete.

Iryna Melnyk · 4 likes

Totally agree, especially for beginners.

Amelia Hughes · 34 likes

I wish more posts had this much context. It reminds me of a very specific conversation near the train station.

Maya Williams · 28 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 am curious whether architecture still feels good next month.

Noah Miller · 27 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. Honestly, the simplest version wins for me.

Imogen Clarke · 26 likes

This reminds me of something a friend in Kuala Lumpur mentioned. The social part surprised me too. I would love to see the benchmark numbers.

Mateo Cruz · 22 likes

Fair pushback.

Benjamín Rojas · 10 likes

Yep, the boring details matter.

Martina Fernández · 26 likes

I would not call it wrong, just incomplete.

Ren Suzuki · 14 likes

You just saved me a bad purchase.

Mariana Costa · 12 likes

Appreciate the nuance.

Tomás Gómez · 7 likes

Could be regional too.

Avery Johnson · 25 likes

This is the gentle version of my rant.

Maya Putri · 5 likes

That is a good boundary.

Laura Gómez · 3 likes

I had the same reaction to call.

Luca Bianchi · 2 likes

This is the kind of disagreement I like.

Sofía Hernández · 25 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 friend tried it in Jakarta and had the opposite result.

Diego García · 25 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 reminds me of a very specific conversation near the library.

Beatriz Sousa · 23 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 am curious whether architecture still feels good next month.

Maya Williams · 59 likes

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

Silver Fern · 23 likes

Helpful and not preachy, which is rare. For me it came down to the recipe.

Noah Miller · 9 likes

Totally agree, especially for beginners.

Ngozi Bello · 20 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 4 weeks.

Urban Sparrow · 19 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 noticed the same thing in Lisbon.

Omar Hassan · 30 likes

Thanks for making it less intimidating.

João Pereira · 1 likes

That is a good boundary.

Avery Johnson · 8 likes

Good clarification — I read it differently at first.

Valeria López · 46 likes

Thanks for making it less intimidating.

Curious Fern · 5 likes

This comment has main-character footnote energy.

Sleepy Comet · 3 likes

Could be regional too.

Nour Ali · 3 likes

I would love a follow-up example.

Hugo Martin · 19 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 used to overcomplicate this constantly.

Chinedu Adeyemi · 16 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.

Youssef Mahmoud · 16 likes

Helpful and not preachy, which is rare.

Inês Ferreira · 15 likes

Anecdotally, this tracks with what I have seen. The practical part is easy to underestimate. This is exactly the kind of tradeoff teams argue about for weeks.

João Pereira · 15 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 corner shop detail changes the whole answer.

Lucas Williams · 14 likes

Beautifully put. I needed that reminder today. This is where I would ask one more question before choosing.

Cedar Lantern · 14 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. It sounds small, but the route matters.

Maya Williams · 12 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 pairs weirdly well with dumplings.

Daan Bakker · 12 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I learned that one the expensive way.

Luciana Vargas · 11 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 2 weeks.

Curious Runner · 11 likes

Really good advice, and it feels doable. That is the kind of detail beginners miss.

Grace Parker · 11 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. That is the kind of detail beginners miss.

Midnight Runner · 11 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 a trailhead detail changes the whole answer.

Nour Ali · 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 friend tried it in São Paulo and had the opposite result.

Jiho Lee · 44 likes

Kind of wild how often still is the whole issue.

Nour Ali · 1 likes

Fair pushback.

Silver Panda · 1 likes

Kind of wild how often reproduction is the whole issue.

Khalid Al Zahrani · 11 likes

The kindness in this post is lovely.

Isha Menon · 6 likes

This is the kind of disagreement I like.

Youssef Mahmoud · 10 likes

This feels like advice from a patient friend. The low-effort version is probably the keeper.

Ren Suzuki · 23 likes

That is a good boundary.

Cedar Orbit · 4 likes

Yep, the boring details matter.

Elsa Andersson · 10 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I would write it down before changing anything else.

Laura Gómez · 8 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. For me it came down to the first draft.

Elif Yılmaz · 7 likes

The safe answer is to keep the API boring: clear names, explicit errors and one behavior per function. I would test it for 8 days before deciding.

Amina Okafor · 8 likes

I needed the reminder to start smaller.

Luca Bianchi · 7 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 awkward part is easy to underestimate.

Camila Rocha · 3 likes

Exactly; the hidden cost is energy.

Budi Santoso · 6 likes

Honestly, this is a little too vague to be useful. My only addition is to make the first step visible.

Sara Ahmed · 6 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.

Bianca Santos · 6 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 Kuala Lumpur example makes it feel concrete.

Avery Johnson · 4 likes

I laughed, but you are not wrong.

Noah Miller · 5 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 pairs weirdly well with bibimbap.

Ren Suzuki · 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. It sounds small, but the first draft matters.

Isha Menon · 4 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. It sounds small, but the routine matters.

Isha Menon · 4 likes

Honestly, great taste. I would love to see a follow-up after 5 weeks. Naming things remains undefeated as the hardest problem.

Nicolás Díaz · 4 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 care less about the perfect answer and more about repeatability.

Avery Johnson · 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. I keep a note about debugging for exactly this reason.

Felix Weber · 3 likes

Start by reducing it to the smallest reproducible piece, then change one variable at a time. Most people skip the boring setup, but that setup is what makes the good habit survive a busy week.

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

That should give you a solid first pass.

Gentle Otter · 29 likes

Thanks, that actually helped.

Cedar Sparrow · 24 likes

I had the same reaction to habit.

Gentle Fern · 8 likes

That is a good boundary.

Felix Weber · 8 likes

Totally agree, especially for beginners.

Felix Weber · 3 likes

You just saved me a bad purchase.

Ethan Brooks · 16 likes

Beautifully concise.

Felix Weber · 1 likes

@urban_ethan47 I am curious what changed your mind.

Mateo Cruz · 2 likes

Same here. It took me too long to learn.