Uncle Bob shares the philosophical and ethical reasons for Agile development that have to do with professionalism and the reasonable expectations of your customers.
Save 35% off the list price* of the related book or multi-format eBook (EPUB + MOBI + PDF) with discount code ARTICLE.
* See informit.com/terms
Before we dive into the details of Agile development, I want to explain what’s at stake. Agile development is important, not just to software development, but to our industry, our society, and ultimately our civilization.
Developers and managers are often attracted to Agile development for transient reasons. They might try it because it just somehow feels right to them, or perhaps they fell for the promises of speed and quality. These reasons are intangible, indistinct, and easily thwarted. Many people have dropped Agile development simply because they didn’t immediately experience the outcome they thought were promised.
These evanescent reasons are not why Agile development is important. Agile development is important for much deeper philosophical and ethical reasons. Those reasons have to do with professionalism and the reasonable expectations of our customers.
What drew me to Agile in the first place was the high commitment to discipline over ceremony. To do Agile right, you had to work in pairs, write tests first, refactor, and commit to simple designs. You had to work in short cycles, producing executable output in each. You had to communicate with business on a regular and continuous basis.
Look back at the Circle of Life and view each one of those practices as a promise, a commitment, and you’ll see where I am coming from. For me, Agile development is a commitment to up my game—to be a professional, and to promote professional behavior throughout the industry of software development.
We in this industry sorely need to increase our professionalism. We fail too often. We ship too much crap. We accept too many defects. We make terrible trade-offs. Too often, we behave like unruly teenagers with a new credit card. In simpler times, these behaviors were tolerable because the stakes were relatively low. In the ’70s and ’80s and even into the ’90s, the cost of software failure, though high, was limited and containable.
Software Is Everywhere
Today things are different.
Look around you, right now. Just sit where you are and look around the room. How many computers are in the room with you?
Here, let me do that. Right now, I am at my summer cabin in the north woods of Wisconsin. How many computers are in this room with me?
4: I’m writing this on a MacBook Pro with 4 cores. I know, they say 8, but I don’t count “virtual” cores. I also won’t count all the little ancillary processors in the MacBook.
1: My Apple Magic Mouse 2. I’m sure it has more than one processor in it, but I’ll just count it as 1.
1: My iPad running Duet as a second monitor. I know there are lots of other little processors in the iPad, but I’ll only count it as one.
1: My car key (!).
3: My Apple AirPods. One for each earpiece, and one for the case. There are probably more in there but…
1: My iPhone. Yeah, yeah, the real number of processors in the iPhone is probably above a dozen, but I’ll keep it at one.
1: Ultrasonic motion detector in sight. (There are many more in the house, but only one that I can see.)
1: Security panel.
1: Flat-screen TV.
1: DVD player.
1: Roku Internet TV streaming device.
1: Apple AirPort Express.
1: Apple TV.
5: Remote controls.
1: Telephone. (Yes, an actual telephone.)
1: Fake fireplace. (You should see all the fancy modes it’s got!)
2: Old computer-controlled telescope, a Meade LX 200 EMC. One processor in the drive and another in the handheld control unit.
1: Thumb drive in my pocket.
1: Apple pencil.
I count at least 30 computers on my person and in this room with me. The real number is probably double that since most of the devices have multiple processors in them. But let’s just stick with 30 for the moment.
What did you count? I’ll bet that for most of you it came close to my 30. Indeed, I’ll wager that most of the 1.3 billion people living in Western society are constantly near more than a dozen computers. That’s new. In the early ’90s, that number would have averaged closer to zero.
What do every single one of those nearby computers have in common? They all need to be programmed. They all need software—software written by us. And what, do you think, is the quality of that software?
Let me put this in a different light. How many times per day does your grandmother interact with a software system? For those of you who still have living grandmothers that number will likely be in the thousands, because in today’s society you can’t do anything without interacting with a software system. You can’t
Talk on the phone.
Buy or sell anything.
Use the microwave oven, refrigerator, or even the toaster.
Wash or dry your clothes.
Wash the dishes.
Listen to music.
Drive a car.
File an insurance claim.
Increase the temperature in the room.
But it’s worse than that. Nowadays, in our society, virtually nothing of significance can be done without interacting with a software system. No law can be passed, enacted, or enforced. No government policy can be debated. No plane can be flown. No car can be driven. No missile launched. No ship sailed. Roads can’t be paved, food can’t be harvested, steel mills can’t mill steel, auto factories can’t make cars, candy companies can’t make candy, stocks can’t be traded…
Nothing gets done in our society without software. Every waking moment is dominated by software. Many of us even monitor our sleep with software.
We Rule the World
Our society has become utterly and wholly dependent on software. Software is the life’s blood that makes our society run. Without it, the civilization we currently enjoy would be impossible.
And who writes all that software? You and I. We, programmers, rule the world.
Other people think they rule the world, but then they hand the rules they’ve made to us and we write the actual rules that run in the machines that monitor and control virtually every activity of modern life.
We, programmers, rule the world.
And we are doing a pretty poor job of it.
How much of that software, that runs absolutely everything, do you think is properly tested? How many programmers can say that they have a test suite that proves, with a high degree of certainty, that the software they have written works?
Do the hundred million lines of code that run inside your car work? Have you found any bugs in it? I have. What about the code that controls the brakes, and the accelerator, and the steering? Any bugs in that? Is there a test suite that can be run at a moment’s notice that proves with a high degree of certainty that when you put your foot on the brake pedal, the car will actually stop?
How many people have been killed because the software in their cars failed to heed the pressure of the driver’s foot on the brake pedal? We don’t know for sure, but the answer is many. In one 2013 case Toyota paid millions in damages because the software contained “possible bit flips, task deaths that would disable the fail-safes, memory corruption, single-point failures, inadequate protections against stack overflow and buffer overflow, single-fault containment regions, [and] thousands of global variables” all within “spaghetti code.”1
Our software is now killing people. You and I probably didn’t get into this business to kill people. Many of us are programmers because, as kids, we wrote an infinite loop that printed our name on the screen, and we just thought that was so cool. But now our actions are putting lives and fortunes at stake. And with every passing day, more and more code puts more and more lives and fortunes at stake.
The day will come, if it hasn’t already by the time you read this, when some poor programmer is going to do some dumb thing and kill ten thousand people in a single moment of carelessness. Think about that for a minute. It’s not hard to imagine half a dozen scenarios. And when that happens, the politicians of the world will rise up in righteous indignation (as they should) and point their fingers squarely at us.
You might think that those fingers would point at our bosses, or the executives in our companies, but we saw what happened when those fingers pointed to the CEO of Volkswagen, North America, as he testified before Congress. The politicians asked him why Volkswagen had put software in their cars that purposely detected and defeated the emissions testing hardware used in California. He replied, “This was not a corporate decision, from my point of view, and to my best knowledge today. This was a couple of software engineers who put this in for whatever reasons.”2
So, those fingers will point at us. And rightly so. Because it will have been our fingers on the keyboards, our disciplines that were lacking, and our carelessness that was the ultimate cause.
It was with this in mind that I held such high hopes for Agile. I hoped then, as I hope today, that the disciplines of Agile software development would be our first step toward turning computer programming into a true and honorable profession.