I occasionally have days where, when reading a mailing list, I want to stab my eyeballs out at what I am reading. And then I realize that: Perhaps my thoughts might be better utilized if I make a blog post. (Bonus: I won’t look like a totally angry troll!) And then, at 4am, as I lay in bed, the thoughts still seething in my head, I say, well, maybe I’ll do that now.
And thus, today, I bring you: My observations and advice on the utilization of time-based schedules in open source software communities.
Full disclosure: I used to do program management (ie: build the schedule, kindly and repeatedly ask people to comply) for Fedora. I learned a lot in a relatively short period of time, thanks to the awesome people I work with. I have no certifications in project management, I have never officially studied it or taken a course in such things, and quite frankly, I just might not actually know what the hell I’m talking about. But I like to think I know a thing or two, or that I might at least give you, dear readers, something to ponder on as you work in your own projects.
First off: There are time-based schedules, and feature-based schedules, and those are pretty much the two models I see employed in community-land. (Yeah, yeah, agile, blah blah blah, I’m not getting into that or its relationship to these methods right now.) Time-based means that you do releases on a predictable basis, you pick a date, and you STICK TO THAT DATE, come hell or high water. Feature-based scheduling involves identifying a list of features, and working until those features are actually done, at which point… you release. I am not going to dive into the latter method, at least today, but I will say this: “Features” tend to suffer from what is referred to as scope creep – what seemed like a small task in the beginning gets a little enhancement here, a little extra love there… basically, they can go on for some time without being *done* according to someone’s opinion. Which means it could be a really long time between releases. (And that may be okay for a lot of people, but you lose out on some of the benefits I’m going to talk about.)
The benefits of time-based schedules
There are many, but these are the two big ones in my mind:
- Out with the old and in with the new. If you’re doing time-based schedules on a short enough release cycle – 4 to 6 months, even 8 months – you know that anything that doesn’t make it into this release, is only going to be one more release cycle away, and you know exactly how long that will be. You also benefit from looking like you’re actually making progress; potential contributors can see that things are coming out the door, and not wonder if the community they are about to jump into is ever going to finish what they are doing. Users know when new stuff is expected, also good.
- Predictability for the community. If I know that I generally contribute to one specific thing (or perhaps more), and I know when that contribution is expected, I am more likely to make that deadline. There is never any question about when things need to happen.
But announcing that the release date is X and patches are welcomed is, well, not enough. Particularly if the scope of the project is large, or you have a large number of contributors. Here are the basic pieces that I think are important:
KNOW YOUR FEATURES
- Have dates by which features must be proposed and accepted. I’m not going to tell you how to decide what gets in and out; that varies from community to community. MAKE SURE that this list is prominently displayed. This gives people a way to give feedback. Sometimes features collide; this can help to avoid that, or at least, to ensure that changes are well-coordinated for things that are really dependent upon each other.
- Have a date by which all features must be complete. You can scale this as you want (must be close, another date for really done). And then be very clear about the fact that features will NOT BE INCLUDED if they are not finished. Why? There may be people in your community doing documentation, marketing, translations, making test plans, etc. People need to know when a good time is to start doing all of those things, without doing it for things that are going to get dropped; they also don’t want to get hailed the day before release because this brand new thing just landed and HEY, wouldya mind dropping everything and writing replete documentation at the last second? Not cool. Having a clear cut-off is important.
- Track the actual progress of accepted features. Make feature owners/contributors be responsible for providing those updates on a regular basis in an easy-to-read place. Nobody likes surprises.
- Define what a feature actually is. New and shiny stuff doesn’t have to be the limit. Sometimes a feature can be a change in how the software is built, or the removal of some functionality or dependency. Again, the key here is having the list of features published; removing things arbitrarily if people depend on them, or worse, if someone is actually contributing those things or would commit to improving them if they knew that there were issues that necessitated the removal, sucks.
DEFINE THE END GAME
After the point where features should be done, well, people are probably doing bugfixing for a while, and then testing and getting ready for release. The length of time for all of these things is up to you; just be sure that, again, IT IS PUBLISHED AND KNOWN. But here are a few other things you can add to make the sprint to the finish line more efficient:
- Have a list of release criteria. Nobody wants to sit around arguing whether or not something is shippable. What functionality does the software ABSOLUTELY have to have to make it useful after shipping? Write it down. Make sure people are in agreement. Make sure your test plan actually tests those specific criteria.
- Publish your test dates. Advertise them. Make sure when you’re deciding these dates that it’s actually a reasonable amount of time to test things. Methamphetamines are illegal and bad for you, kids: don’t make your QA folks stay up 24/7 for a week.
- Have a date on which key contributors/stakeholders/stuff-doers can meet or communicate and agree upon shippability.
- If it is not shippable, have a pre-determined (as in: not during the meeting!) length of time during which bugs will be fixed and testing will happen before you meet again.
Some last bits of advice, at least for this blog post, for those of you who are just absolutely convinced by now (or were already moving that way):
- Pick your date, and work backwards. Figure out how much time it takes to reasonably test a final product, how long it takes to build a release candidate, how long you want to do bugfixing on features for before you make a release candidate, how long the development phase is, the date by which all features should be accepted and defined, how long your planning/feature proposal period is. And remember that it’s not all about the code; if you have people doing documentation, translations, etc. make sure that their roles are defined and considered as well. And above all: Make sure people are in agreement when you’re doing this for the first time.
- Bugs in the release process are expected. Especially the first time. Document them and fix them, yo.
- PUBLISH YOUR SCHEDULE. Pro tip: Publishing your schedule on a mailing list and having it be the only place where it is seen is not helpful. Put it on a wiki, a webpage, whatever it is you have. People do not want to go trolling through their mail to find this when they likely refer to it often. Newcomers do not want to search through archives in the hopes that it might be there. Users don’t want to do that either.
- Advertise your schedule at major milestones. If you have a blog, a twitter account, whatever, NOTIFY people of looming deadlines and of actually reaching those milestones. If people look like they are falling behind, reach out to them personally. You don’t want people saying, how was I supposed to know? Added bonus: you will look like you have your act together! (Even if inside you’re wondering deep down inside how the hell this is ever going to come together into something that resembles anything.)
- Bugs. You have them. Remind people of their existence as deadlines loom. Paste the list and owners if necessary.
- Haz too many dependencies and relationships between tasks? Taskjuggler, my friend. Use it.
And finally: If you are making the move — don’t magically cut over to a point that is skipping half of the steps above. Seriously: If I’ve been steadily plugging away at something, and suddenly I have this major impending deadline out of nowhere that I can’t meet, or if I am a maintainer of some sort and I am suddenly faced with fix it or it disappears, that’s not a pretty feeling. Time-based schedules can help to build your community by ensuring that people can be successful contributors to the project, which makes them come back to give more; it helps them to know when they can contribute, make changes, and helps them to prioritize your project amongst all of the other stuff in their lives. Skipping key milestones, skipping listings of features or changes or agreement upon those changes, effectively prevents some people from being able to participate or contribute. You can accelerate under certain circumstances – but don’t skip the meat of what needs to happen. Good processes can help to build great communities, which can build great software. Don’t disenfranchise your contributors (who are also your best evangelists) – they are the ones who will get you through this release, and many after it, and make it better.
And now is the time where Robyn sleeps for a bit.