commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Henri Yandell <>
Subject Release managing a major version [and Lang 3.0 post mortem]
Date Thu, 28 Jul 2011 22:06:12 GMT

"The Sisyphean task of shoving a large number of bytes up a big hill
while everyone else tries to add, remove and tweak said bytes".

= Step 1: Identify the issues.

Hopefully you are lucky and issues are accumulated in a JIRA, Bugzilla
or other issue tracker (here on JIRA as its our most common one). If
so - bonza. If not, then do your best to drive them to a single

* Look in your code for TODO items that are bigger than minuscule
notes and move them to JIRA.
* Add the taglist plugin (if in Maven) so you can still point to the
minuscule items. Configure it.
* Look for any documentation or text files with todo items. Drive them to JIRA.

= Step 2: Triage the issues.

Any "Unscheduled" issue is grounds for triage. Triage involves moving
an issue, possibly via conversation, to the following items:

* Your current release target. Let's say 2.0.
* Subsequent release targets. In this case, 2.x.
* WONTFIX - ie) cast them back.

Use common sense - an issue _only_ affecting the 1.x branch should
have its own maintenance triage process. Other resolutions are fine
(Duplicate, Invalid, Can't Reproduce etc).

= Step 3: Start focusing on issues.

Initially it's fine to leave a huge clump of issues in 2.0. You're
casting wildly around, random work is happening and it's unlikely that
anything will be in 2.x. This is the new-development state. Lots of
discussion around APIs and scope of the project.

Your task is to keep things moving. Get things into the 2.0 list, plod
along working on just enough to keep the flywheel of interest going.

= Step 4: Recognize when it's time to start focusing on the finish

At some point you'll realize that the discussion is getting focused on
smaller details and not large issues. You'll also get users asking
when the release is coming. It's time to start winnowing down on the
remaining issues.

Primarily this means moving issues from 2.0 to 2.x. Do this for issues
that won't require a major version change later on. Minor bugs and
features that lack patches are good examples. Indicate that you're
moving them due to the lack of a patch - "Moving to 2.x as no patch".

It might mean making a 3.0 and moving issues there if they are a)
going to mean a major version release and b) there's no end in sight.
Obviously try to avoid that, but for wishlist items this is quite
likely. The reality is that if someone had the energy to implement the
wish, it would have happened.

By doing this you should have a tight list of issues to be worked on.
All very believable if the time is but applied. You might have some
major issues for which a solution is not apparent, but you can't
imagine releasing without a fix for.

= Step 5: Start driving for the finish

Focus on your 2.0 list. Keep pushing things to 2.x as much as possible
(unless a patch is available of course) and drive conversation to the
mailing list in a priority order (where priority is severity of bug
and the resolve-risk - ie) not having a solution).

Begin with your blocking issue with no solution. Get people talking
about it on the list. Don't be afraid to throw out half-arsed ideas.
Don't be afraid to nudge privately. Then start focusing on the
(hopefully) short list of other items.

Start to discuss the possibility of release. Consider a beta, it'll
allow you to release without all the items fixed, but will start to
drive people to think and believe in a release. It'll also test the
release mechanics.

Be increasingly defensive about new features or over-polishing.

= Step 6: Release, sweet release

Achieve goal. Conquer world etc.


All of this is based on how Lang went (by and large). It does imply
that Lang went well; which it didn't imo. We took too long to accept
we should start a new major version [ie) JDK 5 is out, but it's not
standard so we won't even start]. We also treated it like a major
release, putting lots of features and bugfixes in as well as the non
backwards compatibile changes. Ideally we would have two versions, a
2.x branch and a 3.0 that launches quickly, and both have the same
bugfixes and features added to them.

Niall did a great job of backporting from 3.0 to 2.5 and then to 2.6.
That covered up a problem which shouldn't have existed, ie) changes
should have gone into both. The problem there, which largely requires
sweat and elbow grease to surmount is that backwards incompatible
changes are more likely to lead to source control merge conflicts [a
wild claim, but one that feels likely to my gut]. Ideally you would
auto-sync the changes to 2.x over to the 3.0 branch, but that means
being able to migrate them. The package name change is easy, but
generics would make that pretty hard.

What does this mean - it means we need to be working on 4.0 now (Java
7 compatible) while still developing the 3.x (Java 5 compatible)
branch. I think this should be easier to do; a search and replace on
'lang3' to 'lang4' and then attempt to auto-commit.


To unsubscribe, e-mail:
For additional commands, e-mail:

View raw message