It's funny that programmers treat zero-indexing arrays and things as normal (even "correct"), but suddenly zero-indexing versions is something wacky. What's weird to me is that 0.0.0 isn't more common in the developer world, given how frequently we start counting from 0.

Because non-developers deal with versions. Sure, programmers use zero-indexing because it makes a lot of common things a lot easier, but I can't imagine anyone expecting that to extend to the regular world where the first item being 1 is ingrained, and makes more sense given the use.

For this reason, 0.x versions can make sense - they serve as a good flag for 'this is pre-release', because people expect version 1 to be the first released version.

Yeah, but 0-based array indexing is a convenience measure.

In the real world everybody would just call a[0] "the first element of the array".

Time to use lisps, am I right? :)

I find 0.0.x versions wacky too. Version numbers (in contrast to array subscripts) are only useful in relation to previous version numbers. Ideally when a new version of the software I use comes out I can decide whether to upgrade only by comparing the version number with the one I use. E.g. in semver increased minor number means "new functionality added". So when 0.0.0 version comes out, what does it mean, compared to the absence of software? No functionality at all? :)

What does 0.0.1 mean, compared to the absence of software? You can't compare 0.0.1 to anything if there's no other previous release.

Starting at 0.0.1 is at least just as arbitrary as starting at 0.0.0, and your aversion to starting at 0.0.0 suggests you're making implicit assumptions about what the non-existent 0.0.0 means when starting at 0.0.1. But if 0.0.0 doesn't even exist then you can't really make any assumptions about it.

At least 0.0.0 is clearly the very first version of something. Starting at 0.0.1 doesn't make clear that there isn't an earlier 0.0.0.

For me, personally, 1.0.0 feels right as the first version. Compared to nothing, the first release is a major and there have been no minors.

I guess I don't really see version numbers as indexes but as cardinals, hence why leading zeroes seem weird to me.

It means "don't use this yet".

To me, 0.x version numbers suggest that a project is not stable and can change in incompatible ways at any time... or be abandoned, even. 0.0.x, even more so. That said, some projects stay in 0.x territory for so long that this no longer applies.

0.0.0 is kind of weird... for some reason it suggests to me that zero lines of code have been written so far. (If there was code, the version number would have been higher.) But this is obviously not the case here. I do wonder what versions they used before this release?

Then again, I know of at least one non-trivial project that used negative version numbers... I guess, in the end, it just means what the developers say it means.

Maybe it's because I come from a physics background, but 0.0.0 also seems to me as the version for the first thought of building something. So after one writes any amount of code, it should get incremented to 0.0.1 or something..

0.x.x means pre-release to me (as in, sure - play with it, but don't fucking rely on it working).

0.0.0 is bizarre though.

> "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-]" [1]

I think they should use 0.0.1-pre instead of 0.0.0. The version 0.0.0 I would consider as "the development have not started yet".

[1] http://semver.org/

I think this advice is even more pertinent:

> How should I deal with revisions in the 0.y.z initial development phase?

> The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release.

Source: http://semver.org/#how-should-i-deal-with-revisions-in-the-0...

I don't get it why I got down-voted since I haven't suggested to use 0.0.1-pre. I have just pointed out that is weird to release version with only zeros - we usually take zero as point to "nothing, void" for non-techie folks (most of end-users).

Oh If you would search SemVer repository on GitHub then there are some mentions about 0.0.0 [1]. It is interesting point of view but I prefer non-production versions ready as 0.x.y, where x is greater or equal to 1. So yes, the 0.1.0 is way more meaningful and I recommend it.

[1] https://github.com/mojombo/semver/issues/221

I'm happy to see the 0.0.0 release - it means that I might just be using this some day. Few weeks ago, having not heard about the project for a while, I was afraid it had become vapourware.

I'd argue it is a placeholder, not a proper release - it's an announcement for interested people to look into it and join the project.

From the release notes:

> This is a first alpha release

Alpha typically means feature complete, but untested and thus unsuitable for general release. You don't need to use good-looking version numbers for that.

Beta means what you think alpha means. Alpha means that some features are done, but others aren't, and the entire application is still subject to change.

If that would be what alpha means, there's no way to indicate non-feature completeness...

It's not even remotely close to being feature complete as of speaking.

What major features are missing? It looks like everything is there.

0.0.x = proof of concept? 0.1.x = first actually usable version (but may be buggy, missing features, etc.)

Server recommends starting at 0.1.0 – starting at 0.0.0 essentially means (to me at least) that nothing has been written and nothing has been released. Initial versions (IMO) should begin with 0.1.0.