Man Linux: Main Page and Category List

NAME

       release_method - .TH "release_method" 3 "Thu Aug 12 2010" "Version
       1.6.8" "avr-libc"

NAME

       release_method - .SH "Release Version Numbering Scheme"

   Stable Versions
       A stable release will always have a minor number that is an even
       number. This implies that you should be able to upgrade to a new
       version of the library with the same major and minor numbers without
       fear that any of the APIs have changed. The only changes that should be
       made to a stable branch are bug fixes and under some circumstances,
       additional functionality (e.g. adding support for a new device).

       If major version number has changed, this implies that the required
       versions of gcc and binutils have changed. Consult the README file in
       the toplevel directory of the AVR Libc source for which versions are
       required.

   Development Versions
       The major version number of a development series is always the same as
       the last stable release.

       The minor version number of a development series is always an odd
       number and is 1 more than the last stable release.

       The patch version number of a development series is always 0 until a
       new branch is cut at which point the patch number is changed to 90 to
       denote the branch is approaching a release and the date appended to the
       version to denote that it is still in development.

       All versions in development in cvs will also always have the date
       appended as a fourth version number. The format of the date will be
       YYYYMMDD.

       So, the development version number will look like this:

       1.1.0.20030825

       While a pre-release version number on a branch (destined to become
       either 1.2 or 2.0) will look like this:

       1.1.90.20030828

Releasing AVR Libc

       The information in this section is only relevant to AVR Libc developers
       and can be ignored by end users.

       Note:
           In what follows, I assume you know how to use cvs and how to
           checkout multiple source trees in a single directory without having
           them clobber each other. If you don't know how to do this, you
           probably shouldn't be making releases or cutting branches.

   Creating a cvs branch
       The following steps should be taken to cut a branch in cvs:

       1.  Check out a fresh source tree from cvs HEAD.

       2.  Update the NEWS file with pending release number and commit to cvs
           HEAD:
            Change "Changes since avr-libc-<last_release>:" to "Changes in
           avr-libc-<this_relelase>:".

       3.  Set the branch-point tag (setting <major> and <minor> accordingly):
            'cvs tag avr-libc-<major>_<minor>-branchpoint'

       4.  Create the branch:
            'cvs tag -b avr-libc-<major>_<minor>-branch'

       5.  Update the package version in configure.ac and commit configure.ac
           to cvs HEAD:
            Change minor number to next odd value.

       6.  Update the NEWS file and commit to cvs HEAD:
            Add "Changes since avr-libc-<this_release>:"

       7.  Check out a new tree for the branch:
            'cvs co -r avr-libc-<major>_<minor>-branch'

       8.  Update the package version in configure.ac and commit configure.ac
           to cvs branch:
            Change the patch number to 90 to denote that this now a branch
           leading up to a release. Be sure to leave the <date> part of the
           version.

       9.  Bring the build system up to date by running bootstrap and
           configure.

       10. Perform a 'make distcheck' and make sure it succeeds. This will
           create the snapshot source tarball. This should be considered the
           first release candidate.

       11. Upload the snapshot tarball to savannah.

       12. Update the bug tracker interface on Savannah: Bugs ---> Edit field
           values ---> Release / Fixed Release

       13. Announce the branch and the branch tag to the avr-libc-dev list so
           other developers can checkout the branch.

       Note:
           CVS tags do not allow the use of periods ('.').

   Making a release
       A stable release will only be done on a branch, not from the cvs HEAD.

       The following steps should be taken when making a release:

       1.  Make sure the source tree you are working from is on the correct
           branch:
            'cvs update -r avr-libc-<major>_<minor>-branch'

       2.  Update the package version in configure.ac and commit it to cvs.

       3.  Update the gnu tool chain version requirements in the README and
           commit to cvs.

       4.  Update the ChangeLog file to note the release and commit to cvs on
           the branch:
            Add "Released avr-libc-<this_release>."

       5.  Update the NEWS file with pending release number and commit to cvs:
            Change "Changes since avr-libc-<last_release>:" to "Changes in
           avr-libc-<this_relelase>:".

       6.  Bring the build system up to date by running bootstrap and
           configure.

       7.  Perform a 'make distcheck' and make sure it succeeds. This will
           create the source tarball.

       8.  Tag the release:
            'cvs tag avr-libc-<major>_<minor>_<patch>-release'

       9.  Upload the tarball to savannah.

       10. Update the NEWS file, and commit to cvs:
            Add "Changes since avr-libc-<major>_<minor>_<patch>:"

       11. Update the bug tracker interface on Savannah: Bugs ---> Edit field
           values ---> Release / Fixed Release

       12. Generate the latest documentation and upload to savannah.

       13. Announce the release.

       The following hypothetical diagram should help clarify version and
       branch relationships.

       Release treeRelease tree