[bluejekyll]

Versioning is generally arbitrary. I actually don't know why people pay so much attention to it.

1.0 for some people, is 0.1 for others.

1.0 might mean it's stable, or it could meant that it's feature complete. As you say it could also be used to convey the confidence the developers have in the software.

The thing I find most important myself is conveying compatibility, i.e. semver. To me that tells me it will be easy to upgrade a library, or it could be hard.

[alephnil]

It is not completely arbitrary though. Usually 1.0 for proprietary software means "the first version shipped to customers", while for open source, the very first commit is 0.0, and then it goes from there. Since it is public from the start there is no 1.0 moment. Sometimes, especially for programming languages, the 1.0 version is used to signal that from no on there will be no arbitrary change to syntax or semantics after that, so that it can be relied on.

Traditionally, version numbering has been used to signal the significance of the release. for version x.y.z, you could expect that

  * x is incremented: Major new features, possibly incompatibilities
  * y incremented but not x: Minor new features and bug fixes.
  * z changed only: Bug fixes only.

This was generally observed in both proprietary and open source software alike, and is still used in many projects. Recently many projects has abandoned this pattern, including Chrome and Firefox, the Linux kernel and others.

Of cause there has always been a pressure from the marketing departments to have a new major release, while the engineers has been holding back, so you have always seen major releases that isn't that major, and sometimes incompatible changes sneaked into minor releases. The latter has generally been considered bad form.

[dvdhnt]

I can generally agree with this save for two cases. One, I've found that major bumps in a programming language are significant, especially in the case of something like python 2 vs 3. Second, a lot of major javascript players have been using major bumps mainly in the case of breaking APIs, removing functionality, etc (ex: Lodash, ExpressJS, and - soon - React).

Contrarily, I've noticed in Rails that A LOT of major refactoring and functionality has been added via minor bumps that, while still backwards compatible for Rails itself, often breaks custom implementations, usually related to javascript modules and configs.

Overall, though, I agree with you.

[Tempest1981]

Then there was Java, where 1.5 meant 5.0. And Win 7, which is 6.1 internally.

(When engineering and marketing aren't on the same page?)