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

[Miles Bader]

Zack Brown <address@hidden> writes:
> 1) the nomenclature "version" is a little misleading. I think I would
> have had a much easier time understanding this feature if it were called
> "series". I suggest converting the 'version' nomenclature to 'series' or
> "version series".

I agree in general; some people might use version as a `real version,'
and others might use it just as a sequence number (I do this).

I don't think the term `version' is misleading though, and it seems as
good as anything.

> 2) the convention "category--branch--version" doesn't indicate the most
> likely relationship between the three elements. As you've said, it's much
> more likely that 'version' will refer to a version of the category, and
> should thus be bound more tightly to 'category' than to 'branch'. On the
> other hand, nothing is lost by putting 'branch' at the end of that trio,
> because a branch may be split off under any circumstances.

This is completely arbitrary -- the version/sequence number of a branch
_may_ be related to the version/sequence of other branches, or it may
not (or more likely, it's related to _some_ other branches, but not
others).

If you use the version as a simple sequence number, I think it's much
more natural to think of it as a division of the branch (it doesn't even
really seem to make sense to think of `sequence 1' of the top-level
category).

Even when you use a convention like `--devo--VERS' where VERS is the
`real world' version, it's also completely arbitrary how you order the
two components:  Is `devo' a branch within each release version, with
each new version having a new `devo' branch?  Or is `devo' a long-lived
branch of the category, that has per-real-world-version divisions.

> Another way of looking at it is in terms of what changes most often. The
> category name is only changed when you go to work on a completely different
> project. So that is the most stable element of the three. The version is
> only changed for a new series of releases, while there can be many branches
...
> 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.

> 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!