This page describes OLPC's software release process.
The goals of the release process process are to:
- Ensure high quality releases which meet the needs of users in a timely fashion.
- Maximize the participation, productivity and enthusiasm of the open source community.
- Create a predictable process which helps users and developers plan for the future.
The output of this process is a generic software image suitable for installation on OLPC's XO laptop platform. The image is generic in the sense that it includes a rounded selection of activities, applications, and languages.
We do not expect established deployments to use this software image directly. Almost all deployments have needs or desires to customise the software image that they ship (e.g. with new languages, a different selection of activities, specific default settings, etc.). We expect that most established deployments will use the Build system to produce a variant of the release including their own customizations.
Nevertheless, the process of developing and stabilising the generic release is key, as it forms the base of all the deployment-customized software releases.
Each release is planned in advance, and this process results in a slightly different development/release methodology for each release. However, certain guidelines and well-established principles are stuck to:
- The release planning documentation is made public from the start.
- Release development is divided into individual stages, separated by milestones (discussed below)
- Releases are coordinated according to a schedule of milestones, which is decided early on, and included in the release plan.
- This is important so that our customers know when to expect the final release, when they should get involved with development and testing, and to allow them to plan their upgrade/rollout.
- This is also a well-established practice in our neighbouring open source communities
- The release schedule is honored strictly. That is, the milestone dates are adhered to, even if some sacrifices (such as exclusion of planned features which didn't arrive in time) are made. Some flexibility can be allowed for, but these should be exceptional cases only.
The development process is divided into distinct stages, with milestones to mark the progression from each one to another. Each of the items below links to an extensive explanation (including technical and managerial procedures) of each stage, be sure to read them all if you want to become involved in the release process.
- Release Process/Planning
- Release Process/Development
- Release Process/Stabilization
- Release Process/Release
Major and minor releases
Major releases include large platform changes (such as updating to the latest versions of Fedora & Linux) and addition of new features.
Minor releases (a.k.a. point releases) are limited to the fixing of bugs which are affecting deployments, and occasionally include translation and locale updates (requested by deployments).
- This was previously adhered to quite strictly, but the recent minor releases in the 10.1 series have seriously blurred the lines between major and minor releases. This degrade of practice started when OLPC's development resources were downsized, meaning that there were no resources in sight to allow for a future major release, resulting in the relaxing of criteria on what could go into the minor release. However, now that OLPC's software team has grown a bit again, it is my hope that this previous practice can be restored, so I've documented it that way. Time will tell... -DanielDrake 17:22, 9 February 2011 (UTC)
New major releases will include a set of new features, pioneered and developed by OLPC staff and community members. A feature is defined as a significant change or enhancement to the current version of XO software that may or may not include new packages. Our feature process should be driven by the needs and feedback of our customers (deployments) and our users (young children).
Features are usually considered to meet one or more of the following objectives:
- Highly user visible changes
- Improvements or changes that require non-trivial cross-package integration
- Noteworthy enough to call out in the release notes
- Exciting new capabilities we can trumpet.
Some examples might include:
- New educational tools that will be used by children
- New features from upstream that we are making available on the XO for the first time
- Improvements to tools and infrastructure used by activity developers
OLPC plans which features to develop for each release according to its key principles and based on feedback from customers. During planning stages, a discussion will usually be started on the devel mailing list in order to solicit input from the community, and to clearly communicate that the feature planning process is underway.
Features can also enter releases through upstream projects. For example, a new feature added to GNOME will automatically enter an OLPC release once a release is made including that specific GNOME version. Some of these features may have direct impact on OLPC and are good candidates to be discussed in the release notes.
Features outside of OLPC's feature plan are also welcome to be contributed by interested individuals and deployments, providing that they meet the normal code acceptance criteria (open source, good code quality, good documentation, appointed maintainer, ...), and provided that they are accepted and included within the acceptable stages of the release schedule. In many cases, development of such features does not belong at the OLPC level, but rather in the upstream projects (for example, development of a new Sugar feature would fall entirely within the SugarLabs community, and would not need acceptance or review by OLPC).
Maintainability and sustainability
OLPC has historically made quite a few changes to standard open source software technologies (Linux, Fedora, etc) and this hurts us in every release cycle. We are now a small team and every release cycle we spend a lot of time bringing forward the the collection of OLPC-local changes.
In recent times, this "delta" from upstream software has been greatly reduced. We need to keep working in that direction, which means strict controls on any new non-upstream changes being added. The most effective way to approach this is to get your changes upstream first.
The release names are of the form "Y.H.NN"
- Y = target calendar year
- H = major release number representing first release or second release of the calendar year
- NN represents the Minor Release, starting with .0 at the availability of the first Major Release and going up by 1 for each publicly available minor release after that.
A Major Release and all its derivative Minor Releases can be referred to with a variable (or wildcard) in the third digit (e.g. 8.2.x refers to 8.2.0, 8.2.1 and 8.2.3).
- 8.1.1: First Minor Release rebuild based on the first Major Release in 2008
- 8.2.0: Second Major Release in 2008
Each release stream is composed of a series of builds: a number of development builds, followed by some release candidates, followed by a final build that consists of the official, final release. Each build has a unique number. As of 2012, the numbering scheme works as follows:
Each Major Release resets build numbering to start at 1 for the first development build. Later builds will increment that number, starting with development builds. When stabilising, release candidates will continue the increment-by-one pattern until the final build is reached. For example, here is a hypothetical situation:
- 12.1.0 enters development. The first build is build 1. Builds 2,3,4,5,...34 are produced during the development phase.
- 12.1.0 enters final stabilisation. Builds 35, 36, 37 are published as release candidates.
- The 12.1.0 release is finished. 12.1.0 build 37 is published as the official, final version.
- 12.2.0 enters development. Build numbering resets to build 1. Development builds 1,2,3,4,...,25 are produced
- 12.2.0 enters final stabilisation. Builds 26,27,28 are published as release candidates.
- The 12.2.0 release is finished. 12.2.0 build 28 is published as the official, final version.
As of 2012, the filenames of the release files produced by the build system are structured in the following manner:
- Fourth digit of the four-digit year corresponding to the Major Release (the "Y" component above), e.g. "2" in 2012, "3" in 2013
- The release number within the current year (first or second release, the "H" component from above). For 12.2.0, thats "2".
- Three-digit zero-padded build number, e.g. 098
- An alphabetic 'deployment identifier', max 2 characters. OLPC will use "o", deployments may wish to use their two-letter country code.
- A numeric code identifying the target laptop model.
- A '.'
- The file extension
The laptop model codes are:
- XO-1: 0
- XO-1.5: 1
- XO-1.75: 2
- XO-3: 3
- XO-4: 4
For example, 21099o1.img is 12.1.x build 99 for XO-1.5 published by OLPC. 22031ni2.img is 12.2.0 build 31 for XO-1.5, for the OLPC Nicaragua project.
If the deployment identifier code is limited to 2 characters, the resultant filename will adhere to the 8.3 limit (8 character filename, 3 character extension). This is the maximum filename length that can be read by the firmware when using VFAT-formatted USB media (this is common). This is why it is strongly recommended to limit the deployment identifier to two characters, although the build system does let you use more.
In the interest of keeping the image size down, OLPC only ships certain locales/translations in its released builds. New locales can be requested by writing to the devel mailing list. The criteria that must be met are:
- There is an active or soon-upcoming deployment (of any size) that is expected to use this language in the software release being targetted.
- The development cycle for the targetted software release is at an appropriate point (i.e. open-development, not frozen) to accept changes of this scope
On one hand, the selection of locales included in OLPC's official builds is somewhat irrelevant, because we expect all significant deployments to use the build system to produce a customized version of each official release that they ship; the supported locales can be modified at this time.
On the other hand, deployments should aim to become actively involved in the OLPC release process: updating, testing and refining their translations during the development stages of the release. This can't be done if OLPC's own releases don't include the locales/translations in question; asking deployments to regularly re-spin development builds is probably asking a bit much. So, deployments requesting inclusion of their specific locale makes a lot of sense, even if they will re-spin and customize the official release build when the time comes.
How to contribute
Translation of the Sugar user interface (UI) is primarily handled via the Pootle instance hosted by Sugar Labs on behalf of the broader Sugar Labs / OLPC / eToys communities.
Documentation about the Translation Team and their processes can be found here:
The Translation Team coordinates it's efforts via the Localization (L10n) list hosted on OLPC's Mailman instance:
Translation of the GNOME boot UI strings in OLPC Sugar / GNOME dual-boot images occurs in various upstream locations: the GNOME L10n server, the Fedora Transifex server, and the Translation Project. Specific upstream packages used by OLPC are tracked on Pootle and several upstream packages are collaboratively localized and hosted on Pootle (e.g. AbiWord and Gnash).
- Release Process Home/Historical - historical plans for parts of the release process