Bug versions are for bug fixes Minor versions are for non-api breaking changes (new functions, logic changes that allow for functions to be called the same way, etc...) Major versions are for API breaking changes (complete reworks of function namings)
I had a general understanding of what was happening but never really made the MAJOR.MINOR.BUG association. Probably something I could have figured out but just never had my noodle aimed at 'naming' it.
Stellaris is at 3.14.14 right now and is making the big jump to 4.0.0 in Q2 this year. So my mind made the "EW A WHOLE LOTTA STUFF THIS TIME!" rather then the "3.15 Hope I get this quality of life improvement" or "3.14.15...Prolly some fixes for something I haven't run into yet."
The important one is the major, because you have to be prepared for your code breaking when you update. At least with an api or framework you use, a game only if you're into modding i guess.
SemVer doesn't really apply to applications like games, since they don't typically have an API (other than a potential modding API) that breaks compatability. You could instead go for savegame compatability, but in some games (Stellaris included) they often break even among minor version updates. Besides, SemVer isn't really the ultimative standard when it comes to game versioning. See the plentiful MMOs that release version 1.1 -> 1.15 -> 1.2 instead of 1.1 -> 1.1.5 -> 1.2
Personally I'm a fan of either a more verbose versioning (e.g. "Update X [Hotfix Y]") or build number.
I worked a project where we had to add a fourth number, because people where getting into a panic about how often we were changing the major version. So version 1.2.3.4 was: 1.x.x.x was if all you did was install and configure, we've possibly done something that broke your config, take a look. X.2.x.x was if you did any programmatic extension, look to make sure we didn't change the apis you were using. X.x.3.x, hooray new features. X.x.x.4, we screwed something up, this fixes it.
Some of our internal libraries follow semver pretty strictly. People certainly take a double-take if that library has a version of 11.2.9 or something with a high major version like that.
Though a lot of these major changes are cleanup at this point - removal of redundant functions, renames of old mistakes everyone disliked and such (or, rather, removal of the compatibility layer during the rename) and such. Oftentimes, the deprecation notice/upgrade guide is "inline this one layer".
If you are a corporate entity 'MAJOR' may also mean 'IT IS A NEW FISCAL AND WE NEED A NEW VERSION OF OUR PRODUCT TO SELL SO PRESENT ALL THE MINOR UPDATES AND PATCHES SO FAR AS THE NEW MAJOR VERSION'
I like the one dev supporting an open source project versioning standard:
0.2.24
0->reserved. never update this. Making this a 1 admits that it is stable for production use and a literal assassin will be paid for if it breaks someone system while being a 1 major release.
2->actual major release, but people won't hurt your feelings when it breaks their stuff. When you actually get a big feature and won't to tell people, bump this.
But be careful every time you bump this you risk putting the project down and forgetting about it for a year.
24->update this weekly, even if nothing else comes with the patch. This just tracks the number of weeks that you paid attention to this project. This is so when you go back at it two years later because someone makes a bug comment, you can be like, "shit i spent like 24 weeks on this, i shouldn't let this die". This is how bad you should feel for ignoring bug reports.
FreeCAD just switched to 1.0.0 so I've seen so many "If version 1.0.0 then why not perfect?" They have the whole roadmap on their website, and the things those people want are probably not too far off.
A project manager releases version 0.9.42 of a program. Everything seems to be working mostly as expected and nobody cares much.
A few months go by. Program is at 0.11.2 and things are going good. Progress has been steady and almost all features that are on the roadmap for the big 1.0 release have been implemented to spec. Interest in the project is growing but they have heard from many potential users that they will keep waiting for 1.0 before they try it.
Three weeks later they publish 1.0-rc.1. The first release candidate for 1.0. Interest continuing to grow. People are excited for the final release that is sure to come soon. The team spends another couple of weeks ironing out the remaining small wrinkles, releasing rc.2, rc.3 and rc.4 along the way.
The big day arrives! Version 1.0 is released to great success! A low, rumbling sound is heard in the distance. A herd of bisons stampeding? Ah, it’s the users! Thousands of people are flocking to the website downloading the software to try it for the very first time! The team is excited. They pop champagne and celebrate.
But then. Then the bug tickets start rolling in. Oh no.. 😟 The team scrambles to fix some severe bugs. It takes a lot of time to triage all of the bugs. And many tickets turn out to be confusing or asking for things that was never on the roadmap for 1.0 in the first place. They get put into the backlog for future versions. Some bugs are pretty severe however. “How could we miss that?” the team says when they read one of the most serious bugs someone found. They release 1.0.1 the same night. By the end of the week the program is already at 1.0.14.
As things start to calm down a bit the team sighs a breath of relief.
The 0 state is an empty repo. By the time you distribute your first release, you've made some changes to the feature set which won't break any of your 0 existing users. That calls for a minor revision bump from 0 to 1.
6.8k
u/PandaNoTrash Mar 03 '25
That is exactly how I feel and how I number releases.