How to link static library to QT creator project properly?

Is SemVer only good for icebergs (software with a small exposed API)?

• Primarily, see ' (jashkenas) post from August 29, 2014 in the link provided below. Jeremy is the creator of the popular JavaScript library Underscore.js, which recently released a major change that many of the library's users thought should have been classified as "breaking" because it was non-backward-compatible and those who picked up the release had to deal with a ton of breaks in their code. Jeremy responded by saying, essentially that SemVer is impractical and useless for a project like Underscore, where major/breaking changes are commonplace. https://github.com/jashkenas/underscore/issues/1805 Note: SemVer stands for semantic versioning, wherein releases are numbered X.Y.Z, where X = major version (non-backward compatible/breaking changes) Y = minor version (backward compatible changes/non-breaking) Z = patches (again, backward compatible/non-breaking). Therefore, version 2.0.0 would be a breaking change and versions 1.5.0 and 1.4.5 would be non-breaking.

• Answer:

  No, I think semantic versioning is useful for software artifacts of arbitrary size. In my experience, one thing that is very difficult for a lot of software developers to adjust to when adopting semantic versioning is an emotional attachment to a majors, i.e. going up a major is a "big deal". Perhaps it is because we are used too used to "marketing major bumps", where the major goes up to signal "hey, this is a big change and possibly one you should get excited about and even (for paid software) pay for a new license". Since historically, software updates were released way less frequently, there is perhaps some further emotional assumption that majors should be "sticky" in some sense. In semantic versioning: Major going up means there is a backward compatibility breaking change. Minor going up means there is a backward compatibility-friendly extension. Patch going up means there is a bugfix. That's it. Semantic version is most useful as a signaling mechanism for users integrating a piece of software. Patch or minor goes up? Awesome. I can update my dependency with much less worry of my integration breaking. Major goes up? I should probably check the release notes to see whether that major changing is something that affects me. These days, when most signficant software projects integrate many dependencies together, having a reliable mechanism for understanding when an update is "safe" vs "takes some consideration" is invaluable. Semantic versioning is an important social tool in a shared software ecosystem. Using versioning that looks like semantic versions, but violates the principles is anti-social behaviour. If you are committed to using semantic versioning, you cannot have any emotional attachment to your majors. Bump your majors mercilessly when it's the right thing to do; let your PO or marketing guys have a "marketing version" that has no association with the semver if they really need one. If you aren't prepared to do this, you might as well tell your users, "my versions might look like semvers, but they really aren't, and read my release notes carefully on any updates, because you have no idea what I might have broken on you between releases you might think have innocent diffs". Real world experience: My team operates a production system that's only been around about 3 years (2 in production). Today it's at version 80.2.0. In our case, the major bump is often a signal to the operators (ourselves) that something has changed that we need to be very careful of on the next upgrade. It also tells other stakeholders who might be running a their own test configurations that they need to be careful when upgrading their setups. We also consume a lot of dependency updates from other teams, and often times the only/best signal we have that something critical has changed is the major being updated. If one of these dependencies breaks our integration because they tagged a major as a minor, shame on them for signaling poorly. If our integration breaks because we didn't examine the changes in a major bump appropriately, shame on us for being sloppy. Funny aside: Usually the easiest decision is to bump the minor, because it's rather clear when you've added functionality without changing existing behaviour. It's less clear when you've made a bugfix. In theory, that should be a patch... but if someone is using that bug as a feature, it should be a major because fixing the bug breaks backward compatibility. The "what kind of semver bump is this change?" exercise is great fun if your team is capable of "constructive confrontation".