I was taking a look at https://gcc.gnu.org/releases.html and saw that the GCC version numbers aren't increasing monotonically with respect to the date unlike most products where the most recent version has the largest version number.
e.g., GCC 8.5 was released 5/14/21, and 11.1 4/27/21.
Why are the version numbers for gcc structured this way?
Based on reading how they format their version numbers, it seems like its because each major release ends up as a branch with their own number of fixes rather then features. There may be reasons on why you would want to stay on the 8.x branch rather then 11.x branch due to compatibility issues, which is why they release fixes for older branches. You can read more here. Hopes this helps clear things up!
Related
I have a utility service x which is in maven repo and is used by some of my other services. We normally update the minor version of the service x when we make small changes and we are currently on version 1.0.15.
No I am making another change and I was thinking whether I should update version to 1.0.16 or I should update the version like 1.1.0.
If anyone can provide an explanation on how this should be done in general, that would I am sure help other developers as well as me. Please let me know if you need further information.
Different projects follow different standards on this, so follow what the repository has done to date.
A well-regarded standard for this is called Semantic Versioning (https://semver.org/). If you are starting a new project or there isn't a standard already in place, I would recommend using this.
Semantic Versions are in the format: MAJOR.MINOR.PATCH.
If you have fixed a bug: increase the patch version
If you have introduced new functionality in a non-breaking way: increase the minor version (and reset patch to 0)
If you have introduced breaking changes: increase the major version (and reset the patch and minor version to 0).
If you are unsure whether your change is a breaking change or not - consider your package (or API) from its consumers' perspectives. If their code has to change as a result of your change then it's a breaking change.
I'm using Yarn and when I installed my packages, I wanted to update them. I am really new to this so I having trouble understand what each one meaning.
An explanation would be helpful as I am not getting it from Googling.
(I am using this to install and working with SPFx).
yarn outdated v1.17.3 outdated
info Color legend :
"<red>" : Major Update backward-incompatible updates
"<yellow>" : Minor Update backward-compatible features
"<green>" : Patch Update backward-compatible bug fixes
Edit: - Finally think I understand..
red = Major Update. The updates are NOT backward-compatible.
yellow = Minor Update. The updates have backward-compatible features.
green = Patch Update. The updates are just patches to fix bugs, and are backward-compatible.
Please correct if wrong.
You are quite correct. NPM packages use Semver (Semantic Versioning) to indicate a package version. The version number isn't merely just an incremented number, it tells you a bit about what happened with an upgrade.
So you will most of the time have a version numbers that look like 1.2.3 or (MAJOR.MINOR.PATCH), where:
MAJOR - Big changes that changes the way the package is used, so you might need to update how you use/call the corresponding package. The update is thus not backward compatible.
MINOR - New functionality was added to the corresponding package, your code doesn't have to change. The change is backward compatible.
PATCH - No features were added, patches normally include bug fixes or small optimisations to a package.
Sometimes there is more meta data in the version number, for example 1.0.0-rc.1
indicates that this is a Release Candidate. Other examples include 1.0.0-alpha or 1.0.0-beta.
You can read more on Semantic Versioning at https://semver.org/
When I go to gcc's web site https://gcc.gnu.org/, I see 3 current versions: 5.5, 7.2, and 6.4. Unfortunately, there's no explanation anywhere I could see of what the differences between the three might be. One would expect that 7.2 would be the most recent but that doesn't appear to be the case, as they are all relatively recent (in fact 5.5 is more recent than 7.2). Does anyone know what the differences are and why one might be preferable to the others?
thanks
Major versions add new features. Minor versions fix bugs. If a bug is found in an earlier major version, a new minor version is released to fix it.
I have built my first ruby app there: https://rubygems.org/gems/youtube_dlhelper. As shown in Versions the correct versions are available: 0.1.0, 0.1.1 and 0.1.2.
But it looks like rubygems lists just the oldest 0.1.0.
Maybe anyone knows why?
The latest version of your gem is not showing up as the default because it does not conform to the Semantic Versioning specifications. Although it may seem obvious to us as humans that 0.1.2.alpha is greater than 0.1.0.alpha, a quick look at the spec shows that this is the incorrect way to specify a pre-release. Here's a relevant excerpt (emphasis added by me):
A pre-release version MAY be denoted by appending a hyphen and a series of dot separated identifiers immediately following the patch version. Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes. Pre-release versions have a lower precedence than the associated normal version. A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version. Examples: 1.0.0-alpha, 1.0.0-alpha.1, 1.0.0-0.3.7, 1.0.0-x.7.z.92.
I'm not exactly sure how 0.1.2.alpha is being interpreted, but I think your best bet is to release a 0.1.3 version of your gem and yank the incorrectly versioned ones. You may even try releasing a 0.1.3-alpha, but I'd wait until someone more knowledgable can a give a more definitive answer.
In the meantime, I'd definitely encourage you to look at the Semantic Versioning specs.
What is a product version? why it changes randomly?
For example. Firefox new version is v.3.6.7. their previous version is v.3.6. my doubt is why they don't use v.3.6.1 instead of using v.3.6.7. Is any specific reason behind this kind of versioning. or they give it randomly.
Each product chooses the versioning strategy differently, but it's usually something styled in the following manner:
3.1.1.123456
major version (big API / behavior incompatibilities; huge new features); example - iPhone 3 vs. iPhone 4
minor version (minor new features, speedups, basic API/behavior is unchanged and usually backward compatible); example - iPhone 3 vs. iPhone 3GS
release version (bug fixes in a specific minor version)
Version control tag or build identifier to quickly match the version string to a version control tag.
Any of those do not have to be sequential in number - versions can be skipped for any reason.
my doubt is why they don't use v.3.6.1 instead of using v.3.6.7.
They did release all the previous ones: Mozilla Firefox 3.6