On The Real Cost of Bad Development
Today I've run across something that makes me cringe. I mean really... cringe. And while it's easy to lay blame at the feet of the developers, I'm really beginning to lay it at the feet of the development managers. If you allow it, they will do it. Period.
I've been having problems with a very poorly created API to a DatingService at The Shop. I've touched on this before, and I won't belabor the point further. No, today I was told that there were significant bug fixes in the latest version of the API, and that it was probably a good idea to upgrade to this latest version and the problems I've been having should go away.
I'm not surprised, it makes sense, but at the same time, if the developers, and managers of those developers, allowed such a bad API to be created, I was worried what the "upgrade" would mean. I had hopes that it was just a Java jar replacement, but I had an inkling that it wouldn't be that easy.
When I got the word that one of the jars was split into two, I had a bad feeling.
It got worse, when I put in the three new jars and tried to compile the code. Not even close. Hundreds of problems. Holy Cow.
So I asked the developer that was helping me "What changed?" Normally, I'd think "nothing", or at worst, a package name change, but again, I had a feeling.
The silence that followed was not reassuring.
He sat at my desk - because there were no docs, no examples, just the raw code, and as he looked at the Google Protocol Buffers code, he was guessing what the method names were. I was shaking my head the entire time. I simply could not believe that a developer who used this code was this unfamiliar with it.
It took far longer than it should have, and included a lot of changes - all for an API that really should have been less than five lines, but ended up being far more than that. The types of data were different, the arguments different. It seemed that they threw most of what was out in favor of something similar, but not really equivalent.
While I'm the first to understand that things need to change, APIs just aren't one of them. There's no reason they couldn't have made the same fixes into the old API. THey just were lazy. Or worse.
So everyone that used the old way had to re-tool their code to use the new. Why? Because a few guys (and their manager) were too bloody lazy to actually design a decent interface and then build it?
It appears that's about the size of it.
I shake my head at the sheer lack of common sense displayed in these interactions.