[Gnu-arch-users] Re: What are version numbers?

[Zack Brown]

On Thu, Sep 11, 2003 at 11:20:56AM +0900, Miles Bader wrote:
> Zack Brown <address@hidden> writes:
> > So I suggest converting the naming convention from
> > "category--branch--version" to "category--version--branch". And if you
> > accept my first suggestion as well, it would become
> > "category--series--branch".
> 
> No, this is silly -- you're trying to assign a specific meaning to
> versions, and the relationship between branches and versions.  Arch
> currently defines no such meaning or relationship, and it shouldn't
> (as indeed you say in your first point!).
> 
> Morever, because the meaning of the version number is arbitrary,
> different branches can use _different_ conventions -- e.g., I might use
> the real-world version for my `release' branch, but a simple sequence
> number for my `x' (experimental) branch.  Given this, it would be
> completely confusing if you put the version number first, as it would
> imply some ordering among the numbers, when they are in fact unrelated!
> 
> For instance, if I have:
> 
>    foo--devo--VERS          :  foo--devo--1.0, foo--devo--1.1
>    foo--release--VERS       :  foo--devo--1.0
>    foo--x--SEQ              :  foo--x--0, foo--x--1, foo--x--2
> 
> Under the current scheme you get this:
> 
>   foo
>     foo--devo
>       foo--devo--1.0
>       foo--devo--1.1
>     foo--release
>       foo--release--1.0
>     foo--x
>       foo--x--0
>       foo--x--1
>       foo--x--2
> 
> This seems fairly straight-forward to me.
> 
> However, if arch were to use your scheme, you'd get:
> 
>   foo
>     foo--0
>       foo--0--x
>     foo--1
>       foo--1--x
>     foo--1.0
>       foo--1.0--devo
>       foo--1.0--release
>     foo--1.1
>       foo--1.1--devo
>     foo--2
>       foo--2--x
> 
> Which seems quite muddled.

Thanks Miles, this is exactly what I was looking for.

So I think what comes out of this whole discussion is that version
numbers are intended to follow conventions set by the user. That's a
pretty simple answer, considering how confusing the issue seemed at
first.

I think the problem was that version numbering has many connotations for
software projects, and the most natural assumption is that tla imposes some
undocumented requirement upon their use. So I was racking my brains and
scouring the tutorial, trying to figure out what those requirements were. At
first I assumed it imposed a versioning scheme on the project under version
control, or that each version of the project had to have its own branch to
reflect the true project version number. Even though wrong, I think it's
the most natural assumption for a beginner.

The bottom line seems to be that tla version numbers will most likely be
used to refer to the project version (series), or to a version of the tla
branch itself, or something else that might relevantly use a version number
in that situation.

That's all fine. It appears that the secret to tla version numbers is that
there is no secret. Just use them in a way that seems appropriate, and that
doesn't necessarily correspond to the project version numbers themselves.
That's actually really cool and flexible.

I think about 2 or 3 sentences in the tutorial would be enough to clear that
question up completely. BTW I'm not the only one who found it completely
opaque before this thread.

Be well,
Zack

> 
> > I think those suggestions taken together preserve the functionality of tla,
> > while adding some good clarity and intuitiveness (downward scalability)
> > to the structure.
> 
> No, they don't.  The current syntax is fine.
> 
> I basically agree with your first point, but that is at most something
> to clarify in the documentation.
> 
> -Miles
> -- 
> Run away!  Run away!

-- 
Zack Brown