The ‘Tightening Cycles’ of Agile, TDD, Learning, Wellbeing: Makers Academy, Day 1
I’m stoked to have just completed my first day in person at Makers Academy. Though the day was mostly given over to admin, welcome activities and induction talks, there was a lot to stimulate my thinking and establish some frameworks to apply to my forthcoming training as a dev. One notion of an “ever-tightening cycle” kept occurring across different areas, and it seems this will be a useful one to latch onto as I shape my learning.
Sam Morgan, the Head of Education at Makers, gave a talk which fully confirmed the extent to which Makers has carefully constructed an educational philosophy which has maximal impact. In this, we discussed how the optimal model for learning is one of a continuing cycle which goes something like this:
- Attempt a thing (e.g. mow the lawn)
- Get feedback from the thing (i.e. it took very long to mow the lawn)
- Analyse the feedback (i.e. I mowed in random zig-zags and had no way of knowing which part of the lawn had been mowed)
- Alter behaviour based on analysis (e.g. mow in straight lines)
- Return to Step 1. and get feedback on your change
Rather than a linear model that is pointed to an arbitrary goal, such as an exam result, prioritising feedback cycles was convincingly presented as a more constructive alternative.
The trick is to tighten that cycle. I understood this to mean two things.
- Reduce the amount of time you iterate through the cycle by asking for feedback as soon as possible (e.g. partway through mowing the lawn, stop and check whether your lawn-mowing practice is sound, rather than wait until you’ve finished the whole garden)
- Be as narrow as possible in identifying a factor to change (e.g. not “mow neater” but “mow in regular vertical lines”
This model allows us to think about our own educational psychology, but it also maps onto key concepts of software engineering: Test Driven Development and the Agile Methodology.
Test Driven Development
- Red (failing test
- Green (production code passes test)
- Refactor (improve production code)
- Return to Step 1; write a new test
The above cycle paradigm is analogous to the reflective learning loop given above in that both emphasise small, frequent, iterative, incremental improvements. If TDD governs the local process of writing production code, Agile is an analogous but broader methodology which governs a whole project, involving small, frequent, iterative, incremental alterations..
On Day 1, we were introduced to another pillar of the Makers Academy experience by Dana, the Chief Joy Officer. Makers has a thorough and detailed Emotional Intelligence Curriculum to allow students to better understand the emotional needs of themselves and others. To paraphrase a comment made during this talk, which has stuck with me:
Since you have all come here to learn how to code, but you to do that you have to change. In order to learn to code you must become different people.
Encountering difficulty and adapting to accommodate it will, we were reminded, feel uncomfortable. Each iteration through the learning cycle or through a TDD loop means encountering an obstruction that the status quo can’t handle — a new bit of knowledge, a feature without the production code to implement it — which requires the status quo to be dismantled. The Emotional Intelligence at Makers helps us to be better equipped to deal with the difficulty of being dismantled so regularly, and the importance given to it goes hand-in-hand with the emphasis on reflective learning cycles.
Thinking cyclically is perhaps uncomfortable because we’re more used to thinking linearly. Some part of our egos might derive a lot of joy from producing reams of code without writing a single test because each new line entered is a positively motivated action. That part of us would rather forestall the time when we receive feedback on what we’ve produced which will, inevitably, reveal areas where we need to adapt. If we’d sooner divide these two ways of thinking — one future-facing, positive and productive, one past-facing, reflective and critical — the need to emphasise ever-tightening cycles is clear, to bring the past and the future into a more regular conversation in the present. The image of the Roman god Janus comes to mind: one interpretation of the significance of Janus is that he represents precisely this bent towards division within human nature between past and future.
The far-reaching implications of tightening feedback cycles in software development and educational theory are thrilling.
Follow me or give me a clap if you enjoyed this. If anyone has further reading on TDD, Agile or Learning Theory that you think I’d enjoy based on this, please shoot it over.