Simply put, the United States legislature was created to acknowledge the many problems and issues faced by people from all walks of life, and come up with sensible solutions that address the needs of most while preserving the rights of everybody. Then solutions are legislated into writing, in a way that’s consistent with past legislation.
If your job is to develop software, the above description may sound weirdly familiar. Software engineers build systems that address certain specific needs (problem space) within certain specific restraints, like the confines of our operating system (or various other restrictions), while maintaining backward compatibility with older solutions (most of the time).
These days, we hear a lot about the dysfunctional state of the legislative system, the burden of over-regulation on American businesses, and the problems of money influence in the political system.Perhaps the software industry can teach the American legislature a few valuable lessons on addressing some of these challenges.
As a thought experiment, try to imagine what software would look like if it followed the legislative system’s example. Following this analogy, our congressmen would be played by product managers, developers would play the role of bureaucrats who implement the laws, and the general public would be played by end users. Think about it. You’ll see how quickly everything would unravel.
If software was built like laws:
- You’d fix bugs only by writing new code
- You’d never break backward compatibility
- You’d never, ever start over
- You wouldn’t go back and refactor code in face of learning better ways to do things
- Your code would have an extreme case of coupling
- Your release cycle would be measured in years
- Product managers would claim they could come up with any and all possible future scenarios
- Product managers would come up with implementation details
- Product managers would put plenty of special case conditions for their “friends” in requirements
- Product managers would favor complexity over simplicity
- And on and on
Every person involved with software at this point will be tearing their hair out! This description can actually be applied to almost every software project that has failed. And yes, lawmaking is mishandled in a manner even worst than this.
The inefficacy of lawmaking isn’t limited by Republican or Democrat party lines; both sides are equality to blame.
Congressmen – like product managers – should come up with high-level requirements and directions, leaving the implementation details to the regulators. This would lower the cost of implementing laws, and as regulators learn more about the system at the implementation level, it’d result in more agile adjustment of details. Plus, it’d even encourage analytical thinking and accountability, with the right metrics and KPIs defined.
Congress should also allow for resetting and refactoring every so often. Maybe automatically expire laws after a decade so we don’t end up with irrelevant legacy laws that make zero sense in the present universe. Believe me, we have the concept of “tech debt” in our legislature as well.
Lastly, when implementation details aren’t in the hands of product managers/legislators, it’s a lot harder to hide favors for special interests in between the million lines of code.
So, here’s to leaner legislation. Maybe we should start talking about minimum viable law!