As has been mentioned many times, what we’ve learned in the health care debate is that our government is currently hapless to really engage with the huge problems our country faces. First, let’s look at the magnitude of the health care crisis. Andrew Sullivan links to a chart from National Geographic that illustrates the problem in stark terms. Americans spend a whole lot more on health care than any other country, have ultimate outcomes in the mediocre to poor range, and don’t even go to the doctor very much. We’re spending an awful lot of money and not getting a lot for it. And the second order effect is that our future obligations to continue spending ever increasing amounts of money on health care are going to bankrupt the federal government and eat away at wage growth indefinitely, unless things change in a pretty radical fashion.
As has been mentioned any number of times, this is just one of our really big problems. We also have structural deficits in the federal budget that must be addressed at some point, we have climate change to deal with, and we have any number of other smaller, but still important problems that are also going to require attention.
What we have seen this year is a federal government that is unequipped to grapple with any of these problems in a serious way. Republicans refuse to attempt to solve any of these problems at all. Not only have the Republicans declined to work with the Democrats in moving any bills through the Senate or House this year, but in the six years where they were in charge (not counting 2007 and 2008 where Democrats ran Congress), they opted not to address any of these problems at all. They continue to deny that global warming is even an issue, and the only thing they did on the health care front was work with Democrats to pass an unfunded prescription drug benefit for seniors. And the only thing they did while they were running things was expand the budget deficit to a massive degree through tax cuts without offsetting spending cuts, new programs (like the Medicare drug benefit), and of course, multiple wars that they chose not to fund through revenue, either.
When President Bush was in charge, it was pretty obvious that the most acute problem facing the country was his administration. Now that he’s out of office, it’s clear that we can zero in on the de facto supermajority requirement in the Senate as the largest obstacle to progress. Liberals are angry with President Obama (for some good reasons and some bad ones), but it’s clear that the Senate is the biggest problem. President Obama could be twice as committed to the progressive agenda as he is, and Harry Reid would still need every member of his caucus plus both independents to vote for every bill to make progress. Ezra Klein has an op-ed today that explains just what a liability this is for effective government.
So the health care reform bill that the Senate passed will, I think, be good for the country, but it’s almost devoid of ambition. Beyond expanding coverage, it doesn’t take on any of the biggest problems we face going forward. And it seems clear it was the best bill we could possibly get from the Senate given the rules it operates under. Had Al Franken lost the recount battle in Minnesota, we would probably have nothing. It’s hard not to be pessimistic about the future of the country when one political party has as much power as any has had in decades, and it’s still unable to make real progress on its agenda.
Trend of the decade: decentralized process
O’Reilly Radar’s best and worst tech of the decade inspired me to think about trends in software development. In the past decade, one prevailing trend has been the migration of process in software development from management to individual developers. Traditionally, process has been imposed on the development team, who usually ignore the process or actively resist it. Or in many cases there just isn’t any process at all.
Traditionally, “process” has been associated with project managers. Most processes had to be applied at the team level in order to work. Whether it was old school process like Waterfall or newer, agile processes like Scrum or Extreme Programming, everybody on the team has to participate for the processes to work. These processes are heavy, difficult to implement, and in many cases, completely ineffective.
The most powerful contribution of Extreme Programming, though, was that it was much more developer-friendly than the other approaches, and it really arrived as a bundle of specific practices. XP made it easy for developers to pick the practices that they liked best from the whole collection and start applying them, whether or not management bought into XP as an approach. So we’ve seen specific XP components like test-driven development, refactoring, continuous integration, and small releases really find democratic support among programmers.
A second major factor in encouraging developers to implement their own processes has been the growth of open source software. For one thing, it’s proven to be a laboratory for a lot of different approaches to building software, and for another, all of those approaches were implemented and used by developers themselves, and so they all work for at least some developers. The growth of open source software has also contributed a powerful set of programmer-friendly tools for implementing a development process, including version control, issue tracking, unit testing libraries, automated testing tools, continuous integration servers, project management applications, and more.
The third major change we’ve seen in the past decade or so has been the growth of blogging. People talk a lot about the effect of blogging on other fields, but its effect on software development has been profound. There were ever many magazines that were aimed at working software developers. Back in the day, there were magazines like Information Week, InfoWorld, and PC World that were for IT management — not for the people doing the real work. Developers had Usenet and mailing lists, but blogging led to an explosion in the amount of information that was written by programmers for programmers.
All of these factors contributed to developers stepping up and taking ownership of the process of developing software. These days, you see lone developers implementing a somewhat formal process for building software. Ten years ago, it was tough to find programmers who wrote unit test. Now there are a lot of programmers out there writing unit tests even when people aren’t looking. Programmers are taking ownership of the full life cycle of software development like never before as well. Take a look at some of the more recent writing on continuous deployment — it covers everything from requirements to maintenance to monitoring of running applications. More work done in public, public discussion of that work, and the introduction of new best practices have defined the trend of the decade — developers owning the processes under which they work. Hopefully it will continue in the next decade.