On to legal documents, and documents generally, this is whilst the statement or even even affliction is added, flushed, or changed. On to computers, versioning is a about universal practice in the development of software, in which a version of the software package package changes by owning every modification in the software. Revision control is very useful for any price that utilizes versions.

Software engineering
This is utilized within practical terms per consumer, or even client, by being breaa to compare their copy of the software package against a second copy, like the fresh version freed per creator. For even even even the computer softwcome engineer team or company, versioning is typically utilized within the file-by-file basis, in which single arethe or sectors of the software code are equated & contrasted by owning newly or older revisions, typically in a collaborative Concurrent Versions System. No absolute & definite package version schema; it could typically deviate from either software package genre to genre, & is very unremarkably according to a coder's portable preference.

Software versioning schemes
inside computer softwcome, version counts are a enumeration scheme utilized to allow a computer software development organization to better track issues & fixes within the field people. It likewise allows a client service arm of the organization to understand which issues use been found and/or fixed where releases of the software package.

Numerical
the usual package versioning scheme occurs as scheme where different major releases of the computer software from each one receive a unique numerical identifier. This is occasionally expressed when terzetto figures, separated by periods, like version Ii.Four.Xiii. A single super usually followed structure for these figures is:

In most cases, the first released version of a software product has version 1.0. Numbers below 1 mean alpha or beta versions, i.e., versions for testing purposes or internal use, or versions that aren't stable enough for general or practical deployment.

In principle, in subsequent releases, the major number is increased when there are significant jumps in functionality, the minor number is incremented when only minor features or significant fixes have been added, and the revision number is incremented when minor bugs are fixed. A typical product might use the numbers 0.9 (for beta software), 0.9.1, 0.9.2, 0.9.3, 1.0, 1.0.1, 1.0.2, 1.1, 1.1.1, 2.0, 2.0.1, 2.0.2, 2.1, 2.1.1, 2.1.2, 2.2, etc. Developers may at times jump (for example) from version 5.0 to 5.5 to indicate that significant features have been added, but not enough to warrant incrementing the major version number.

There is sometimes a fourth, unpublished number which denotes the software build. This scheme is used by Microsoft. Some companies also include the build date. Version numbers may also include letters and other characters, such as Lotus 1-Two-Three Release 1a.

Some software packages use more complex versions of this scheme, such as Linux, which uses odd minor version numbers to denote development releases and even minor version numbers to denote stable releases. For example, Linux 2.5 was a development family of the second major design of the Linux kernel, and Linux 2.6 was the stable release family that Linux 2.5 matured into. After the minor version number in the Linux kernel is the release number, in ascending order; for example, Linux 2.4.0 -> Linux 2.4.22. Even further, a trivial version number was added to 2.6.8, making 2.6.8.1 which denoted a very minor change. This fourth number has been made standard since 2.6.11.1.

A different approach is to use the major and minor numbers, along with an alphanumeric string denoting the release type. A release train using this approach might look like 0.5, 0.6, 0.7, 0.8, 0.9 1.0b1, 1.0b2 (with some fixes), 1.0b3 (with more fixes)
1.0rc1 (which, if it's stable enough) == 1.0. If 1.0rc1 turns out to have bugs which must be fixed, it turns into 1.0rc2, and so on. The important characteristic of this approach is that the first version of a given level (beta, RC, production) must be identical to the last version of the release below it: you cannot make any changes at all from the last beta to the first RC, or from the last RC to production. If you do, you must roll out another release at that lower level.

The purpose of this, of course, is to permit users (or potential adopters) to properly evaluate how much real-world testing a given build of code has actually undergone. If changes are made between, say, 1.3rc4 and the production release of 1.3, then that release -- which asserts that it has had a production-grade level of testing in the real world, in fact contains changes which have not necessarily been tested in the real world at all.

This approach commonly permits the third level of numbering ("change"), but does not apply this level of rigor to changes in that number: 1.3.1, 1.3.2, 1.3.3, 1.3.4... 1.4b1, etc.

Finally, there's a common habit in the commercial software industry (usually, though not always, spurned by non-commercial programmers) to make major jumps in numeric major or minor version numbers for reasons which do not seem (to many members of the program's audience) to merit them: "marketing" version numbers. This can be seen in several Microsoft products, as well as Sun Solaris and Java Virtual Machine numbering, SCO Unix version numbers, and Corel Word Perfect, as well as the filePro DB/RAD programming package, which went from 2.0 to 3.0 to 4.0 to 4.1 to 4.5 to 4.8 to 5.0, and is about to go to 5.6, with no intervening release. A slightly different version can be seen in AOL's PC client software, which tends to come out *only* as .0 releases (5.0, 6.0, 7.0, etc...) with never a .1 release .

Date
The WINE project uses a date versioning scheme, which uses the year followed by the month followed by the day of the release; for example, "WINE 20040505". This is intended to lead into a decimal versioning scheme when WINE 1.0 is released, but assists in keeping track of the large number of development WINE releases until then.

Other schemes
Some software producers use different schemes to denote releases of their software. For example, the Microsoft Windows operating system was first labelled with standard numerical version numbers (Windows 1.0 through Windows 3.11), then by years (Windows 95, Windows 98, Windows 2000), and also by alphanumeric codes (Windows Me, Windows XP). The Debian project uses a major/minor versioning scheme for releases of its operating system, but uses code names from the movie Toy Story during development to refer to stable, unstable and testing releases.

Other examples, identifying versions by year (Adobe Illustrator 88, WordPerfect Office 2003), by alphanumeric codes (Macromedia Flash MX, Adobe Photoshop CS2), and by codename (e.g. Mac OS 10 Tiger).

Pre-release versions
Programs that are in a very early stage of development are often called "alpha" software, after the first letter in the Greek alphabet. After they mature but are not yet ready for release, they may be called "beta" software, after the second letter in the Greek alphabet. Alpha- and beta-version software is often given numerical versions less than 1 (such as 0.9), to suggest their approach toward a public "1.0" release. Software packages which are soon to be released as a particular version may carry that version tag followed by "rc-#", indicating the number of the release candidate. When the version is actually released, the "rc" tag disappears.

Unusual versioning schemes
TeX has an idiosyncratic version numbering system. Since version 3, updates have been indicated by adding an extra digit at the end, so that the version number asymptotically approaches π. The current version is 3.141592. This is a reflection of the fact that TeX is now very stable, and only minor updates are anticipated. TeX developer Donald Knuth has stated that the "absolutely final change (to be made after my death)" will be to change the version number to π, at which point all remaining bugs will become permanent features.

The developers of MAME do not intend to release a version 1.0 of their emulator program. The argument is that it will never be truly "finished" because there will always be more arcade games.

Variations
In practice, as noted above, product version numbers are subject to marketing considerations. For example, Microsoft Access jumped from version 2.0 to version 7.0, to match the version number of Microsoft Word. Sun's Java has had the versions: JDK 1.0.3 JDK 1.1.2 through 1.1.8 J2SE 1.2.0 through 1.4.2 J2SE 5.0

Software may have an "internal" version number which differs from the version number shown in the product name (and which typically follows version numbering rules more consistently). J2SE 5.0, for example, has the internal version number of 1.5.0, and versions of Windows from 95 on have continued the standard numerical versions internally: Windows 95 is Windows 4.0, 98 is 4.10, 2000 is 5.0 and XP 5.1.

Files and documents

Some computer file systems, such as the OpenVMS Filesystem, also keep versions for files.

Versioning amongst documents is relatively similar to the routine used with computers and software engineering, where with each small change in the structure, contents, or conditions, the version number is incremented by 1, or a smaller or larger value, again depending on the personal preference of the author and the size or importance of changes made.