What is the size of a baby step?

Filed under: New developers, — Tags: Baby steps, Experience, TDD — Thomas Sundberg — 2019-05-18

It is easy to agree that baby steps are good when doing something complicated. They allow you to move slowly but steadily. That is why baby steps are recommended when doing software development.

If we agree that baby steps are good, the next question is "How large is a baby step?"

This is where it gets interesting and this is where I see different interpretations.

We must take baby steps here

Recently I had the opportunity to watch a developer that said "We must take baby steps here" when a pair did a TDD exercise.

That developers definition of a baby step was much larger than I could imagine. Much larger than I would have done it.

The pair tried to implement checking if all values in a row in tic-tac-toe was equal. And they tried to implement a loop that would check all rows on the board. This was, in my mind, a large step. I was curious, would they succeed or not? Unfortunately, they didn't succeed until after some time.

Smaller steps

The test that drove their development was one specific row where all values where equal and thus should return true to the question if one player had won or not.

My approach would have been to check the one row they had a test for where all fields were equal. I would then allow the next test to guide me towards a better solution. The first iteration could have been a one liner, not a nice one liner but still one line of code. Instead, they had a loop inside a loop. The solution they wanted to implement is a good and generic solution. The route they choose for the implementation was a bit long. At least in my mind.

What is the difference here? One difference is that they are learning TDD and I know TDD. I was doing the teaching in this case. Another difference is that they have a few years experience while I have a few decades.

More than one observation

This is not the only data point I have. But it is concrete and I feel I can share it without making any person look bad. My goal here is not to make anyone look bad or feel sad.

This leads me to think that the ability to take baby steps is somehow connected to your experience. The longer experience you have, they more mistakes you have done. You have learned not to trust yourself and therefore you take smaller, safer steps.

My hypothesis is that "The length of your baby step is inverse proportional to your experience."

I can't prove this as I haven't done a proper study. However, experienced developers and trainers I have spoken to often recognise this.

Can this be used?

What can we do with this? Not that much. I think we can recognise that taking baby steps is hard and that it is even harder for developers that don't have a lot of experience.

If we are aware of the fact that baby steps are different for different persons, we can use this when teaching TDD. We can make sure to use exercises that emphasize small steps. And then shrink the allowed step size. This may lead to developers learning TDD to realize that tiny, tiny step are safer and therefore better than larger steps.

Acknowledgements

I would like to thank Malin Ekholm for feedback.

Resources



(less...)

Pages

About
Events
Why

Categories

Agile
Automation
BDD
Clean code
Continuous delivery
Continuous deployment
Continuous integration
Cucumber
Culture
Design
DevOps
Executable specification
Gradle
Guice
J2EE
JUnit
Java
Javascript
Kubernetes
Linux
Load testing
Maven
Mockito
New developers
Pair programming
PicoContainer
Presentation
Programming
Public speaking
Quality
React
Recruiting
Requirements
Scala
Selenium
Software craftsmanship
Software development
Spring
TDD
Teaching
Technical debt
Test automation
Tools
Web
Windows
eXtreme Programming

Authors

Thomas Sundberg
Adrian Bolboaca

Archives

Meta

rss RSS