When you think about it, it's clear that software architects and developers should rule the world. Not that - in reality - they don't already. Let's face it, almost everything that goes on in the world today, from air traffic control to motor cars to the microwave oven in your kitchen is powered by software. But what's becoming clearer over time is that they should be running the Government as well.
Here's the justifications:
1. Software developers manage usage of their primary resource, memory, knowing that there is a finite limit to the amount available. At some point you'll run out of slots to plug more in. You can't just print more memory for your application to use. Governments, meanwhile, have no idea how to manage their primary resource, which is, of course, money. They just keep spending it until there is none left, then print some more, and then discover that there still isn't enough to keep their economy running. Examples: Government debt and the financial crisis.
2. Software developers realize that efficiency is the key to making an application work well, and for generating income that allows them to prosper and build even more software. Individual components of the application are accurately targeted, fine-tuned for performance, and only instantiated when required. Governments, meanwhile, work on the principle that the best way to promote efficiency is to appoint more people to watch the people who are already watching other people who are trying to do something. Efficiency in Government consists of using maximum resources to manage input, instead of minimizing resource usage whilst achieving the required output. Examples: taxation systems and nationalized health services.
3. Software architects design systems based on known and tested mechanisms and patterns, thinking ahead to avoid applying limitations that will inhibit any future changes or extensions to the system; and considering interoperability, effectiveness, and reuse. Governments, meanwhile, design systems based on ideology and with no consideration of impact and unintended consequences; and usually based on untried practices and unproven assumptions. Examples: health and safety regulations and the Human Rights Act.
4. Software developers implement comprehensive testing regimes for their products, and provide an efficient feedback mechanism that allows them to discover faults and improve quality before the application is deployed. Governments, meanwhile, implement new systems with no prior testing and have no effective feedback mechanism that supports changes when glaring errors or omissions are discovered. Faults are either ignored, or result in changes that make things worse. Examples: the European Union and the single currency.
5. Software architects and developers innovate rapidly, meet constantly changing requirements, and fulfill aspirations in a fast moving market with regular new paradigms. Governments, meanwhile, plan for yesterday and strive to maintain power and the status quo. Examples: Doha trade negotiations and global environmental summits.
6. When a fault in a system is detected, software developers apply effective patches and updates to resolve the issue. Governments, meanwhile, prevaricate and apply wildly unpredictable and often unsuitable or unsatisfying fixes that often make things worse. Example: Cheddar cheese.
OK, so that last one might seem a rather strange example. But if you read about how the Irish Government is responding to the disastrous ramifications of its membership of the European Union last week, you'll understand. They've decided that the best way to counter the effects of running out of money is to give everyone in the country a nice soothing block of cheese to take their mind off the crisis (see Let Them Eat Cheese). A move that Jeremy Paxman on Newsnight rather neatly summed up as "quantitative cheesing".