Great Walls of Wonder

How to Build Your Own Wall of Wonder

One of the foundations of agile development is increasing the visibility into the software development process through
techniques like the demonstration of working software at the completion of an iteration. Another technique is to leverage a
visual radiator that shows requirements flowing through an iteration development lifecycle into completed and tested code. I
call this a Wall of Wonder as it can have a wondrous effects on business stakeholders and project participants as they see
iteration progress and can adapt to bottlenecks and problem areas.

What is a Wall of Wonder?

A Wall of Wonder is a visual radiator that software development teams use to manage their tasks and activities in
completing their goals in an iteration. The Wall of Wonder is a highly tactile and visible tool that requires very little in the
way of infrastructure or training to implement.

In many software development projects, information related to the project and its overall progress and velocity is 'locked'
inside a variety of different tools. Project Managers create GANTT charts in Microsoft Project, analysts document
requirements in Requisite Pro or Doors, developers write their code using an IDE and check it into a version control
system, testers write scripts using Winrunner or Loadrunner. In rare cases, this information will be browser accessible but
typically it can only be accessed using the original authoring tool and often requires special authorizations to access the
files themselves. In every case, it's not clear how any of information relates to one another; are the requirements being
developed by the analysts really what the developers need to create the right software, do the testers know what
functionality will be available for testing, does the project manager know that the most important/architecturally significant
tasks are being completed first? The result is that it's almost impossible to get a definitive understanding of project
progress which limits the feedback teams need to adapt and adjust.

One way around this is to create a Wall of Wonder. Using standard index cards, a white board and some tape or magnets
you can quickly show overall progress in an iteration and make your daily stand-up meetings more effective.

Creating a Wall of Wonder

To create your wall of wonder you'll need:

A large whiteboard in a highly visible
location (ideally the same location where
your daily stand-up meetings are held)
Index cards (different color cards can be
useful to represent different types of tasks
but you can use a colored marker instead)
Tape or if you have a magnetized
whiteboard, magnets (you can buy these
in small pre-cut squares)
Post-it Notes

As you can see from the picture to the right, the
wall of wonder in this case was a simple white
board next to a large table. This particular
location was actually in a hallway which
increased visibility into the project and the
technique as people walked by. The team did
considerable brainstorming around the table
and the wall.

Collaborative Development and Fun with Cards

One of the most telling benefits of the Wall of Wonder and leveraging Task Cards is the level of collaboration and
engagement that occurs. The cards themselves are an invitation to 'have a conversation' about a feature or requirement,
similar to that advocated by Ron Jefferies. Enough information is available on the cards to prioritize and assign work but
not so much that a developer will know exactly how to realize the functionality on the card. Another benefit of the cards is
that different roles can work together to ensure that all the work on a card is completed. On many of the projects that I have
managed the final test of completeness was having a tester walk through the code with a developer to ensure it worked to
its specifications and was appropriately documented. The tester was armed with the Red Marker and when satisfied that
a card was complete would 'approve' it with a mighty swipe of the marker. Developers who claimed they had completed
their task card but didn't have the 'official' red marker check were quickly reminded that they weren't really done. The cards
also became a fun way to show progress and bring some friendly competition into the development lifecycle. One of the
developers on a project I managed once completed five cards in a single day, from that point on he was nicknamed 'Five
Card', a name that persisted for several years after the project!

Creating Task Cards

The Wall of Wonder reflects activities and tasks associated with
your iteration and to convey this, index cards are used. One
reason, index cards are so useful in managing complex software
development processes is because they're so simple. Index cards
are readily available (I've personally driven to many Office Depots
to grab cards prior to facilitating planning sessions at client sites),
they require little in the way of training, they're highly tactile and
they're inexpensive.

The cards used in this example are tasks specifically related to
developers and have some important components associated with
them.

Using Your Wall of Wonder

There are a variety of ways to create your Wall of Wonder but there are several key themes that should be present:

The first is that the purpose of the wall is to show progress in an iteration. You should separate disciplines and even
application tiers to make this evident and ideally you should use plain language to represent each of the areas (which
will make it easier for non-project team members to see progress).
The second is that the wall should help different roles on the team work together to accomplish the goals of the
iteration (which implies that you establish goals each iteration, if you need a template for this you can find one here).
This means that analysts should be providing requirements to the development team in enough time that they can
write software, developers should be building the system across all tiers (not just business logic), testers should be
aware of what has been built and what has not been built in preparing their tests/validation processes.

One effective way to manage your Wall of Wonder is to leverage a 'kanban' style that shows the flow of work through the
lifecycle (Requirements, Analysis, Design, Development, Test. Deploy). Another, and the approach I used on this project is
to on development tasks required to realize a requirement across all tiers of the application (presentation/business/data
access). Any approach will work provided that the principles mentioned above are adhered to.

May 2008

by Bryan Campbell

Great Walls of Wonder

The Overall Wall of Wonder process

As many people already know, I leverage agile techniques
within the context of the Unified Process software
development methodology. Consequently, each two week
iteration contains 'slices' of activities and also inputs from
disciplines that the Unified Process identifies. If you're
interested in learning more about this you can read this blog
article to get a quick thumbnail sketch of how I manage this
process. The thumb-nail image to the right provides an
overview of what this looks like. The key however is that work
scheduled for an iteration can be easily broken down into
small. managable tasks that can be updated on a daily basis.

The first was a definition of 'done'. Before a card could be returned the developers agreed on what needed to be
completed, examples included unit tests written, appropriate documentation and syntax used, successful inclusion in
a Continuous Integration build that passed all of its tests.
The second was involving different disciplines. Cards were written in a lightweight, bulleted fashion with references
to supporting information like domain models and use cases. However, they were also intended to have developers
engage in a dialog with the requirements analysts without having to read reams of requirements documents.
Finally, the cards allowed the Testers to become more actively involved in the process. The final check before a
card could be identified as 'done' involved taking the card to one of the testers and walking them through the 'done'
criteria. The testers would then sign-off that the card was complete from their persepctive.

In Conclusion

Creating a Wall of Wonder is a lightweight, inexpensive and engaging way to manage a software development project.
This technique works best for small teams working together although the ideas behind it can scale using products from
Rally Software or at www.cardconversationconfirmation.com. Although the ideas in this article have been used a number
of times on projects, there are no 'firm' rules to creating a Wall of Wonder and you can use whatever approaches best suit
your needs. If you have questions about this approach or want additional information don't hesitate to contact me and I'd
also be interested in hearing how others are applying/leveraging these techniques.