Consider two strategies for implementing an upgrade of something with multiple versions (e.g. upgrading an installation of some software).

  1. From any version, upgrade directly to the latest version.

  2. Progressively upgrade through intermediate versions, until you get to the latest.

Is there a generally accepted name for option 2?


As an example, you are on version 7.0, and you want to get to the latest version, 9.1. The upgrade works internally, using the following chained steps.

any -> 8.0
8.0 -> 9.0
9.0 -> current (9.1)
  • 2
    It's called "Incremental Software Upgrading." Google even holds a patent. – Robert Harvey May 2 '19 at 16:08
  • @RobertHarvey Thanks. You might as well make this a proper answer. – Clay Bridges May 2 '19 at 17:44
  • @RobertHarvey I thought this was where we went for educated and informed opinions on this kind of thing (versus e.g. stackoverflow). If not, where? – Clay Bridges May 3 '19 at 15:47
  • You didn't get at least three educated and informed opinions already? Read On the Troubles of Naming and Terminology. – Robert Harvey May 3 '19 at 16:01
  • 1
    Engineering is a scientific discipline, and science requires/values use of precise terminology. Asking if there is a term is not asking for an opinion. The fact that there is no generally accepted term does not IMHO change validity of question. I'd therefore like to reopen this question, since I'm personally confronted with the same terminology issue, and I hope that someone could still provide a term with a reference to an ISO/IEEE/NIST/EN standard (or other authoritative source) which I was not aware of. Keeping this question closed would definitively prevent this such an outcome. – Christophe May 3 '19 at 18:36

In short

The strategy 1 is a direct upgrade.

The strategy 2 is a sequential upgrade (example by RedHat) or successive release upgrade (example MongoDB or MySql, at least in former versions). But be careful, since there is no authoritative definitions or commonly accepted terms.

Terms might be misleading

The terminology related to upgrade is tricky and often misleading.

Take the example of Robert's incremental upgrade :

  • For any agile developer, solutions are delivered in increments. So it could be tempting to see successive versions as the natural increments.
  • However in the Google patent referred to by Robert, and more precisely in the section about prior art, incremental is used to refer to patches: it is opposed to full replacement of executables of one version by the executables of the another one.
  • So incremental upgrade might refer to very different things and have different meaning for different people. And it does not address your question, since the granularity of the increment is not defined: is it patch by patch or version by version ?

Take the example of Dr.Brown's cumulative upgrade:

  • Strategy 1 is clearly non-cumulative
  • Strategy 2 can be cumulative if you add up patches until you reach the desired version. However, you can also replace each version by the next, so it's a succession of substitution and nothing accumulates.
  • The problem with cumulative is that it has a technical connotation of accumulating small things. Again, it can mean different things to different people.

Restrict yourself to commonly agreed terms

The following terms are widely accepted and used:

  • The upgrade path describes the way to upgrade from a source version to a target version
  • A direct upgrade is when you can go directly from source to target, without using intermediate versions.
  • Intermediate versions are versions that are on the path

Any other more precise terms are subject to caution. Even in your own example, it is not clear if you can skip minor versions (between 8.0 and 9.0) and if the successive versions apply only to the same versioning level.

This is why the biggest vendors use extensively the upgrade path, make full sentences to describe how this path looks like in general, and present the possible path in nice matrices (which also allow to cope with the many exceptions due to change of strategy in older versions).


Option 1 is often called "cumulative upgrading", which makes option 2 just "non-cumulative". And yes, Robert Harvey is right, too, #2 is also called "incremental upgrading". Note the terms "incremental" or "cumulative" are not restricted to software upgrades, they apply to any kind of changes to documents or data.

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