9 Things You Should Always Do When Pruning Your Product Tree

Product Tree is one of the most powerful but least-used techniques in agile development. Product Tree is a way to visualize your product structure, showing the relationships between all of your products and projects.

It can be especially helpful when you’re designing or choosing your release plan. Because it lets you see how everything fits together before you start writing any code or building any features. Visualizing your product structure with a tree also helps make sure that everyone on the team has the same understanding of the architecture and knows what components are built by whom.

By doing nothing more than making some decisions about how products relate to each other. You’ll quickly discover omissions, gaps, and redundancies . These become opportunities to simplify your design.

For example, if you’ve just spent weeks designing a monolithic application that captures all of the product’s requirements inside one big component. that doesn’t mean that it will be simple to release or support. Quite the opposite! You’ll spend lots of time wondering whether or not it’s possible to split things apart without breaking features or adding unnecessary complexity. This is where many teams get stuck. They know there are problems with their current structure. But they don’t understand what those problems are – much less how to fix them.

9 Things You Should Always Do When Pruning Your Product Tree are:

1. Always have a ‘working’ branch that is always deployable

2. Keep the trunk lean and mean, i.e., make it do as much as possible but nothing more

3. Make sure every feature has an isolated component that does only that feature’s things

4. Strive to keep all components less than 300 lines of code (LOC)

5. Avoid inter-component dependencies like the plague

6. Whatever you do, don’t change your mind about how to structure things just because you can!

7. Don’t shy away from using temporary hacks where needed until you’ve finished refactoring out what they’re there for

8. If something is hard to understand or feels wrong, it probably is so fix it.

9. If you do decide to change something, make sure it isn’t already implemented, otherwise revert the changes and start over.

Some Things You Should Always Do When Pruning Your Product Tree are:

• Bad abstractions are worse than no abstractions at all!
• Never ever commit code which doesn’t work or isn’t tested, unless it’s a bugfix!
• In case of doubt, always think of implementation before interface!
• Serialize your data structures as much as possible. But remember that JSON is slow and XML is slower by orders of magnitude!
• Always write tests for any code which needs them, preferably using TDD (though not necessarily). Because testing is important and it’s hard to test every use case manually. If nothing else then for regression tests!
• And above all else: Think before doing anything, especially if you are the only one who might ever read your code!
• Never change APIs unless it’s necessary, instead create new ones where possible along with deprecating old ones when needed!
• Keep adding features until your code is so complex that no one can understand it anymore. Then cut some of the features and rewrite them because at least one user wants to keep them.
• If you must delete functionality then announce it beforehand and give users time to adjust their workflow accordingly – don’t just delete stuff without warning for no good reason (or any reason)!
• Not using version control like driving without a seatbelt!
• Not posting to your blog like not wearing a helmet while biking!
• Using threads that you didn’t write yourself, they are evil and can bite you in the ass when using them wrong! So don’t use them unless you know what you’re doing (which usually means if someone else wrote it for you).
• Not leaving enough time to properly fix bugs before releasing new features or similar , so release often and without proper testing since users will be the ones finding all these bugs eventually anyway.

A lot of people are surprised to discover that there are formal techniques for managing product roadmaps. And even more, are shocked at the idea of managing your product trees. This may be because it sounds complicated, or because they’re not sure how to explain it beyond “we release frequently to our users, and then fix bugs that come up”.

Thus Pruning Your Product Tree is a series of articles that will explore the process and technique called ‘ Release To Users, Fix Bugs In Production ‘, better known as RUTF. We’ll begin with a look at how it works for software development teams and then expand into other areas where this model has been used successfully.

You likely are already familiar with the product roadmap, which outlines plans for the next six months to a year. For example, if you’re following an agile process, this would be your sprint backlog. A product tree looks similar to a roadmap, but instead of focusing on things that will happen in the future, it focuses on things that have happened in the past. Both of these are necessary for effective product management, and a product tree is a natural outgrowth of your roadmap.

Also read: Benefits of video marketing