Moving Forward (carefully)

It's a classic problem in software development: how to change a system to make it better without breaking existing deployments. That's the battle that comes up regularly in the OpenStack ecosystem, and there aren't any simple answers.

On the one hand, you've released software that has a defined interface: if you call a particular API method with certain values, you expect a particular result. If one day making that exact same call has a different result, users will be angry, and rightfully so.

On the other hand, nobody ever releases perfect software. Maybe the call described above works, but does so in a very unintuitive way, and confuses a lot of new users, causing them a great deal of frustration. Or maybe a very similar call gives a wildly different result, surprising users who didn't expect it. We could just leave them as is, but that isn't a great option. The idea of iterative software is to constantly make things better with each release.

Enter microversions: a controlled, opt-in approach to revising the API. If this is a new concept, read Sean Dague's excellent summary of microversions. The concept is simple enough: the API won't ever change, unless you explicitly ask it to. Let's take the example of an inconsistent API call that we want to make consistent with other similar calls: we make the change, bump the microversion (let's call this microversion number 36, just for example), and we're done! Existing code that relies on the old behavior continues to work, but anyone who wants to take advantage of the improved API just has to specify that they want to use microversion 36 or later in their request header, and they get the new behavior. Done! What could be simpler?

Well, there are potential problems. Let's continue with the example above, and assume that later on some really cool new feature is added to the API. Let's assume that this is added in microversion 42. A user who might want to use this new feature sets their headers to request microversion 42, but now they may have a problem if other code still expects the inconsistent call that existed in pre-36 versions of the API. In other words, moving to a new microversion to get one specific change requires that you also accept all of the changes that were added before that one!

In my opinion, that is a very small price to pay. Each microversion change has to be documented with a release note explaining the change, so before you jump into microversion 42, you have ample opportunity to learn what has changed in microversions 2-41, too. We really can't spend too much mental effort on protecting the people who can't be bothered to read the release notes, as the developers and reviewers have gone to great lengths to make sure that these changes are completely visible to anyone who cares to make the effort. We can't assume that the way we did something years ago is going to work optimally forever; we need to be able to evolve the API as computing in general evolves, too. Static is just another word for 'dead' in this business. So let's continue to provide a sane, controlled path forward for our users, and yes, it will take a little effort on their part, too. That's perfectly OK.

Leave a Reply