Take the 2-minute tour ×
User Experience Stack Exchange is a question and answer site for user experience researchers and experts. It's 100% free, no registration required.

I've written a piece of software, and am trying to decide whether to call it version 0.0.0.0 or version 0.0.0.1.

Logically speaking, it is version 0.0.0.0, and the system tool I am using allows this version number to be used.

However, I don't know if users or other people involved in designing the project will find this confusing, since the first version of something must surely be version 1.

share|improve this question
5  
I think this belongs on programmers.stackexchange.com and not here. –  Danny Varod Jan 24 '13 at 16:19
    
They will simply say version 0.0.0.0 because it's the right answer logically speaking. –  Urbycoz Jan 24 '13 at 16:21
    
Who is the consumer of this version number? In what context will they encounter it? –  Alex Feinman Jan 24 '13 at 16:27
    
@AlexFeinman The users of the system will be able to see the version number when the click on a menu item within the system. Will seeing v0.0.0.0 confuse them? –  Urbycoz Jan 24 '13 at 16:43
3  
Oh, you're releasing it! Behold the power of calling something "v0.xxx"--I just assumed it was internal. –  Alex Feinman Jan 24 '13 at 17:42

5 Answers 5

up vote 7 down vote accepted

The first number in a machine oriented environment might be "0" but i suppose that it would actually be confusing for the people involved in the project – so you better stick to the "1" as the first (1st) number. Otherwise you will sooner or later have continues problems when talking on the phone about "the third version" which would then have the "2".

And additionally I can just recommend to keep it simple – instead of having "0.0.0.1" I would instead start with "0.1". Then continue through "0.2 … 0.9" and then go on with "0.10" and "0.11" and so on.

Once you have a stable version or a first release call it "1.0" –– the first update of that version is then again "1.1" and so on. If it's untested you could add a "b" for "beta" and if it still is very buggy add an "a" for "alpha".

btw: at some point it might be that the client (or "the other people") expects the final version already after "v0.9" – and some others might think that "v0.9" is something like a dead end and want to continue with "v0.9.1" or even worse "v.0.91" –– but it should be "0.10".

share|improve this answer
    
I'm limited to the four digit version number (x.x.x.x) by the software I am using. But then I guess the users don't need to know that. –  Urbycoz Jan 25 '13 at 10:17
    
@Urbycoz: 2 of those 4 digits are for more technical people. That is, you announce the first 2 digits but used the last 2 to differentiate between different versions of the same product release (e.g., one of those extra digits could be a build number that increments on every compile). Only the first 2 digits are normally used within advertisements and promotional material, but you may use the last two digits for technical support (e.g., determining if your users are up to date on patches). –  Brian Jan 29 '13 at 18:53

While the convention seems to be that main version numbers can start with 0. I don't think there ever is a 0.0 or 0.0.0 version.

The leading 0 suggests development, i.e. "not yet a released version" - as compared to 1.xx and so forth, which show the main release number.

You should definately start with 0.0.0.1 - any version you publish is already a version, so logically, there can't be an absolute zeroth version of your software. The initial zero just designates the overall development status, but each release has a positive integer number somewhere in the subversion numbering.

Reading through this wikipedia article will be helpful. Even though there is no definitive answer it certainly does not show any examples of 0.0.0 as initial version, but mentions 0.xx as designated beta or pre-release.

Edit:

semver seems to be a popular guideline for versioning, and in its faq it states (retrieved 2013-01-29):

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.

(just saw @iamdto has answered quoting the exact same excerpt earlier)

share|improve this answer

As you surely understand - this is a mine field you're stepping into with this question. But it's great fun and I'll do a reasonable try to answer this question. So lets start in the beginning, shall we?!

Software versioning is the process of assigning either unique version names or unique version numbers to unique states of computer software. Within a given version number category (major, minor), these numbers are generally assigned in increasing order and correspond to new developments in the software. At a fine-grained level, revision control is often used for keeping track of incrementally different versions of electronic information, whether or not this information is actually computer software. Reference: Software Versioning

That said there is no convention of how many groups of number to use. Some use four groups (like Microsoft), others three. The important thing to remember is that the order is left to right. 1.0.0 is greater than 0.9.9.

There are some developers who use 0 for alpha version, 1 for beta version, 2 for release candidate and 3 for final and production ready.

Some rare cases like SmartEiffel use negative numbers starting at -1.0. The S.u.S.E Linux distribution started at version 4.2 referenceing 42, "the answer to life, the universe and everything" mentioned in Douglas Adams' The Hitchhiker's Guide To The Galaxy. The current Slackware version is at 13.37 referencing leet.

So it's fair to say that anything you use is neither right nor wrong. The advice would be to use a versioning system that works for you, and that you document how your versioning system should be read.

share|improve this answer

SemVer states this :

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.

I think that makes sense for end users (those that will download your app) because the average people are used to start counting beginning from 1 in their everyday life.

share|improve this answer

Usually versions starting with 0 pre-production or beta/alpha versions. Once they are in a public (non beta) level of development, they usually start numbering from 1.

So the very first development version would usually be something like v0.0.0 (with as many dots as you like), but v0.97.2 would still be pre production ready. V1.23.2 would be an early production version, and v17.87.3 would be much later.

There are however many exceptions to this, and no hard and fast version numbering rules.

share|improve this answer
    
That's not really what I'm asking. Essentially, should I be calling the first version of something v0 or v1? –  Urbycoz Jan 24 '13 at 16:23
1  
@Urbycoz that depends on what you mean by first. Is it the first commit of any code? The first beta release? The first stable public release? –  JohnGB Jan 24 '13 at 16:25
    
I'm sorry, you're not understanding my question. My point is not accuracy, but whether the perception of users should be given priority over logic. –  Urbycoz Jan 24 '13 at 16:41
    
@Urbycoz I've reread your question and my answer, and I don't see the problem. Come onto chat and maybe you can explain it better. –  JohnGB Jan 24 '13 at 16:49
1  
+1. 'Most' people (i.e., non-techies) do not work in a 0-based numbering scheme. "Version 1" is the first incarnation, not the second, in their minds. –  Alex Feinman Jan 24 '13 at 17:43

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.