Every IT shop has some sort of change-management system. And it's often more a burden than a help. Why? Because of a number of change management myths that we hold near and dear.
The single most unheeded dictum, which seems to come from every successful entrepreneur-turned-billionaire, is to not be afraid of making mistakes. In fact, many people proudly declare that mistakes are the only way you make progress, and they attribute much of their success to their ability to make mistakes. Interestingly enough, this never seems to have worked out for me, but they're the rich ones, so they must know.
But ours is a world of caution, and it's one company in 10,000 that truly does not consider mistakes a cardinal sin. Careers are shipwrecked on mistakes. In many companies, management never remembers your victories, only the goofs.
Because of this deeply ingrained mindset, change control has evolved from the coder's helper to the coder's nightmare, and more than one company has set up change-control systems that double or triple the time it takes to get something "to market" without really providing any additional safety.
Here are just a few of the change-management myths we have embraced that have helped it grow from a tool to a prison.
Every User's Thoughts Should be Noted
Great writers fill notebooks with passing thoughts and bits of inspiration that come to them at odd moments, and someday some of those thoughts may become great pieces of literature. Or at least quick reads that net their authors a hefty royalty.
But users are not writers. Most passing thoughts and bits of inspiration that come to users (both real users and IT people) should be ignored. Yep, just forgotten about.
If the thought comes multiple times, maybe it's worth following up on, but most of the things we think about are just not worth further scrutiny. They may be cute and all, but they provide very little real business impact.
Unfortunately, there's a real belief in many companies that by allowing users to create their own requests and adding them to the queue, you are empowering those users and providing an enhanced level of service. Whatever.
The downside to this freedom, however, is that you end up with a huge queue. Sure, you can put a management review in there, but how many managers really want to tell their people that the idea they had was stupid? In this kind of environment, no matter how hard IT is working, it appears they're making no progress because the influx of half-thought-out ideas more than offsets those that are put into place.
In addition, if something sits in a queue for some period of time, maybe two or three years, is it really relevant for the business anymore? Try to find someone who says their business is not continually evolving. So if that's true, how relevant to today's needs is a requirement from three years ago?
Plus, even though you're theoretically providing a service to your users, if one of them puts in a suggestion and doesn't see any results for two years, they really aren't going to consider that "service." Sometimes, it's better to say no right away than say, "Oh, yeah, we'll get to it" month after month.
Finally, because you let things that aren't fully researched get into a queue, you get down the road and nobody really remembers what that was all about. The person who put it in may be gone or may not remember. So what do you do then? Close it? Or spend three or four people's time trying to figure out what that item was? Either way, it's a lot of overhead.
The More People Who Look at a Change, the Safer It Will Be
This is a big one. If we want to avoid code problems in production, don't just leave it up to the coder; have someone else look at it, probably a whole bunch of people. Have the users test it (I agree with that), have a user manager approve it, have someone independent in IT look at it, have IT management look at it, create a special final test group to look at it…. There's no limit to what you can do here to "protect" yourself.
First, let's look at management. Managers should know what's going on, but the idea of them looking at something detailed and spotting a problem is, for most companies, wildly optimistic. Managers are busy managing, whatever that means. And I believe managers can be either detailed or overview-oriented. I don't think most people do both very well. So what you get from management (both user and IT) is a quick look and a pass. But it does effectively add anywhere from a couple of hours to a week to the development cycle.
Second, I don't believe in special test groups. The only person who can really understand the change and test it properly is the coder. I strongly believe in empowering the coder to have the responsibility of ensuring that the change being made is a good one. Yes, for some projects that's going to be a big job, but the "coder" could always be a team: one person to do the SQL scripts, one to do the RPG changes, and one to do the final testing (because some people are better testers than others). I just don't like the idea of dropping an enhancement on another group of people and saying, "Here, test this." Besides, people who just test things day after day tend to snap more often than normal people, which is a problem because they always seem to be big into firearms or medieval weaponry.
Every time you pass something off to a different group, you waste time. And you force people to look at things that aren't what they were looking at a few minutes ago. I think there's real value in keeping people focused.
This doesn't mean that you shouldn't communicate about what you're doing. Team meetings in which everyone understands what each other is working on and the impact it will have on things are still necessary. But they should be short, more like Scrum meetings, not the endless meetings we all know that go on with one or two people endlessly dissecting the same thing over and over again. Oh, yeah, we know who you are. We talk continually today about training to teach people new skills. How about training to teach people how to stick to the point, say what they have to say, and shut up about it already?
Proper Change Management Will Prevent Production Problems
Yes, and fairy dust will cause pigs to fly and people like myself to become powerful warriors.
We live in a physical, probabilistic world, and despite the fact that what our society wants most of all is to eliminate all bad surprises, things are going to happen that we didn't count on. Accept it and move on.
Putting in a dozen firebreaks doesn't prevent problems; it just lengthens the time it takes us to get solutions out into production. Besides, traditional problems are the least of our worries. Poor design and crappy code cause most of the user unhappiness and, down the road, maintenance issues, but very little is done about that because it might mean stepping on someone's toes. (And don't decide to add a design review and a code review to your change process. It won't do any good.)
What does do some good is accountability. Making the primary coder the one responsible for the enhancement is the best way to ensure quality. Involve a team if necessary, but everyone on the team should know what their responsibility is and know that they need to be accountable for it. Most of the time, people will respond favorably to that.
It's Not That I Hate Change Mangaement…Or Do I?
All in all, it doesn't seem like I'm a big fan of change control as most of us know it today. I'm not. But I am a big fan of producing quality code that meets user needs.
So far, I've talked about things that I think aren't true. But what do I think is true? Ah, for that, you're going to have to stay tuned. Catch me next month, when I talk about what I think change management should look like. I know; I'm excited too.