Slashdot Mirror


Romance and Rebellion In Software Versioning

joabj writes: Most software releases more or less follow the routine convention of Major.Minor.Bugfix numbering (i.e. Linux 4.2.1). This gives administrators an idea of what updates are major ones and might bring compatibility issues. As Dominic Tarr points out in his essay "Sentimental Versioning," a few projects boldly take on more whimsical schemes for versioning, such as Donald Knuth's use of successive Pi digits to enumerate new updates to TeX, or Node.js's punk-rock careening between major and minor releases. If you break convention, Tarr seems to be arguing, at least do so with panache.

86 comments

  1. Semantic Versioning by bondsbw · · Score: 5, Informative
    --
    All my liberal friends think I'm a conservative, all my conservative friends think I'm a liberal.
    1. Re:Semantic Versioning by Anonymous Coward · · Score: 0

      That does not take distribution into effect. What happens if there are two independent "major" releases at the same time?

    2. Re:Semantic Versioning by Chris+Mattern · · Score: 1

      What happens if there are two independent "major" releases at the same time?

      Then they should each have their own name, and their own version sequence.

    3. Re:Semantic Versioning by Anonymous Coward · · Score: 0

      Whomever though up "semantic versioning" was sadly ignorant of the long-established and successful prior art of libtool versioning (http://www.gnu.org/software/libtool/manual/html_node/Libtool-versioning.html).

    4. Re:Semantic Versioning by Junta · · Score: 2

      Got an example at hand?

      foo 1.2.3 and foo 1.3.4 might both release as independent stable branches. 1.2.3 might release after 1.3.4, and that would be ok. Ditto for foo 2.1.3 releasing before 1.9.20. So in terms of the upstream, it's perfectly capable of describing concurrent releases.

      If you refer to giving room to linux distros to ascribe another tier of versioning, that's why packages append their own revision and flavor (e.g. -5.el6 and -10.el7 may refer to both different generations of the package targeted at RHEL/CentOS6 v. 7.

      If you are instead referring to some sort of disagreement in how the project moves forward, that's a fork with a rename (e.g. Gnome v. MATE, Trinity v. KDE),

      Not seeing how that argument stands against semantic versioning. Arguments can be made whether or not one can meaningfully honor the promise of the versioning for very large, complex projects, but at least for smaller projects it's a reasonable enough approach.

      --
      XML is like violence. If it doesn't solve the problem, use more.
    5. Re:Semantic Versioning by Junta · · Score: 1

      While there is a practical facet of that approach, it misses a lot of things.

      For one, if you want *only* bugfixes and *nothing* to change functionally in some app you use (or your confidence in the upstream to make feature changes without regressions is low), then semantic versioning offers a promise that you can use to select what you pursue. libtool speaks strictly only to functional compatibility, but some want to track beyond that promise.

      Similarly, it speaks specifically to how API/ABIs work, not things like expectations around it interacts with a human. For example, a UI redesign wouldn't necessarily mean anything according to libtool versioning system, but it may be a huge thing for people trying to use the software, and they may want a way to tell pre-redesign from post-redesign.

      Now the duration for which one can chase such areas hoping for backports of fixes, that's probably a big way in which the promise of semantic versions fade quickly (at least without some sort of out-of-band data about how *long* the project in question promises to try to backport).

      --
      XML is like violence. If it doesn't solve the problem, use more.
    6. Re: Semantic Versioning by Anonymous Coward · · Score: 0

      What about projects that do not have apis?

    7. Re:Semantic Versioning by rrr00bb5454 · · Score: 1

      The version numbering should specifically speak of contracts between components, or else it's not robust enough to help with automating things. Roughly speaking: the contract is the header files exported (or IDL files), and an implementation of the contract imports those header files. The header files should contain all documentation that pertains to the contract, and even documentation changes to the contract should bump the contract version up, while the implementation imports the contract just like the client does. The contracts "5.0" and "5.1" are not necessarily compatible in every way, because the interface expanded; which will cause things like structures having incompatible sizes in C, or unimplemented interface members in Java. For this reason, 5.0.20 and 5.1.20 might be the same implementation exposing two different interfaces. Both being version "5" basically means compatibility at the level of source code, and both being "5.1" should mean that they both work with the same contract. That means that there is agreement on: structure members, sizes, which functions exist, their preconditions and postconditions, data layout in buffers passed around, etc. Assuming that "5.7" can use "5.2" should be expressed in an explicit and computable way. A "5.7" component might export a "5.2" interface, but it should be done explicitly. In the real world, there are compatibility outages in places where theoretically things should be compatible. It's almost easier to dispense with version numbers, and simply declare that if A talks to B, then they both import C of the same git commit, or a C in a list of supported interfaces. Otherwise, the versioning is just a bunch of marketing stuff that has little to say about what is actually connected to what.

  2. Sofware versions should stop at 10 . . . by PolygamousRanchKid+ · · Score: 5, Funny

    Some can go up to eleven, but most should stop at 10.

    --
    Schroedinger's Brexit: The UK is both in and out of the EU at the same time!
    1. Re:Sofware versions should stop at 10 . . . by Kenshin · · Score: 1

      But the minor number should keep going past 10, just to make things difficult for pedants. :)

      "OS X 10.11? Where's OS XI? Oh my god I'm going insane!"

      --

      Does it make you happy you're so strange?

    2. Re:Sofware versions should stop at 10 . . . by Anonymous Coward · · Score: 0

      Ooh, oh ... you could always consider recycling. Since version 1 & 2 & 3 have not been used for a long time then just start using those numbers again. Think of all the space you'll save by not having to deal with a new higher number. And the greenies will be happy because recycling should always be a consideration ... :-) While this is an idea, it might not be in my top 10 best ideas list

  3. Sure... by Anonymous Coward · · Score: 1

    you could do something whimsical. Alternately, you could not be an asshat. Sematic versioning FTW!

  4. Integer by Anonymous Coward · · Score: 0

    Start at 1 and just increase with 1 with each version. No dots, no nothing. Just an integer that is increased with every new version. Done.

    1. Re: Integer by Anonymous Coward · · Score: 0

      yyyymmdd

    2. Re:Integer by fisted · · Score: 1

      Done.

      Done what exactly? I mean, apart from turning a version number into a meaningless number

    3. Re:Integer by Anonymous Coward · · Score: 0

      Of course it's not meaningless. Compared to many other version schemes this actually has meaning, a larger number is newer. But what about API breakage you might ask. Simple, do as Linus says and NEVER BREAK API. There, done.

    4. Re:Integer by Anonymous Coward · · Score: 0

      Instead of arguing about major, minor or bug fix, it's just a simple release number, done in order of issue. While I wouldn't argue that it's the best way, there is a simple elegance to it.

    5. Re: Integer by Anonymous Coward · · Score: 0

      So you released version 111 and some people downloaded it and purchased a support contract. Then you add a major new features in version 112 that due to their awesomeness have to break backward compatibility with version 111, and for that reason the aforementioned customer is not going to upgrade right away... but they did find a bug in version 111 that you are obligated to fix.

      Release strategy for thus situation is well defined and easy using semantic versioning. But how would it look under this always-increment-by-one approach? Just call it 113 because it came after 112 and explain in release notes that this is actually 111 with a bug fix and does not include new feature from 112? That does not sound simpler over long term than semantic versioning.

      Or do you have to adopt a

    6. Re: Integer by kthreadd · · Score: 1

      So you released version 111 and some people downloaded it and purchased a support contract. Then you add a major new features in version 112 that due to their awesomeness have to break backward compatibility with version 111, and for that reason the aforementioned customer is not going to upgrade right away... but they did find a bug in version 111 that you are obligated to fix.

      Myth number one, new features does not need breaking changes. Take a look at the Linux kernel. Probably the most modern kernel of all time, yet its developers take pride in that they don't break compatibility. New features does not have to come with the price of breaking changes.

    7. Re:Integer by fisted · · Score: 1

      actually has meaning, a larger number is newer.

      How innovative. Care to point me at some version numbering schemes that do not have this property?

    8. Re: Integer by fisted · · Score: 1

      new features does not need breaking changes

      But sometimes/often they do, and in the situation described by AC this case is assumed. What exactly is your point?

    9. Re: Integer by kthreadd · · Score: 1

      That there are actual shipping software that follows this principle and still manages to improve and add new features and capabilities at a high rate. Sometimes people make stupid decisions; no one will ever be able to type ls * without an error in /usr/lib/systemd/system because someone though it was a good idea to put a file there called -.slice there. Now it's part of the API so it has to stay that way. Inconventient, yes. But will it prevent new features and improvements? No.

    10. Re: Integer by Anonymous Coward · · Score: 0

      Sometimes people make stupid decisions; no one will ever be able to type ls * without an error in /usr/lib/systemd/system because someone though it was a good idea to put a file there called -.slice there.

      The guy who did that ought to have something sliced off of him.

    11. Re: Integer by Anonymous Coward · · Score: 0

      Sometimes people make stupid decisions; no one will ever be able to type ls * without an error in /usr/lib/systemd/system because someone though it was a good idea to put a file there called -.slice there. Now it's part of the API so it has to stay that way.

      The solution is obvious. Add an option -.slice to ls that does nothing...

      There, I fixed it. :-)

    12. Re:Integer by Gr8Apes · · Score: 1
      Windows 10.

      There are 10 kinds of people in the world...

      --
      The cesspool just got a check and balance.
    13. Re:Integer by fisted · · Score: 1

      The "10" in windows 10 is not the version number, it's the marketing name. Their version number is something different which may or may not begin with 10, but at least doesn't bounce up and down and outside of the domain randomly

    14. Re: Integer by adhdengineer · · Score: 1

      its developers take pride in that they don't break compatibility

      The fuck you say?

    15. Re:Integer by Gr8Apes · · Score: 1
      --
      The cesspool just got a check and balance.
    16. Re:Integer by fisted · · Score: 1

      It's not like I care about what windows does or does not ...

  5. Use Gödel numbering by vikingpower · · Score: 4, Funny

    Use one series of primes for major.
    Use a second series of primes for minor.
    Use a third series of primes for patches/micro/bug fixing.

    The three sets of primes should be disjoint.

    For each release, multiply major with minor with micro. That is your unique version number.

    You may add some sugar by adding powers of these primes for various locales, database compatibility etc. etc.

    --
    Religous speak to God. Insane are spoken to by God. When all shut up, one can finally hear Shostakovich in peace
    1. Re:Use Gödel numbering by Rob+Riggs · · Score: 1

      I like it.

      P.S. My UID is also semiprime.

      --
      the growth in cynicism and rebellion has not been without cause
    2. Re:Use Gödel numbering by Anonymous Coward · · Score: 1

      And your post number (#50614169) is a triprime.

      50614169 = 113 x 307 x 1459

  6. I'm running Chrome 45 and Firefox 41 by wstrucke · · Score: 1

    It seems many developers stopped caring about versioning several years ago. I've been torn on whether it was just marketing finally overtaking common sense or too many inexperienced but successful developers showing up and making some poor choices.

    1. Re:I'm running Chrome 45 and Firefox 41 by bluefoxlucid · · Score: 2

      People don't consider a lot when they do things. There's an old convention of 0.x being "incomplete", such that we have some rather mature products in pre-1.0 stable releases without all of the features and finalized interfaces which constitute a completed product. There's a newer convention of Major.Minor.Revision, based on the old Major.Minor.Revision, by which "revision" means "nothing new, fixed some defect", while "Minor" means "Something new, works exactly as before if you're not using the old thing", and "Major" means "things that you did in the last major may produce different results in this version; that includes the removal of features we previously deprecated."

      Upon these conventions, we've built support conventions. The prior major release, at least, usually gets continued bugfixes, and occasionally feature back-ports. Bugfixes are for people who can't move forward just yet--they need to fix their processes and workflows to use the new version--and need that support, especially for security fixes; while feature back-ports let the client keep up with new developments, accessing some features in the new major which don't depend on new behavior of old features. We usually handle this by giving a shorter and more casual minor-update duration (you get new features when we care to backport them, by user demand, only for 12 months) than we do for bug fixes (the final 6.x release gets bugfixes for an additional 12 months).

      Then you have the deviants.

      Apple, upon releasing a new Quicktime major, will preemptively stop supporting the last major. When Quicktime 7.0 came out, it fixed major security vulnerabilities in Quicktime 6; Apple provided no updates to Quicktime 6, so those vulnerabilities remained unless you upgraded to a whole new major Quicktime version with new APIs, new features, changed behavior, and some features removed.

      Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality. If it worked on release day, it will work in exactly the same way at EOL. Bugfixes may enable previously-broken functionality; they try not to alter functionality such that previous work-arounds start behaving differently, unless the application is so crippled as to be unuseful. This is okay because the scope of a distribution release implies a major change; Ubuntu has a point release system for LTS to signify minor feature updates.

      RedHat takes a different, more Apple-like approach: Their point-releases are just inline updates, like Ubuntu LTS; but they're *major* updates, removing old features and subsystems, integrating completely new systems, changing behaviors, and generally breaking all kinds of shit. There's no support for the previous point release, at all; if you call RHEL support, they tell you to update or else they have nothing for you. The difference between RHEL 6.10 and RHEL 7 is functionally similar to the difference between RHEL 6.9 and RHEL 6.10, or RHEL 7 and RHEL 7.1.

      Bring that out to Chrome, Firefox, and friends, with an iterated version for every release. Release numbers now have no meaning except "new". They are effectively date stamps, without the benefit of Debian-style releases in which every release is implied a drastic upheaval rather than a possible incremental feature increase. Nothing in the versioning indicates if APIs have changed or been removed, so broad assessment of compatibility risks (e.g. with old protocols, old incorrect rendering behavior, or old extensions) are not as readily assessed.

      It goes all the way out to the Linux kernel, which is just nonsense. WhenLinusFeelLikeIt.Otherwise.Bugfix is the Linux kernel's pattern; it's essentially Major.Bugfix with a period in the Major part.

    2. Re:I'm running Chrome 45 and Firefox 41 by petermgreen · · Score: 1

      Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality.

      Well that's the ideal, whether reality lives up to it is another matter.

      --
      note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
    3. Re:I'm running Chrome 45 and Firefox 41 by bluefoxlucid · · Score: 1

      The major deviants are mostly Firefox and Chrome, since sometimes you need to pull Firefox up a few versions to get a security fix; they often backport the fixes.

    4. Re:I'm running Chrome 45 and Firefox 41 by kthreadd · · Score: 1

      Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality. If it worked on release day, it will work in exactly the same way at EOL. Bugfixes may enable previously-broken functionality; they try not to alter functionality such that previous work-arounds start behaving differently, unless the application is so crippled as to be unuseful. This is okay because the scope of a distribution release implies a major change; Ubuntu has a point release system for LTS to signify minor feature updates.

      Actually, Ubuntu just bumped python3 from 3.4.0 to 3.4.3 in Trusty LTS yesterday.

    5. Re:I'm running Chrome 45 and Firefox 41 by kthreadd · · Score: 1

      RedHat takes a different, more Apple-like approach: Their point-releases are just inline updates, like Ubuntu LTS; but they're *major* updates, removing old features and subsystems, integrating completely new systems, changing behaviors, and generally breaking all kinds of shit. There's no support for the previous point release, at all; if you call RHEL support, they tell you to update or else they have nothing for you. The difference between RHEL 6.10 and RHEL 7 is functionally similar to the difference between RHEL 6.9 and RHEL 6.10, or RHEL 7 and RHEL 7.1.

      Here you're actually not completely correct. Red Hat does provide Extended Update Support (EUS) as an option to customers that want to standardize on a minor RHEL release for some time, usually two years.

    6. Re:I'm running Chrome 45 and Firefox 41 by bluefoxlucid · · Score: 1

      3.4.3 looks like a pure bugfix and improvement release, not a major feature release. They did change some casing in the http.cookies module, which is concerning.

    7. Re:I'm running Chrome 45 and Firefox 41 by Anonymous Coward · · Score: 0

      Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality. If it worked on release day, it will work in exactly the same way at EOL. Bugfixes may enable previously-broken functionality; they try not to alter functionality such that previous work-arounds start behaving differently, unless the application is so crippled as to be unuseful. This is okay because the scope of a distribution release implies a major change; Ubuntu has a point release system for LTS to signify minor feature updates.

      Actually, Ubuntu just bumped python3 from 3.4.0 to 3.4.3 in Trusty LTS yesterday.

      I've had it the other way around. Kernel bugs in up to date Ubuntu LTS systems which have been fixed by the upstream kernel developers and that takes months to trickle into the 3.2 or 3.13 release that Ubuntu uses because it takes time and effort to backport individual fixes. Why do all this extra error-prone work when the kernel developers actually do a heck of a good job with stability between versions?

  7. How about time-based versioning? by Crowd+Computing · · Score: 1

    It seems that many projects now opt for a regular progression of numbers with or without any major new features. Even Ubuntu releases, formerly the occasion for the introduction of some initially broken new feature, have become boring affairs. Even the well-numbered Linux kernel appears to break the major.minor paradigm. Besides the addition of more and more drivers, was there anything particularly disruptive in the move from Linux 3.19 to Linux 4.0? Beyond the third digit of the bug fix releases, Linux version numbering fall more into the sentimental rather than semantic versioning camp.

    1. Re:How about time-based versioning? by tomknight · · Score: 1

      OpenBSD dees time-based versioning. Every six months, the version number increments by 0.1 - there's a new release every May 1st and Nov 1st. The change in major version number means nothing other than it's gone from x.9 to (x+1).0

      Simple.

      --
      Oh arse
  8. Key rules. by jellomizer · · Score: 4, Interesting

    1. Stay Consistent!!! Don't drop your versioning and swap to another one. Like Microsoft, Firefox, to a lesser extent Apple.
    2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.
    3. Insure development milestones are consistent with the version bumps. So Version 2 to version 3, should be just as large as from version 3 to 4.

    The key importance to versioning is so we know what is the newest/newer version and if you have a major version you will expect some compatiblity changes.

    --
    If something is so important that you feel the need to post it on the internet... It probably isn't that important.
    1. Re:Key rules. by Anonymous Coward · · Score: 0

      2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

      What happens when it goes beyond Z? Does it go onto [? Does it run onto the cyrillic characters or kana?

      Or will we finally have the Ultimate Linux that can never be bested?

    2. Re:Key rules. by halivar · · Score: 2

      What happens when it goes beyond Z? Does it go onto [?

      0. I'm on EBCDIC, you insensitive clod!

    3. Re:Key rules. by Anonymous Coward · · Score: 0

      2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

      Re #2, what do you think about Debian's codenames?

    4. Re:Key rules. by Anonymous Coward · · Score: 1

      I've grown accustomed to a variation on Microsoft's four-point versioning system. It's officially Major.Minor.Build.Revision, but I've found reversing the meaning of the last two sections to be more helpful. Major.Minor.Revision.Build just works better for me.

      Major versions are breaking revisions. The file format is incompatible. The database architecture changed. The network protocol is completely different. That sort of thing. You increment this when you have a major architecture overhaul or when you make a large, breaking change to something fundamental to the program. Remember, if it's not breaking compatibility with the existing assets and output of the current release of the program, it's (probably) not a major revision!

      Minor versions are compatible within a major version, but progressive minor versions contain more, better, upgraded, or different features. You increment this when you make a group of feature additions that don't break compatibility with the previous version.

      Release versions are bugfixes, but are a production release (or at least had an RC sent for testing). You increment this when you send a build to QA.

      Build versions are daily or other builds generated for developer use. You increment this (or your IDE does it for you) when you compile.

      All "higher" version segment changes reset "lower" version segments to zero.

    5. Re:Key rules. by sarguin · · Score: 1

      2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

      Names like One, Two, Three, Four, Five, ... sounds good to me ;)

    6. Re:Key rules. by Anonymous Coward · · Score: 0

      Microsoft fails at #2, unless you can find a locale in which XP < Vista and 98 < 2000 < 7.

    7. Re:Key rules. by plover · · Score: 1

      Internally, their version numbers are still consistent, but the fact that their product names include numbers (sometimes related to the date, sometimes related to the internal version number, and sometimes related to the previous release) makes for a confusing mess. Windows 3.5, Windows 95, Windows 98, and Windows ME were all built on top of DOS and were not built on the NT kernel. They were all just windowing systems, and none of them deserved to be called an operating system. Underneath, they ran MS-DOS, which was a more or less compatible version of PC-DOS. They were all 16 bit operating systems.

      Windows NT 3.5.1 was Microsoft's first actual multitasking OS, followed by NT 4.0, which was followed by Windows 2000 (NT 5.0). XP was Windows NT 5.1, and was when the Windows NT kernel finally went mainstream to the home users (and introduced most to a 32 bit OS.) Vista was NT 6.0. Windows 7 was NT 6.1. Windows 8 is NT 6.2, and Windows 8.1 was NT 6.3. Starting with Windows 10, they actually renumbered the internals so it's reporting itself as NT 10.0.

      On top of all of those, you can try to overlay their server versions. At least they're all named according to the year of their intended release.

      As marketing is clearly in charge of OS naming at Microsoft, don't look for consistency in future versions. The only thing you can count on is the unpredictability of their naming schemes. Their next release is equally likely to be called Windows 7331, Windows Forever, Windows 64, Windows 11, or Windows 2018. Internally, it'll probably still just report itself as NT 10.1.

      --
      John
    8. Re:Key rules. by khellendros1984 · · Score: 1

      Windows releases always have internal version numbers like these. 5.1.2600 < 6.0.6000, and 4.10.1998 < 5.00.2195 < 6.1.7601 (using your example releases)

      --
      It is pitch black. You are likely to be eaten by a grue.
    9. Re:Key rules. by glwtta · · Score: 1

      2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

      I use Medoc Grads Crus in increasing order of subjective quality - pretty much as obvious as it gets.

      --
      sic transit gloria mundi
    10. Re:Key rules. by Anonymous Coward · · Score: 0

      The complaint was that it's hard to know which version is greater, and the criticism still stands. If I buy a set of measuring cups and they'll labeled with names like XP and Vista instead of being labeled with the quantity they contain, then they'd be a pain to use. If you point out that the quantity they contain is laser-etched underneath and visible under UV light with a magnifying lens, then you'd be technically correct, but the set of cups would still be a pain to use.

    11. Re:Key rules. by Anonymous Coward · · Score: 0

      The notion that Windows 9x series was simply a windowing system built on top of MS-DOS is a widely-believed myth. Windows 95 was a true 32-bit OS with backwards compatibility for legacy 16-bit drivers and software, and introduced preemptive multi-tasking. It was only the 3.1 and earlier versions (I'm guessing that's what you meant when you said Windows 3.5 earlier) that provided coorperative (non-preemptive) multi-tasking only.

      Summary from link follows. You can read more in detail if you want, as it's fairly interesting:

        MS-DOS served two purposes in the Windows 9x series.

              It served as the boot loader.
              It acted as the 16-bit legacy device driver layer.

    12. Re:Key rules. by toddestan · · Score: 1

      Debian uses a version number, but they nickname each release with a character from Toy Story. Kind of like how Apple uses 10.x to version OSX, but also nicknames each release with a type of feline.

  9. KISS by Moof123 · · Score: 3, Informative

    Please keep this crap simple. It is maddening for secondary tools (ones I don't use daily) to get all cutesy with the Silky Lizard release, which is also known at the 2015 release, but has an about me of 3.2.0.1 hotfix 430. Searching under all three is necessary since everyone adopts a different preferred method to refer to the dang thing.

    On the whole I greatly prefer versions that are year.month based so it is very easy to recognize how long in the tooth something is. XYZ 2015.01 tells me it is the January 2015 release.

    1. Re:KISS by Anonymous Coward · · Score: 0

      I like something about the date in there too. We use YYYY.DOY (day of year), like 2015.271. ...and all of our software updates are major. :) I've seen plenty of updates that went from 2.4.5 to 2.4.6 and broke bunches of things, so I don't rely on that.

    2. Re:KISS by Anonymous Coward · · Score: 0

      This! Version madness sucks.

      Semantic versions should essentially mean that "4.2.x" means that the interface that it presents is "4.2", and that anything interacting will assume "4.2". A "4.2" client and server should speak the same protocol (over network, disk formats, or library compatibility). It should mean that implementation "4.2.5" and "4.2.7" import the same "4.2" header files, unchanged, at least for the things which are already defined in earlier versions.

      If the interface and the implementation are separated from each other, then a "4.1.x" and a "4.2.x" might be (from the client point of view) the same implementation supporting two different interfaces. A client using a "4" version should expect a small amount of reworking as opposed to a "3", because the interfaces are not identical.

    3. Re:KISS by Anonymous Coward · · Score: 0

      The main idea is that "2.4" is a contract that the software, and the things that it uses obey. If there is breakage from "2.4.5" to "2.4.6", what that should mean is that either the client relied on undocumented behavior, or that the server broke the contract.

    4. Re:KISS by Junta · · Score: 2

      On the whole I greatly prefer versions that are year.month based so it is very easy to recognize how long in the tooth something is

      Of course there are situations where that really does not matter and fretting about how old a piece of code is pointless worrying. For example, the code to decrypt a DVD hasn't change in an eternity, but there's no good reason to expect a change to be needed on that front. A library dedicated to that purpose might not change because there's no point, not because it's abandoned.

      --
      XML is like violence. If it doesn't solve the problem, use more.
    5. Re:KISS by Anonymous Coward · · Score: 0

      On the whole I greatly prefer versions that are year.month based so it is very easy to recognize how long in the tooth something is.

      That versioning scheme is based on the assumption that:

      * development is linear (no concurrent versions, no maintenance releases, nothing. Only the trunk)

      * no patch is added to a previous version

      * the interfaces don't change

      * backward compatibility doesn't matter

      etc etc etc

      In short, it is awfully inadequate for the purpose of versioning software.

    6. Re:KISS by hackertourist · · Score: 1

      The big drawback of year.month over major.minor is that year.month gives no indication of the magnitude of changes. Can I install 2015.09 and be certain all of the features I use daily are still there? What's the difference in file format between 2014.06 and this new version?
      Now I realize major.minor is not an ironclad guarantee either, but it gets me closer than year.month.

  10. Versions have been marketing bullshit for decades by Anonymous Coward · · Score: 0

    Windows, OSX, Android, Adobe Photoshop, several Linux distributions... And that's just off the top of my head.

    Once you start ascribing mythical importance to version updates and, worse, selling them, they cease to be useful as a development milestone.

  11. So the final version is... by __aaclcg7560 · · Score: 1

    Microsoft Windows 42

    1. Re:So the final version is... by Zero__Kelvin · · Score: 1

      You apparently haven't been paying attention. Windows 10 is the final version. I'm not kidding.

      --
      Guns don't kill people; Physics kills people! - John Lithgow as Dick Solomon on Third Rock From The Sun
  12. I like year-based versioning by Cro+Magnon · · Score: 1

    With year-based, I know how old the software is and I know which version is newer. Maybe add something extra to indicate if it's a major change, or if it gets long term support.

    --
    Slow down, cowboy! It has been 4 hours since you last posted. You must wait another few hours.
  13. if there is limited new functionlaity. by leuk_he · · Score: 1

    If your new version has limited new visible functionality let users vote on a name of the most current release. Can you name the new feartures of android Marshmellow? If nom, you do know the name!

  14. Re:Versions have been marketing bullshit for decad by leonbev · · Score: 1

    Microsoft's version numbering "system" has always been the most confusing to me. They went from actual version numbers (Windows 3, 3.1), to the approximate year they were released (Windows 95, 98, 2000), to weird brand names (XP, Vista), to made up version numbers that aren't actually the real version number reported by the OS * (Windows 7, 8, 8.1), and finally back to an actual version number that matches what the OS says it is (Windows 10).

    Bloody hell, man!

    * Windows 7 reports as version 6.3 when you use the "ver" command.

  15. Versioning and Releases Are Old School by friedmud · · Score: 1

    We run with a full continuous integration cycle... with continuous release. Our software version is whatever the Git hash is. This is for a large computational science library that's in use by hundreds of researchers around the globe.

    You can read about some of our software development methodology here:

    http://openresearchsoftware.me...

    Although, that's a bit dated now and a newer article has already been accepted by the Journal Of Open Research Software and should be out "real soon now". You can see an early draft of the new paper here:

    http://figshare.com/articles/C...

    1. Re:Versioning and Releases Are Old School by fisted · · Score: 2

      with continuous release.

      Ain't no rockstar brogrammer got time for releng, right?

      Our software version is whatever the Git hash is.

      You're saying this as if that was something to be proud of, rather than a demonstration of laziness...

      This is for a large computational science library that's in use by hundreds of researchers around the globe.

      Thanks for the warning.

    2. Re:Versioning and Releases Are Old School by Anonymous Coward · · Score: 1

      That sounds like the worst versioning scheme I've ever heard of, and requires gobs of research just to determine the order of versions. I assume that it includes the presumption that the tip of the repository is always bug free. Assuming that you have different development branches and a strict testing policy before copying a branch up to mainline, this could be feasible. But in this case, you'd expect that you could have your CI tool also include a strictly monotonically increasing integer to help your users differentiate between two versions. (Seriously, show a little respect! Just because they're researchers doesn't mean they want to waste their time! They have better things to do, which is why they're using your library instead of writing their own from scratch.) You could even have it slap the commit hash to the end of the version for those users who are interested in the commit version. So the twenty-seventh release might look like "27-4ce653b488b3f1a3f929caa136f63f7846303967" -- now it's user-friendly for everyone! :)

      To be a little anal about it, you seemed to imply that having hundreds of users was evidence that your versioning scheme was good. Hundreds of users is peanuts for pretty much anything. I didn't review your product, so I could see that the particular niche it fills only has a few hundred researchers. But that doesn't mean it's good, it might just mean it's the only thing out there.

    3. Re:Versioning and Releases Are Old School by friedmud · · Score: 1

      Quick to criticize and call names I see.

      You obviously didn't even bother a cursory glance at the two papers I pointed to. We spend a LOT of time doing release engineering... we just build it all into an automated system so that we can do multiple "releases" per day.

      We actually test every code change against a large set of our downstream users codes... automatically. Yes, every change... and yes, against _user's_ applications that are built using our library (even users located on the other side of the world). Our continuous integration isn't just internal... it's over all our user's applications. Every time the code changes pass against the dozens of downstream applications the system automatically rolls out a "release" (by merging to our "stable" branch). Our users can use the stable branch (and update daily if they like) without fear of it breaking their codes.

      We are proud of using a Git hash for our "version". We do it this way because we want the entire community to move forward together... all the time. It's a major issue in computational science when people use old versions of libraries forever. Again, go read the papers.

    4. Re:Versioning and Releases Are Old School by friedmud · · Score: 1

      Look at my reply to the guy above you for a little more detail.

      We _do_ actually test every every code change _before_ it enters a "devel" branch (everything flows through tested pull requests). Part of that testing is actually testing against _downstream_ applications (user's applications). Once it's deemed fit to go into "devel" the PR is merged and a new set of automated testing is kicked off... with more extensive testing against all downstream applications. If that passes then a "release" is automatically done by merging to our "stable" branch (which is actually master).

      The entire system (other than pressing "Merge" on the PR) is completely automated... allowing us to roll out several releases per day that are guaranteed to work with all of our user's applications. This gives them the freedom to use the very most up to date version of the library (the master branch) without fear.

      As for the version "number" it actually doesn't matter... no one talks about "I'm on version 4ce653b488b3f1a3f929caa136f63f7846303967"... the only question is: "Did you update today?"...

      BTW: If we make an incompatible API change (which is rare). _WE_ actually put in PR's to all of our downstream user's applications (currently numbering in the hundreds) to fix their applications.

      The purpose of all of this (which is talked about in the papers) is to keep the entire community running on the newest code... all the time. It trades support burden (of old versions) for a burden of always passing extremely rigorous tests. We've found it to be a really positive thing and our userbase is continuing to grow because of it.

      About that userbase. This is massively-parallel, scientific and engineering software (the kind that runs on the largest supercomputers in the world). Several hundred users is actually pretty great ;-)

  16. Do it with Panache? by FatdogHaiku · · Score: 2

    OK, but I'm still on Panache 0.92.4!
    Do I need to update to 1.1.x?
    Also, it would seem that certain young women on the internet have Panache x.x.x.

    --
    You have the right to remain sentient. If you give up the right to remain sentient, you will be elected to public office
    1. Re:Do it with Panache? by Virtucon · · Score: 1

      Panache got forked. It's now Flamboyance 3.1.4

      --
      Harrison's Postulate - "For every action there is an equal and opposite criticism"
    2. Re:Do it with Panache? by FatdogHaiku · · Score: 1

      Panache got forked. It's now Flamboyance 3.1.4

      I hope the new developers are flexible...

      --
      You have the right to remain sentient. If you give up the right to remain sentient, you will be elected to public office
  17. Re:Versions have been marketing bullshit for decad by dejitaru · · Score: 1

    I personally preferred the version numbers or years. When they changed it Me, XP, Vista, and then 7, 8, it annoyed the hell out of me. At least with the version numbers 3.11 or years Windows 98 it was easier to follow. I am glad they finally made Windows 10 kernel ver 10. Now Office is kind of a different story because for one instance they had XP but then switched back to years.

  18. TeX versioning by Anonymous Coward · · Score: 0

    It's great as a joke or starting out, but eventually you end up with a really long number, and comparing the two numbers becomes something that a string length function is required for. Only slightly more readable than using 1,11,111,1111,11111,...,1111111111111111111111... If all you're doing is counting the number of digits, you might as well use something more than base 1 for your counting. Then you're just counting of course.

  19. Date + SVN revision by Anonymous Coward · · Score: 0

    Hello,

    First you have to use something AUTOMATIC. No manual changes else it is bound to be forgotten.
    Second, use something that makes it easy to see how old somethign is
    Third use something that allows you to go back to a given version.

    We use the date AND svn revison number as the version. It is automaticaly included in the build so there is no manual operations to change the version.

    Since we have done that, we have never gone back!

    cyrille

  20. i.e != e.g. by RghtHndSd · · Score: 0

    i.e. means equivalent. e.g. means an example.

  21. Re:Versions have been marketing bullshit for decad by Megane · · Score: 1

    I think Firefox and Chrome, which are mostly on a quarterly release schedule, should have year-dot-quarter version numbers. But I don't have anything against the Gecko version numbering (which is what current FF version numbers correspond to). But no matter what you do, someone will have borked up browser version checking that will break when you change your version numbering to something that seems more sensible.

    As for the Windows version naming, the funny part was how they were ready to call it Windows 9 until they realized just how much stuff (including Java, for fuck's sake!) did if (substr(version, 0, 9) == "Windows 9") to lazily check for Windows 95 and Windows 98 in a single comparison.

    --
    #naabhaprzrag, #sverubfr-000, #agi-fcbafberq, negvpyr[pynff*=' negvpyr-ary-'] { qvfcynl: abar !vzcbegnag; }
  22. Cute when it's small, annoying later by enjar · · Score: 1

    Just like kids and puppies, it's cute when they are small, then develops into an annoyance you put up with for decades.

    It's also painfully annoying when you have a version of something (e.g. 7.0), then another version contained in the driver file (340.xx), and still another version reported in a OS-unique manner (e.g. A.B.C.D on Windows). Yes, I'm looking at you, nVidia.

    Similar case for themed server names versus role-based, owner-based, rack-location-based, physical-location-based -- anything that allows a rational human being to determine something useful about the server in question versus some confused mnemonic about how Gandalf is the mail server, Frodo is the DNS and Bilbo is the VPN gateway.

  23. Shall I come in again? by hackertourist · · Score: 1

    I count four, no, five version numbering schemes:
    - romantic
    - rebellious
    - traditional (major.minor.bugfix)
    - marketing (year.month)
    - irrational (a.k.a. Mine's Bigger: Firefox, Chrome)

  24. Eclipse are the worst by Anonymous Coward · · Score: 0

    I can never remember which version of Eclipse is newer. The names don't tell me anything, which is particularly annoyince since releases go only by their names and not their version numbers.

    Quick, without looking up the answer, which is newer for example - Luna or Kepler? Heck, do you even know what version numbers these are? If I look up eclipse in a Linux repository I'll only get version numbers, so I won't know how out of date it is compared to the latest (as repos are almost always out of date).

    1. Re:Eclipse are the worst by Anonymous Coward · · Score: 0

      Luna is newer than Kepler, because L comes after K in the alphabet. Previous Eclipse releases were Galileo, Helios, Indigo and Juno. Current Release is Mars. I'll give you the version number issue, although eclipse.org lists them all prominently down to 4.2 (3 years old)