To keep in mind.

Enviado por Genete a través de Google Reader: Dave Neary: Drawing up a
roadmap vía Graphics Planet el 7/02/11

One of the most important documents a project can have is some kind of
elaboration of what the maintainers want to see happen in the future.
This is the concrete expression of the project vision – it allows
people to adhere to the vision, and gives them the opportunity to
contribute to its realisation. This is the document I’ll be calling a
roadmap.

Sometimes the word “roadmap” is used to talk about other things, like
branching strategies and release schedules. To me, a release schedule
and a roadmap are related, but different documents. Releasing is about
ensuring users get to use what you make. The roadmap is your guiding
light, the beacon at the end of the road that lets you know what you’re
making, and why.

Too many projects fall into the trap of having occasional roadmap
planning processes, and then posting a mightly document which stays,
unchanged, until the next time the planning process gets done. Roadmaps
like these end up being historical documents – a shining example of how
aspirations get lost along the way of product development.

Other projects are under-ambitious. Either there is no roadmap at all,
in which case the business as usual of making software takes over –
developers are interrupt-driven, fixing bugs, taking care of user
requests, and never taking a step back to look at the bigger picture.
Or your roadmap is something you use to track tasks which are underway,
a list of the features which developers are working on right now. It’s
like walking in a forest at night with a head-light – you are always
looking at your feet avoiding tree-roots, yet you have no idea where
you’re going.

When we drew up the roadmap for the GIMP for versions 2.0 and 2.2 in
2003, we committed some of these mistakes. By observing some projects
like Inkscape (which had excellent roadmapping in 2005 and 2006) and
learning from our mistakes, I came up with a different method which we
applied to the WengoPhone from OpenWengo in 2006, and which served us
well (until the project became QuteCom, at least). Here are some of the
techniques I learned, which I hope will be useful to others.
Time or features?
A question with roadmaps is whether releasing on a given date should be
included as an objective. Having said that release plans and roadmaps
are different documents, allow me to qualify here: it is important to
set dates on waypoints, to keep people focussed on the path. But pure
time-based releases, with no features associated, doesn’t quite work
either.

I like Joel’s scheduling technique: “If you have a bunch of wood
blocks, and you can’t fit them into a box, you have two choices: get a
bigger box, or remove some blocks.” That is, you mix a time-based and
feature-based schedule. You plan features, giving each one a priority.
You start at the top and work your way down the list. At a given
horizon date, you run a project review. If a feature is finished, or
will be finished (at a sufficient quality level) in time for release,
it’s in. If it isn’t or won’t, it’s bumped. That way, you stick to your
schedule (well, mostly), and there is a motivation to start working on
the buggest wood blocks (the most important features) first.
Near term, mid term, long term
The Inkscape roadmap from 2005 is a thing of beauty. The roadmap mixes
beautifully long-term goals with short-term planning. Each release has
a by-line, a set of one or two things which are the main focus of the
release. Some releases are purely focussed on quality. Others include
important features. The whole thing feels planned. There is a vision.

But as you come closer and closer to the current work, the plans get
broken down, itemised further. The BHAGs of a release in 2 years gets
turned into a list of sub-features when it’s one year away, and each of
those features gets broken down further as a developer starts planning
and working on it.

The fractal geometer in me identifies this as scale – coding software
is like zooming in to a coastline and measuring its length. The value
you get when measuring with a 1km long ruler is not the same as with a
1m ruler. And as you get closer and closer to writing code, you also
need to break down bigger tasks into smaller tasks, and smaller tasks
into object design, then coding the actual objects and methods. Giving
your roadmap this sense of scope allows you to look up and see in the
distance every now and again.
Keep it accurate
A roadmap is a living document. The best reason to go into no detail at
all for future releases beyond specifying a theme is that you have no
idea yet how long things will take to do when you get there. If you
load up the next version with features, you’re probably aiming for a
long death-march in the project team.

The inaccurate roadmap is an object of ridicule, and a motivation
killer. If it becomes clear that you’re not going to make a date,
change the date (and all the other dates in consequence). That might
also be a sign that the team has over-committed for the release, and an
opportunity to bump some features.
Give space to breathe
In community projects, new contributors often arrive who would like to
work on features, but they don’t know where to start. There is an
in-place core team who are claiming features for the next release
left & right, and the new guy doesn’t know what to do. “Fix some bugs”
or “do some documentation” are common answers for many projects
including GNOME (with the gnome-love keyword in Bugzilla) and
LibreOffice (with the easy hacks list). Indeed, these do allow you to
get to know the project.

But, as has often been said, developers like to develop features, and
sometimes it can be really hard what features are important to the core
team. This is especially true with commercial software developers. The
roadmap can help.

In any given release, you can include some high priority features –
stuff that you would love to see happen – and explicitly marked as “Not
taken by the core team”. It should be clear that patches of a
sufficiently high standard implementing the feature would be gratefully
accepted. This won’t automatically change a new developer into a coding
ninja, nor will it prevent an ambitious hacker from biting off more
than he can chew, but it will give experienced developers an easy way
to prove themselves and earn their place in the core team, and it will
also provide some great opportunities for mentoring programs like the
Google Summer of Code.

The Subversion roadmap is another example of best practice in this
area. In addition to a mixed features & time based release cycle, they
maintain a roadmap which has key goals for a release, but also includes
a separate list of high priority features.
The end result: Visibility
The end result of a good roadmap process is that your users know where
they stand, more or less, at any given time. Your developers know where
you want to take the project, and can see opportunities to contribute.
Your core team knows what the release criteria for the next release
are, and you have agreed together mid-term and long-term goals for the
project that express your common vision. As maintainer, you have a
powerful tool to explain your decisions and align your community around
your ideas. A good roadmap is the fertile soil on which your developer
community will grow.

Cosas que puedes hacer desde aquí:
- Subscribirte a Graphics Planet con Google Reader
- Empezar a utilizar Google Reader para mantenerte al día fácilmente de
todos tus sitios favoritos
------------------------------------------------------------------------------
The ultimate all-in-one performance toolkit: Intel(R) Parallel Studio XE:
Pinpoint memory and threading errors before they happen.
Find and fix more than 250 security defects in the development cycle.
Locate bottlenecks in serial and parallel code that limit performance.
http://p.sf.net/sfu/intel-dev2devfeb
_______________________________________________
Synfig-devl mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/synfig-devl

Reply via email to