We are planning to use a setup that uses several modules to complete a whole application, example modules include:

  • The core (code shared by all other modules)
  • The server
  • The client (Windows, OS X, Linux)
  • The client (iOS)
  • The client (Android)
  • Tool #1
  • Tool #2

And now while we preparing to deliver our first release, it is a good time to think about the numbering scheme. We have defined to use a major.minor.patch format, but we are struggling about one question:

Should every module have the same version number as newest release, and consequently, should we bump version numbers if there has been no update to them?

Example to illustrate:

1) Assume all our components are running on version 0.1.0 (early development), once we do a significant update, should then all components be bumped to version 0.2.0?

It also works the other way around:

2) Assume again every component is running 0.1.0 initially, and now we introduce a signifcant update (could be a GUI rework) on the Android client, should we then release a version 0.2.0 for every component, even though the other versions have not received any update?

And perhaps the most tricky one:

3) Assume that we still run 0.1.0 one very component in the start, and we figure out Tool #2 has a bug and we need to hotfix it to 0.1.1, should we also then update every component to 0.1.1?

I am currently doubting whether we should pursue correct versioning, or should go for compatability? People outside to the development team will most likely expect that all modules run on version 0.3.0 for example, while we as developers are a bit confused and perhaps feel uneasy with bumping a version number up, while the module did not have any change to it.

What is the best way to deal with this?

Edit, something I have forgot to mention, but which may change opinions is that all releases will be done in automated way. On Github/git a specific commit will be tagged being version major.minor.patch and after that the build system (here: Travis CI) will pick up the tag and automatically build every release and publish it somewhere if necessary and/or wanted.

  • 2
    Are the modules independently deployable (in reality)?
    – Telastyn
    Commented Sep 8, 2014 at 19:02
  • @Telastyn Yes, we can make it that way (Android and iOS client for example could be pushed at different days), but it would make our build & release system more complicated.
    – skiwi
    Commented Sep 8, 2014 at 19:04
  • If you don't rerelease components just for a version bump, I still would assign the latest release number based on the overall system, not the prior release of the same component. For example, if after releasing 0.1.1 of Tool #2, you needed an (unrelated) update to the Android client, it would skip 0.1.1 and become 0.1.2
    – Ben Voigt
    Commented Sep 8, 2014 at 19:04
  • "while we as developers are a bit confused and perhaps feel uneasy (...)", speak for yourself! :) Commented Sep 8, 2014 at 19:07
  • 6
    What's the point of giving each component its own version number if it doesn't indicate the version of that component? If the "version" really just indicates the version of the overall application that that component belongs to, that's fine, but you should make it clear that the number is the app version, not the component version. And as you say, any update to any component means that you have to release new versions of everything, which sort of defeats the point of a component architecture in the first place.
    – Caleb
    Commented Sep 8, 2014 at 20:11

4 Answers 4


First off, there is no correct way.

However, I have found that keeping all version numbers the same across releases, regardless of whether things have changed or not, makes things much easier down the road. If I want to know what has been going on in a software, all I want is to be able to easily go from a version number to a state in version control, and see whats going on in there. Having a collection of unrelated version numbers makes doing that murky.

The alternative is that ultimately you have to maintain some sort of BOM for your software releases to know what's what, and those invariable end up out of date or incorrect, and everything just becomes a big mess.

There have been situations I've worked on where products did have a mismatch of version numbers for various dlls. It was a medical device software, and the developers rationalized that by not changing certain parts, they could avoid doing testing and verification for those parts. It may have saved work there, but it has created plenty of other work and harmed credibility with distributors when even the company wasn't sure what was what because of the hard to understand versioning scheme.

  • 3
    +1, I agree that keeping all version numbers equal makes a lot of things easier (we apply the same strategy for our main product currently). Nethertheless the other strategy (own version numbers for the modules - at least own minor version numbers) is IMHO a viable solution. If done with care it does not have to become a mess, and it is definitely the better approach if server and client modules cannot always deployed synchronously.
    – Doc Brown
    Commented Sep 8, 2014 at 22:17

Take a look at semver.org a standard for versioning.

Translating it to your situation, it would probably mean that the major versions would not be compatible with each other, so a 1.0 server can not work with 2.0 clients. The minor versions would be compatible with each other, so a 1.2 server can work with a 1.1 or a 1.5 client, but personally I would recommend to release all the components when you bump the minor version number. Bugfix/patch numbers should be bumped when a bug was found, but I wouldn't release all components for this.

As for your question "Is it correct", of course it is. In case of versioning there is basically no right and wrong, the question you should ask yourself is: "is this versioning scheme convenient for us (and does it cost us extra work or saves us work), and is it clear to the user?".


No. If there has been no change to a module, it shouldn't get a new version number. Otherwise you're just sowing confusion and making more work for whoever's doing your release work. I think you'll also find it's easier to track down problems when you can see which modules have really changed as opposed to those which have simply had their rev bumped.

  • I've edited the post slightly at the bottom, I forgot to mention that all releases are automated, this may change your opinion.
    – skiwi
    Commented Sep 8, 2014 at 19:32
  • You know what's a better tool to find out when things have changed? Source control. Commented Sep 8, 2014 at 21:24

Finding which components have code base changes can easily be done with version control software. However, a valuable piece of information inferred by updating all version numbers is that it clarifies that those components are known to be compatible with each other.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.