“I’ll start, however, by assuming it’s going to work. No need to borrow trouble from the future.” That’s Ron Jeffries, in Extreme Programming Adventures in C#.
I’ll start, however, by assuming it’s going to work. No need for me to know much about eXtreme Programming (XP) and less about C#. And that’s me. Interestingly, in some very real sense, this book didn’t help me to overcome either of those lacks. And yet I still strongly recommend it.
Why? For one thing, because of quotes like the one at the top. It’s essentially the thesis of the book, repeated in various forms from just about the first words in the Introduction …
I start with a very simple design idea and implement features in a customer-driven order, using refactoring to keep the design just barely sufficient to the moment.
… to the last words in the final chapter, Project Retrospective:
Does incremental development work? This, of course, is the big question. It’s clear to me, and I hope it’s clear to you, that it certainly worked for me on this project. Will it work for you on your project? That’s for you to determine … The skills are valuable in their own right, and they may enable you to find a more flexible way to develop your software.
Here’s a couple more quotes that spoke to me, but the book is full of them:
The opposite of simple is “wrong.” (p.330)
The main thing is to remain sensitive to what you’re doing, and to adjust your practices as you notice problems. (p.346)
Frankly, I am surprised, given that I planned this book and think of it as a book about programming, at how much value an independent customer could have provided. (p.479)
In fact, it’s so heavily-laden with snappy chunks of wisdom that it has a Sound Bites appendix where some of the one-liners are elaborated on, and some that couldn’t be fitted into the main text are given as a bonus. Here’s one:
Isolate the unknown. Often when we’re working on something, we know how to do most of it and there’s just this one part we don’t know how to handle. Isolate that part, via one of two ways: We can begin by focusing on that part [or] we can pretend that we know the solution [and often find that] doing what we know has made the unknown more clear.
Why else did I love this book? Because I love listening to people who know and care about what they’re doing talking about what they know and care about. The style of this book is so conversational that it’s almost as if Jeffries is sitting alongside you, recounting the work that he did. And it’s clear that he knows what he’s doing, and it’s very clear that he cares about what he’s doing.
And what he’s doing is describing the paths he took – some false – and the compromises he made – knowingly and not – in the creation of a small application. He describes a set of principles that motivate XP loosely at the beginning of the book, and all of the work takes place in the context of them. But he’s never ruled by them: he uses his instinct and pragmatism and the resources available to him at any given time to make decisions about what do do, and how, and when, and, importantly, why.
The book is littered with sidebars labelled Lessons, micro-retrospectives for and on himself. He went away from some principle he holds dear, but got away with it this time. He ignored a code smell and got punished with several hours of debugging an approach that was never going to work, before backing it out. He chose to write or perform a particular kind of test this time, with these trade-offs.
Testing, yes. The book talks about programmer unit tests, customer acceptance tests, and manual testing. Jeffries, despite developing an application with a Window-based user interface, wants to keep himself away from manually exercising the software as far as possible. The motivation, to gloss it, runs something like this: to support his incremental development he wants a suite of tests that can be run quickly so that he can make a small change and run them to find out that either he hasn’t altered the functionality by his change, he has altered it in an expected way, or he has altered it in an unexpected way and needs to do work to find out where the reality and expectation diverge.
The focus of this book is not the philosophy of test coverage … but, with my testing hat on, I found that I was feeling tense about the extent to which the tests we’re shown do more than explore happy paths. That’s my bias I guess, and one that could easily see me writing more tests – for edges and corners – than perhaps there is immediate value for.
I was struck by how familiar Jeffries’ exploration of a problem feels. He probes behaviour, he frames hypotheses, and he tests them, frequently in code. He holds opinions loosely and is prepared to be guided by the evidence in front of him, and the advice of others with experience. I learned a new term – spike, for a short experiment – that I find appealing because of my visualisation of it as a tall but narrow peak, on a chart showing effort on the y-axis and time on the x.
But I also found the focus on the low level unfamiliar in some ways. Strategy, the big picture, high-level choices are the responsibility of the customer. Which isn’t to say that Jeffries ignores them, or has no thoughts on them, or nothing to say about them. But they are not the focus of the developers on this project and, by extension, of developers on XP projects. Again, with my testing head on, I find myself uncomfortable here. I want freedom to be at both ends of that spectrum and at places that I consider to be valuable in between.
So, yes, I’m a tester. And this is a book about programming. But I write code that helps me to test software. Sometimes I use code to directly exercise software, sometimes to prepare data to exercise software with, and sometimes to analyse the results of exercising software – and sometimes, on days when I’m feeling particularly meta – I write code that generates code that I use for those exercises. Coding is a helpful and important tool in my working life, but it by no means takes up the majority of my time.
In recent years I have found myself edging closer and closer to developing the code that I do write in really tiny increments, programming by intention (although I didn’t know it was called that until I read it here), and letting a design emerge by refactoring. I have also become happier about throwing away work and more desirous of pursuing a more direct route to the value I seek more often.
But I find that, to a large extent, that’s also true of my non-programming work, and this book is a welcome and useful and enjoyable way to reflect on that.