This document provides:
In a nutshell, Juneau release numbers are usually of the form "<major>.<minor>.<point>".
We identify two distinct categories of APIs within a component: external, internal.
Composed of the public-facing classes, methods and fields that are likely to be consumed by external developers. In general, these consist of all public classes/methods/fields, and protected methods/fields on classes meant to be extended.
We try to avoid or at least acknowledge changes to the external interface.
Composed of classes, methods, and fields not meant for external consumption.
We mark interfaces as internal in the following ways:
Developers have free reign to make changes to the internal interface. These interfaces should not be included in the Javadocs.
We can categorize the changes to a component according to the degree to which these changes are compatible with previous releases of the component. We define three such categories: fully-compatible, interface-compatible, and external-interface-compatible.
Release B is said to be fully-compatible with Release A if B can simply replace A in (nearly) all circumstances and deployments without changing the client code or configuration, and without changing the semantics of any public or protected member.
Examples of fully-compatible changes include:
Examples of changes which are not fully-compatible include:
Note that not every non-fully-compatible change will cause compilation or readily apparent run-time problems.
Generally speaking, a fully-compatible change will at most change the private interface of a component, or simply add classes, methods and attributes whose use is optional to both internal and external interface clients.
Release B is said to be "interface-compatible" with Release A if (nearly) all clients that can be compiled with A in the classpath can also be compiled with B in the classpath, without changing the semantics of any public or protected member. A configuration or classpath change may be required.
Examples of interface-compatible changes include:
Examples of changes which are not interface-compatible include:
Generally speaking, an interface-compatible change will at most change the private interface of a component, or simply add classes, methods and attributes whose use is optional to both internal and external interface clients.
Release B is said to be "external-interface-compatible" with Release A if (nearly) all clients that depend only on the external interface of a component and that can be compiled with A in the classpath can also be compiled with B in the classpath, without changing the semantics of any member in the external interface. A configuration or classpath change may be required.
Examples of external-interface-compatible changes include:
Examples of changes which are not external-interface-compatible include:
Generally speaking, external-interface-compatible changes correspond to changes to at most the internal interface of the component or the addition of optional classes, interfaces or members to the external interface.
We identify five types of releases: "Major", "Minor", "Point", "Beta" and "Milestone".
Developers are encouraged to "upgrade" a release to a stronger type whenever the nature or scope of the change warrants it.
Major releases signify significant changes to a component. Developers may perform a major release if there have been substantial improvements to the component. Developers must perform a major release whenever the new release is not at least interface-compatible with the previous release.
Minor releases signify enhancements to a component that do not necessitate a major release. Developers may perform a minor release if the release is at least external-interface-compatible with the previous release.
In other words, whenever a client depends upon at most the external interface of a component with a given minor release, it will work with all subsequent minor releases within that major release.
A point release typically involves simple bug fixes or optimizations and minor new features. Developers may perform a point release if the release is at least interface-compatible with the previous release.
In other words, whenever a client depends upon a component with a given point release, it will work with all subsequent point releases within that minor release.
Developers may, at their option, perform a beta preview of any major, minor or point release. Beta releases may be performed for a variety of purposes such as:
While every effort should be made to ensure the quality of released code, "beta" releases are essentially provided as-is with no guarantees of stability or maintenance.
Developers may, at their option, offer a milestone preview of any major release. A milestone release is appropriate when part of the overall component is fully functioning and the team wants to make it more widely available for testing. Those features implemented and those remaining to be implemented should be clearly defined and documented.
While every effort should be made to ensure the quality of released code, "milestone" releases are essentially provided as-is with no guarantees of stability or maintenance.
A release number is comprised of 3 components: the major release number, the minor release number, and an optional point release number. Here is a sample release number:
2.0.4
and it can be broken into three parts:
The next release of this component would increment the appropriate part of the release number, depending on the type of release (major, minor, or point). For example, a subsequent minor release would be version 2.1, or a subsequent major release would be 3.0.
Note that release numbers are composed of three _integers_, not three digits. Hence if the current release is 3.9.4, the next minor release is 3.10.0.
Beta releases are denoted by adding "B<beta version number>" after the release number. For example, if the current release version is 2.0.4, and a developer wished to preview the next major release, the release would be labeled 3.0-B1.
Milestone releases are denoted by adding "M<milestone version number>" after the release number. For example, if the current release version is 2.0.4, and a developer wished to preview the next major release, the release would be labeled 3.0-M1.
We identify four possible states: "in development", "beta", "released", and "unsupported".
When a component is "in development", it is new and still relatively unstable. Typically components in this state do not have any binary releases available beyond the nightly builds. Users should be made aware that this component may change its functionality or interface before a stable release is achieved. A "milestone" release may be made while the component is still "in development" to make the features currently implemented more widely available for testing in a more stable test version.
When a component has made significant progress toward release-quality code, the committers may vote to perform a "beta" release. At this point, the component state will change from "in development" to "beta". The component will remain in this state until it is ready for its first major release.
Note that developers may skip vote to skip the "beta" state and go directly to "released", if the component is sufficiently stable.
When a new component is finally production-quality, the developers may vote to perform the first major release. At this point, the component status will be changed from "beta" to "released". In the future this component will always be considered to be in the "released" state, even when new releases are initiated. The only exception is in the case of "unsupported" components.
Under rare circumstances, committers may vote to make a component "unsupported", if there are no resources to maintain the library or if it has been completely supplanted by another component. Only "released" components may become "unsupported"; components in other states will simply be terminated after a brief warning period.
Using this approach it is possible to very precisely and concisely define the dependencies between a component and its clients.
For example, suppose that the application Foo depends (only) upon features of the juneau-core component that are part of the external interface in release 2.3.0. Then the maintainers of Foo can state with a high degree of certainty that Foo will work with any 2.x release of superwidget (x >= 3).
Similarly, suppose the application Bar depends upon features of juneau-core that were part of the internal interface of release 2.3.0. Then the maintainers of Bar can state with a high degree of certainty that Bar will work with any 2.3.x release of superwidget. Only once 2.4 (or 3.0) is released will Bar's developers have to re-evaluate.
Related articles appear here based on the labels you select. Click to edit the macro and add or change labels.
|