The power of effective Decomposition - part 2

Before we explore the user stories and their acceptance criteria, let's start with a delightful analogy: the cake. Picture the cake in this post, composed of layers filled with delicious ingredients. Each layer in the cake represents a horizontal slice, and collectively, they make up the complete cake. In this case, our cake has several layers:

1. Cranberries in the top layer: This is the topmost layer of our cake, offering a sweet and tangy flavour.

2. White whipped cream layer: Below the cranberries, we have a layer of creamy, white wallpaper cream. It's cool and smooth, contrasting with the cranberries above.

3. Raspberry cream layer: Moving down, we reach the raspberry cream layer. It's light, and fluffy, and adds a fruity twist to the cake.

4. Fruits with ice cream layer: Beneath the raspberry whipped cream, we discover a layer filled with fruits and ice cream, adding layers of flavours and textures.

5. Caramel layer: Finally, at the bottom, we have the dessert caramel layer, providing a rich, caramelized sweetness that balances the entire cake.

Now, let's relate these layers to the concept of "vertical slices" in software development, particularly user stories:

Vertical slices in user stories

In the world of software development, our goal is to deliver value incrementally, much like building a cake layer by layer.

Each "vertical slice" of the cake represents a functional aspect or component of our software product.

When we refer to "vertical slices" in user stories, we mean that each user story represents a complete and independently functional piece of the software, similar to each layer in our cake.

Explaining a User Story as a Vertical Slice:

Imagine we're creating a cake delivery website.

A user story might read: "As a customer, I want to select my preferred cake flavour."

Think of this user story as a single layer of our cake. It's a standalone, functional piece that adds value on its own.

Acceptance criteria for this story could specify details like how the customer browses and chooses from flavours such as cranberry, white ice cream, raspberry cream, fruits with ice cream, and caramel.

The Beauty of Vertical Slices:

Just as savouring a single layer of cake is delightful, completing a user story brings value to our software product.

Over time, as we work through user stories slice by slice, our product gains robustness, akin to enjoying the entire cake layer by layer until it's fully relished.

So, while we explore user stories and their acceptance criteria, keep in mind that each one is like a vertical slice that contributes to our software's overall sweetness. Just as you wouldn't want to miss any layer of our cake, each user story adds its unique flavour to our software journey. ??

What are the user stories and acceptance criteria? ??

Let's break down the concept of user stories and acceptance criteria using the same cake approach: each layer of our cake represents a different flavour, and similarly, each user story represents a unique enhancement to the way the system behaves from the user's point of view. What a user hopes to accomplish when interacting with the system is similar to how they would want to enjoy each of our cake's many flavours.

User Story's approach:

As a... {persona or role},

Think of this as the guest who's about to eat a slice of our delicious cake. Who is this person, and what role do they play in our cake-eating journey?

I want to... {achieve a goal},

Now, think about the objective. What does this cake enthusiast want to do with our cake? It could be as simple as "I want to taste the raspberry cream layer."

So that... {customer value is realized}.

This part ties it all together. Why does our cake enthusiast want to taste the raspberry cream layer? Maybe because it adds a fruity twist and enhances the overall cake experience.

Acceptance Criteria's approach:

Just as we have expectations for each layer of our cake—its taste, texture, and appearance—acceptance criteria lay out the specifics of what we expect from the software.

Given... {describe the context or situation},

Think of this as setting the scene. It's like preparing the environment before you take a bite of cake. For example, "Given that I have a slice of the cake in front of me."

When... {specify the event or action that occurs},

This part focuses on the action that needs to happen. It's like describing the process of picking up the cake slice and taking a bite. For example, "When I take a forkful of the raspberry cream layer."

Then... {explain the expected outcome or result}."

Finally, it's time to describe what we expect to happen next. What should the user experience when they taste that layer of cake? For instance, "Then, I should experience a delightful burst of fruity flavour that complements the rest of the cake."

How can we break down user stories effectively?

We may divide user stories into smaller parts, much as we savour the layers of a cake, to ensure they're as lovely as each cake layer. Here's how we can accomplish it using different criteria like User Story Mapping and Splitting User Stories Patterns.

User Story Mapping

Let's simplify and explain how this supports vertical slicing:

User Persona: These are the different types of customers who want to order cakes through your website.

User Activity: These represent what these personas do on your website. It could be browsing cake options, customizing cakes, or placing orders for events.

User Task: Break down these activities into specific steps. For instance, the task of "placing an order," involves selecting a cake, specifying delivery details, and making payment.

Releases 1 and 2: These are different versions or phases of your website.

Release 1 may include core features like browsing and ordering cakes,

while Release 2 might introduce more advanced features like cake customization and order tracking.

In the case of the cake website, "vertical slicing" means that the development process is broken up into small,? valuable functional units that contain all aspects of the application.?This is made easier by user story mapping, which helps organise and order work features so that every element of functionality adds value and is implemented fully.

Splitting User Stories

Just like we enjoy the layers of a cake, we can split user stories into more manageable portions, ensuring they're as tasty as each cake layer. Here's how we can do it based on different factors:

1. Workflow steps: Think of our cake preparation process. We have steps like mixing, baking, decorating, and serving. Similarly, in the application, we can break a story like "Manage Customer Orders" into separate stories for each step, such as "Create Order" >> "Process Payment" >> "Prepare Order" >> "Deliver Order."
2. Operations (e.g., CRUD - Create, Read, Update, Delete): We have separate stories for creating, reading, updating, and deleting recipes.
3. Business rule variations: Imagine our cake delivery website offers discounts based on order quantity. We break it down into two stories: one for applying discounts to single cake orders and another for bulk orders.
4. Variations in data: If we allow the customisation of cakes with different ingredients, we create stories for customizing cake flavour, adding toppings, and selecting cake sizes. These stories cover different ways data can vary.
5. Data entry methods: Our cake website users input in various ways: typing manually, importing from existing recipes, or copying from others. We have stories for each method: manual entry, importing, and copying.
6. Major effort: Some tasks are big, like integrating a complex payment system. We split them into smaller stories, starting with integration and later focusing on the payment logic.
7. Simple/Complex: When a story gets too complicated, we divide it into simpler ones. For example, a complex user registration process becomes a few stories: basic registration, facial verification and profile customisation.
8. Defer performance: Sometimes, making things faster is a big thing. We might first create a story for the basic functionality and later work on optimising performance for real scope.
9. Break out a spike: When we're unsure or need to explore something technically, we create a "spike" story to research before diving into the main task.

Okay, guys, I'm tired and it's time for the conclusion: Thanks to this efficient decomposition, we can develop user stories that are in line with the idea of vertical slicing. This method guarantees that our software becomes more stable and recognised by users?with each release, similar to enjoying many layers of a tasty cake. Until we meet again bye!