In struggling to understand the behavior of both Democratic and Republican leaders who, in turn, are struggling to find ways to craft legislation and govern this country, one day it struck me that maybe we could treat the political landscape like software development.
Problems can creep into the software development process at many points: early design decisions can have unexpected consequences down the road, poor execution and bad practices can result in lowered quality, lack of feedback loops and testing can cause divergences between expectations and reality to go unnoticed, and porcine lipstick application can happen at any step.
It seems to me that politics works the same way.
I've been involved in software projects where project managers have declared that everything is fine, on track, and beautifully executed. In those same projects from my perspective as a software tester, the train was on fire, off the rails, and headed for disaster. At the end of the run when it's time to ship, if the worst disasters had been averted, the project manager might take credit for the huge success. If the project was crashing and burning, that project manager might blame everything from external circumstances to the engineers, but somehow dodge the heat.
Either way, better software development practices would have helped ship the product and keep visibility high such that bamboozlement by project leadership is minimized. I think leveraging some software development concepts might help in the political system as well.
More ideas below the fold.
Basically, in order to treat politics like software, here's what I'm proposing:
- Have a spec - in legislative terms, it may seem like this would be a bill. It's not. There's more to it than that. The bill would be the final outcome (the source code). The spec has the meta information needed to write the bill. What is the intention? Who is the target audience or end user of the legislation? What players are involved? Who wrote it? What resources are required for the bill's creation and implementation? What is trying to be accomplished? How will success be measured?
- Have a spec review - should the legislature even attempt this? Has enough information been gathered to make it successful? Is this a good plan? Accept "bugs" against the spec then triage, prioritize, and address them. Specs and spec reviews should all be publicly visible and create a historical record for future features, products, or bugfixes. If an early compromise is required, it should be noted here - there may be tradeoffs between features.
- Write code - this would be crafting the base legislation. It should be based on the spec.
- Have a code review - this review would not be to decide on the bill's intent, but only to determine legislative quality - does the bill accomplish what was agreed on in the spec? Are there any surprises?
- Find bugs - experts and the public could analyze the spec and the code and file bugs. Writing code is hard. It's hard work and it's hard to do right. You're going to ship with bugs - track them.
- Fix the bugs you can - this is essentially an amendment process. Bug fixing is not a time to add tons of new features. That results in bad code. Feature changes should have happened earlier in the process. Disruptive changes should be rejected.
- Beta test and/or prototype - it might be useful to try out some features on a smaller scale. There may be unexpected side effects with your design or how your code is running in the real world.
- Make a go/no-go decision on a final release - did you get the minimum quality needed to ship successfully? Make a note of what bugs didn't get fixed, and why. There may need to be a "readme" file or list of known issues.
- Provide customer support and get feedback on your shipped product - create a forum for users to help each other, provide technical support, make customer education part of your marketing plan, let users file bugs.
- Plan for the next release - whatever you just built, it wasn't perfect. Start planning for the next version even before you shipped the first.
I'm pretty sure some of this kind of stuff happens automagically, but with private players with their own agendas. I'd sure like to file some bugs, though. And when the country doesn't understand why something is broken, please... let someone hook up a debugger? Maybe they'll be able to help figure it out.
If I ever get around to it, it'd be fun to build a website that will help make politics like software some day. So when teabaggers scream "Obama is a socialist!", we can just reply... yeah, that's Bug 73238 on the Obama administration. It was closed "no repro."