I think there is some nuance in here but it's worth discussing.
For example, if a project is using SemVer there are a couple parts of the spec that come to mind...
4. Major version zero (0.y.z) is for initial development.
If a project doesn't have a 1.0.0 yet and it's using SemVer than I don't think it should be graduated because it's still in initial development.
I realize different people do different things with versions. But, versions are about communication. Graduated projects should be clear on their communication of versions.
1. Software using Semantic Versioning MUST declare a public API.
8. Major version X (X.y.z | X > 0) MUST be incremented if any backwards
incompatible changes are introduced to the public API.
and on the CNCF projects page it talks about Graduated Projects being for the majority. They aren't experiments but things that more cautious businesses can adopt.
A graduated project should state what it's API is (network, library interface, UI output, etc) and then properly version that so that consumers can know what they are getting and when things will change.
These are policy based and different projects can do different things. For example, Kubernetes does not follow SemVer but does specify what is in the supported API policy and how it changes. Helm does something similar with the Go API and output from helm commands. For example, on Helm we have one place where the date format is different from the rest in the output but we can't change that until Helm v4 as a default because we know external tools parse that output.
I would expect graduated projects to do things in a way that communicates clearly on what's happening with versions and have stable releases.
Just my 2 cents.
- Matt Farina
On Thu, Jan 14, 2021, at 1:33 PM, alexis richardson wrote:
IMO, everyone's using version numbers in different ways now. For example many projects go to 1.0 once they are feature complete, and hit production way before that. I think insisting on 1.0 for graduation is unfair and not very helpful.
I realise that many enterprise users still see 1.0 as being the first production ready version. Much as Quinton says.
So, I suggest we leave everything as it is, and make sure that our own graduation criteria are clear.
On Thu, 14 Jan 2021, 18:27 Quinton Hoole, <quinton@...
I'm not convinced that in people's minds, or practically, v1.0 and Graduated mean similar things. As a concrete example, Kubernetes went to v 1.0 several years before it graduated. In my mind, version numbers tend to denote the maturity of the software. Graduation levels add to that the maturity of the process and community around the software.
I do however think that there would be value striving for some amount of consistency in the semantics of version numbering across CNCF projects (possibly) to avoid the kind of confusion that Liz ran into. I don't know exactly what that would look like, but I imagine something along the lines of:
- pre 1.0 denotes "not recommended for production use"
- post x.y denotes "go for it, people are starting to use it successfully in production"
- post p.q denotes "rock solid, widely used in production - almost definitely graduated unless there are extenuating circumstances"
... and so on might make sense.
This detail may well have been debated in depth elsewhere in the CNCF, in which case I apologise for not being up to speed on that :-)
+1 imo a graduated project should have some documented backward compatibility guarantees and semantic versioning helps denote this. It has been a best practice on all the projects I've worked on. I'd be supportive of adding a criteria around stability and defining
what that means and recommending using a semantic version to denote this for graduation.
Someone I spoke with today said something along the lines “if <this project> is stable, why is it still at v0.something?” and that got me thinking - does it make any sense to expect Graduated projects to be at v1.0 or above?
I know this is easily gamed, in the sense that project maintainers can release any version number they like, but let’s set that aside for now and assume that maintainers are well intentioned. I wonder if the signals that are sent by releasing
a v1.0 are similar to what Graduation means?
(I have not checked the version numbers of existing graduated projects)