As the launchpad explosion of the Obamacare Healthcare exchanges continues to play out, the risk builds of putting the blame on the programmers. This would be a mistake, and I don’t say this out of some sense of fraternal protectiveness for the developers.
The blame here lies squarely on leadership.
Notice that I don’t say management. I say leadership, in particular, the political leadership.
It’s true that the code isn’t very good. In fact, it would be fair to say that the piece of the code we’ve been able to see – mostly the javascript – is lousy with bugs and poor coding practices. And it’s also true that Barack Obama and Kathleen Sebelius didn’t write the code or manage its development. But they are responsible for the overall environment in which that code was written, including the timeline and the expectations.
They were so committed to the October 1 launch date for the entire system that they didn’t leave enough time for proper development and testing.
It’s quite clear that the development team simply wasn’t given the time it needed to do the job. By some reports, top-level decision-makers were so slow in approving requests that certain key functionality had about ten months in development. That’s simply not enough time for a large, complex system that involves a lot of cross-communication with other systems.
What’s also not clear unless you’ve worked in software development for a while is that such large systems are developed with a lot of back-and-forth between the pieces. Data that needed may not be available at a certain point in the process; you may find out later on that you want to keep users from entering certain kinds of data in combination, and so forth. A lot of this only becomes clear once development is well underway, and UI developers – the guys who create and program the User Interface that you see – are usually at the tail end of the process. This often gives them the least amount of time to do their work. Since it’s clear from the sorts of error messages we’re seeing that even the underlying middle-tier and database code still isn’t ready, it’s clear why the user interface keeps breaking.
As mentioned above, the political leadership, evidently fearing political fallout from any delay whatsoever, has decided to act like Soviet leadership facing a poor harvest. (Was there every any other kind?) Instead of facing reality, and preparing people for that reality, they resorted to a number of strategies.
In such situations, it’s almost impossible to make up for that by throwing more people and resources at it. Design and development can only bear so many chefs; the complexity isn’t in the small pieces of the code that need to be written, but in the overall picture of how the various systems fit together, and the business rules that need to be enforced at each step. Adding more people to the design process isn’t going to get the work done any more quickly. And just adding more developers to the coding process doesn’t solve that problem at all. In fact, it can make it worse, as different coding styles begin to conflict with each other.
And yet, that’s just what the administration seems to have done, with an initial price tag of $100 million ballooning to over $630 million as of this writing. When they asked how things were coming, they were told, “not well.” And when they asked if more resources would help, and were told, “yes,” they wrote a bigger check. They may not even have asked the second question, and the contractors may have said yes in order to get a bigger check. And no doubt the contractors will be hauled in front of a Congressional committee to tell this story. The point is, that it’s possible to imagine a scenario where Washington reacted as Washington always has – write a bigger check – and such a reaction was doomed to complicate the failure, not ameliorate it.
Their public reaction to the failure has be equally Soviet. They first blame circumstances beyond their control – for the Russians, it was the weather; for this crew, it was server load. In neither case was that factor beyond normal. And yet they stuck with it for days after it became clear.
And now, we’re being told that “it’s getting better every day.”
Here’s the secret: it’s not. What’s happening is that the developers and designers are now rushing to meet another hard deadline – December 31, when people will, by law, have to have signed up for health insurance, or risk fines from the IRS. The scenario they’re desperate to avoid is one where someone can’t sign up, files his taxes, has his refund garnished by the IRS to enforce the penalty, and files a class-action lawsuit in the middle of election season to remind everyone of last year’s Hindenburg.
The development team still isn’t getting the time it needs to do this right, and in continuing to rush to rebuild a system that already exists, it’s only going to make things worse. It may succeed in hiding some of the more public failures, but the back-system stuff is going to be held together with chewing gum and baling wire, and is going to be ripe for hackers and routine breakages.
As I said before, just be glad that nobody’s actual care is depending on this thing. Yet.
