Skip to content
Home » Blog Posts » Teach students to grow thin slices into features

Teach students to grow thin slices into features

Arrange delivery of thin slices into a whole feature; show your work and be patient

Last week I mentioned that teaching students to think in term of thin slices. By developing this way, they can more easily create bigger components out of thin slices of work. This speeds delivery, and lets clients validate work earlier.

This week I want to elaborate on that with deeper examples of how such slices could be formed. We’ll stick with the polar bear example, and the pizza store to show different types of work. The polar bear site focuses on sharing data, while the pizza store aims to sell pizzas.

In both examples we aim to do the following as we start the application. We want to deploy early to ensure we can show our work to others, and validate assumptions about deployment. This is most easily done when the app is small. If we want we can set up a CI/CD pipeline too.

In both examples aim to make it even smaller than your students expect. No, even smaller when you start.

Photo by Ivan Torres on Unsplash

The pizza store starts small

The pizza store should be the simplest thing you can imagine. Now make it smaller.

The smallest pizza store could be a page with a menu, and a mobile number. The page lists one or two types of pizza: cheese, and maybe pepperoni, or whatever your favourite is, which comes in one size: 9 inch. You only take phone orders, and customers pay via PayPal. The customers also collect the pizza from you.

You’ll notice, there is no form, there is no database. Customers do not have a profile, or have options for size, or extra cheese. All of that comes later.

This simple version can be added to slice by slice like a pizza. The next slices could be:

  • Add photos/images to the order/home page to show your wonderful pizzas.
  • Add extra toppings to the order
  • Email ordering instead of phone orders. Create a form, which sends an email with the order when the customer clicks ‘submit’. The ‘reply’ screen displays confirmation that the email was sent, and says ‘ thanks for your oder of … . You can collect your order in 30 minutes at …’.

From here we could then start to add a database, and customer accounts, assuming that we’re still in business and the repeat orders. There is no point adding customer accounts, if we are not delivering orders, and if we don’t have repeat customers. Food trucks don’t do customer accounts, and delivery. You have to go to them. This pizza store could be the same: If you want our pizza, you make the effort, and come to us.

The polar bear site tells you about the bears

The polar bear site could be simpler than it is in the example I linked to last time. That one is more complicated as it was designed to show how to build database driven web applications. If the goal is thin slices, then we can make it simpler when we start.

The simplest polar bear site starts without the database. The simplest version starts with a template of the page we want to display as a list in the browser. There is only a view method that calls the template html page with some hard coded bear data so that we can see what the page will look like.

This lets us deploy and validate assumptions about what is useful. From here we can add more thin slices such as:

  • A model bear and data hand loaded into the sqlite3 database. The view now calls this and passes the data to the template.
  • A script to read the excel file and load it into the database using the model. The template can now display this data.
  • Add pagination to the template html page.

From here we can now add the second model for each sighting of a bear, and grow the application. We can also add maps, showing where bears were tagged, and visual charts all done slice by slice.

Teach students to think slice by slice

This should be enough to see that anything can be made smaller. When it’s smaller, then the component can be done thin slice by thin slice. You can keep encouraging your students to use this approach by always asking them ‘can it be smaller?’ or ‘just do the web page with some hard coded data, add the database in another slice’.

By doing this they will integrate their work more frequently, and confirm the parts work as expected. With only a few things being new in each slice it will be easier to debug errors, and they will quickly be able to add tests too so that each part is confirmed and ready for deployment. More small things also means more tasks completed, and that warm fuzzy feeling they get with each successful addition to their app.

This post is part of a project pulling together my materials and ideas about Teaching Team Collaboration: the Human-Side of Software Development for software development to students.

If you’d like to be notified of future posts, then please sign up for more using the adjacent form. When you sign up, then I’ll send you a free copy of the collaboration rules as a PDF from the book. You can also follow me on LinkedIn

The ideas above are from my book 101+ Ideas to Improve Team Collaboration, which covers all of these little things that students can do to improve their collaboration.

Cookie Consent with Real Cookie Banner