Unit4
Ch. 1
1
2
3
4
5
6
7
Ch. 2
8
9
10
11
12
13
14
15
16

Lesson 15: Improving and Iterating

Overview

Teams have at this point developed an app prototype that has gone through multiple iterations and rounds of user testing. With the information and guidance gained from the last round of user testing, each student has the opportunity to plan for and implement improvements to the team app. Depending on the time you have available, and student interest, you can run the cycle of testing and iteration as many times as you see fit.

Purpose

While it is tempting to make this lesson a deeper dive into programming for all students, encourage each student to find the elements of app design that interest them and focus on that for their personal improvements. While improvement can mean adding programmatic functionality, in can also mean a more eye-catching design, more informative text copy, better uniformity of iconography, or any number of other non-programming related features.

At this point in the development process, you can choose to spend as much time as you like iterating and testing. There is no further time budgeted for testing after this iteration, but feel free to use the previous two lessons as a guideline for cycling through further iterations.

Assessment Opportunities

  1. Analyze user feedback and test results on a computational artifact

    Activity Guide: The left side of the T-chart on the first page should include at least four descriptions of things that happened in the test, and the right side should list a reasonable interpretation of the descriptions.

  2. Categorize and prioritize the issues according to impact and ease of implementation

    Student poster: The chart should include several improvements to the app, categorized according to urgency and ease of implementation.

Agenda

Lesson Modifications

Warm Up (5 min)

Activity 1 (30 min)

Activity 2 (30 - 90 min)

Wrap Up (15 min)

Extension Activities

View on Code Studio

Objectives

Students will be able to:

  • Analyze user feedback and test results on a computational artifact
  • Categorize and prioritize the issues according to impact and ease of implementation

Preparation

  • Print one copy of the activity guide for each team
  • Set out sticky notes and poster paper for each team

Links

Heads Up! Please make a copy of any documents you plan to share with students.

For the Students

Vocabulary

  • Bug - Part of a program that does not work correctly.
  • Feature - An individual functional element of a software item, such as the ability to do something new, work across multiple platforms, or perform more efficiently

Support

Report a Bug

Forum

Teaching Guide

Lesson Modifications

Attention, teachers! If you are teaching virtually or in a socially-distanced classroom, please read the full lesson plan below, then click here to access the modifications.

Warm Up (5 min)

Bugs and Features

Prompt: Based on your user testing, what are some of the bugs you discovered in your apps? Keep track of these on the board.

Teaching Tip

Bugs are often easier for students to identify from feedback than features. Encourage students to really consider how users might have assumed the app should work, or places where they needed help or direction to successfully navigate.

Discuss: You likely found plenty of bugs, but what other feedback did you get from users? Help they class identify feedback that implies the need for new functionality. We're going to call these [feature] requests. Today teams will be working to identify the bugs and features discovered through testing, prioritize them, and plan for improvement.

Activity 1 (30 min)

Teaching Tip

Reducing Printed Materials: This Activity Guide can be completed online or as a journal activity.

Distribute: Poster paper, sticky notes, and a copy of the activity guide for each team.

App User Testing Analysis

Interpreting User Feedback

Teams start by completing a T chart that will help connect specific user testing observations to the potential bugs or missing features they reveal. This information will be the basis of a brainstorming session to create list of bugs found in the existing app and features the team would like to add to our next iteration of the app in the next activity.

Teaching Tip

It's tempting to focus solely on bugs that are the cause of, or can be solved with, code. Remind students that there are many roles and skillsets on a software development teams, and not all bugs and features are dealt with by programmers. Inconsistent color, confusing text, and counterintuitive layouts are all potential bugs that are important to deal with.

This is an opportunity to let students with other skillsets shine and make a strong contribution to their apps, so make the extra effort to help highlight those students.

Brainstorming Session

Once teams have organized all of their feedback into the T chart, they can move into the brainstorming phase. Fill out a sticky note for each bug or feature identified.

The top of the sticky note should say BUG or FEATURE. The middle of the sticky note should be a description of what the bug or features is - including steps to reproduce the issue if necessary. The bottom of the sticky should have a quick estimate of how long (in minutes) it will take to fix this bug or implement this feature. Let students know that they will have a chance to refine this estimate later in the lesson - all that is necessary right now is a ballpark estimate.

Bug and Feature Analysis

On a sheet of poster paper, draw the two charts on page two of this activity guide.

For each of the sticky notes generated in the previous phase, discuss whether it is urgent or not, and whether it seems to be easy or difficult to implement. Based on that discuss, place the sticky in the appropriate quadrant.

Discuss: Now that you have your bugs and features categorized, which of the four categories should be the first that you tackle? Which should be the last?

Activity 2 (30 - 90 min)

Fixing Bugs and Adding Features

Teaching Tip

This activity can take as much or as little time as you want, as long as each student is allowed the time to implement at least one fix or feature. You may even consider returning to this activity later in the year when you have some free time - distance from a problem can add useful perspective.

Tracking Progress

As students move to Code Studio to begin iterating on their programs, they will use the To Do, Doing, Done chart at the bottom of their poster to track the state of each bug and feature. While each student will implement only a select set of these in their own app, the group as a whole will be able to explore a wide variety of features through several versions of the same app. Each time a student tackles a new task they should first move the sticky from To Do to Doing, and then finally to Done when they have finished implementation. You can use this chart for an at-a-glance view of how each team is progressing.

Wrap Up (15 min)

Journal

Prompt: Have students reflect on their development of the five practices of CS Discoveries (Problem Solving, Persistence, Creativity, Collaboration, Communication). Choose one of the following prompts as you deem appropriate.

  • Choose one of the five practices in which you believe you demonstrated growth in this lesson. Write something you did that exemplified this practice.

  • Choose one practice you think you can continue to grow in. What’s one thing you’d like to do better?

  • Choose one practice you thought was especially important for the activity we completed today. What made it so important?

Extension Activities

Merging New Features

In this phase of iteration each student has been working on their own copy of the team's app. If you have the time available, consider having teams reconvene to merge their updates into one master app. This can be pretty tricky, particularly when students may have added conflicting code or design elements, but it's an excellent challenge to build problem solving skills and strengthen team dynamics.

View on Code Studio

Implementing Features and Fixes Individually

Because App Lab is difficult for large groups of students to work on simultaneously, we have students work on implementing features and fixes individually or in pairs. The benefit of this approach is that it allows the team as a whole to explore more potential features than if they were working all on the same app, but it also means that each team member's app will diverge further from the others as more changes are made.

As an optional extension activity you could provide a day of work for students to share their changes with each other and attempt to integrate all of the added features into a single app.

Keeping Track of Changes

The more features students add to their app, the more likely they are to introduce new unforeseen bugs. To ensure that students always keep the most recent working copy of their app, encourage them make a remix before adding any new features. Make sure students leave the remix alone and return to this level to do their programming - this will ensure that when they go to submit their app for your review it is the most recent version.

View on Code Studio

Improving and Iterating

You've put your app in front of users, gathered feedback, and identified bugs and new features - time to do something about it.

Do This

Each team member is going to implement select features and bug fixes on their own version of the team's app. Start by selecting a sticky note from the To Do column of your team's chart and moving it to the Doing column. For each sticky you tackle:

  • Add a comment to the top of your program describing the feature or bug fix you are implementing
  • Work on your iteration until it works. Try to stay focused on only the single feature or bug that you've selected.
  • When done, move your sticky to the Done column, pick a new one, and start the process over.

Standards Alignment

View full course alignment

CSTA K-12 Computer Science Standards (2017)

AP - Algorithms & Programming
  • 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  • 2-AP-14 - Create procedures with parameters to organize code and make it easier to reuse.
  • 2-AP-15 - Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
  • 2-AP-16 - Incorporate existing code, media, and libraries into original programs, and give attribution.
  • 2-AP-17 - Systematically test and refine programs using a range of test cases.
  • 2-AP-18 - Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  • 2-AP-19 - Document programs in order to make them easier to follow, test, and debug.
CS - Computing Systems
  • 2-CS-01 - Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
DA - Data & Analysis
  • 2-DA-09 - Refine computational models based on the data they have generated.
IC - Impacts of Computing
  • 2-IC-22 - Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.