Teach students that thin slices are best

Thin slices speed up learning, and are less challenging

Thin slices have so many good aspects to them when building applications. You are focusing on a small number of things, so it’s easier to keep track of them. The team can coordinate their collaboration more easily. The work is less complication, so it should be more focused too. It should also take less time, so the feedback will be faster too.

All of this is good stuff.

The parts that I don’t understand are these two questions:

• Why is it so hard to teach this approach?
• Why do students always try to do thicker slices?

The two are part of the same issue

I think students have a hard time decomposing features into smaller, less capable versions. In assigning them larger applications than they could easily do on their own, we are already asking them to stretch their abilities. They are still exploring the application idea, so breaking it into different layers is an extra step that might be conceptually harder.

For example, if they are putting in an authentication system for their application, then many examples I found online for python point to more complex scenarios with REST APIs, OAuth, and other systems. I had to know to look for one with basic http authentication. The thin, simple version was hard to find.

This means it is harder for students to realise that they can make examples simpler than the scenarios they find online, and in the text books. we need to create exercises to show them how to break up some of these scenarios so that they know how to explore creating thin slices of their applications.

Teaching application decomposition into thin slices

I like to use a pizza store example for teaching students about slicing applications into thin slices. No, the puns weren’t intentional, by the way 😉 They just are part of our weird language we call English.

Anyways, assume that a friend is wondering if his pizzas are good enough to start a local business. He would like your team to build a web site to test his idea. If he sells enough, then he knows he can probably start a business that can grow.

Your job is to build the simplest site possible so that he can test this idea. The site only needs to take orders from customers, who then come to his place to collect the pizza. Keeping it constrained to this seems hard to students.

Students want to add too many things because they immediately think of other pizza places and the variety they offer in their online menus. Tell them to forget about this. Ask them to focus on the simplest site they could build in a short one, or two week sprint.

After they have explored the idea and come up with some basic stories I usually find that I tell them to through most of them away as they are too big. They are concerned about databases, menu options, account creation, and delivery details. Yes, even if delivery isn’t an option. I tell them this should be simpler.

The basic site to test the idea could be a static page with only two options for pizza in a nine inch size: cheese, and pepperoni. The price is fixed, and you can either make it only via PayPal, or cash as you prefer. This is enough.

By keeping the sprint small we can test application assumptions. We can also do it quicker than if we add more detailed features. Those can all come later.

Later you can add more details as I outlined in a previous post talking about estimating the pizza store.

Use this in your classroom

Add the pizza start up to one of your exercises in software engineering. I use it when talking about estimating as noted in the other post, and also in slicing in general. The example is cross-cultural, so works well in international cohorts.

---