Lesson 15: Improving and Iterating
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.
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.
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.
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.
Warm Up (5 min)
Activity 1 (30 min)
Activity 2 (30 - 90 min)
Wrap Up (15 min)
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
- Print one copy of the activity guide for each team
- Set out sticky notes and poster paper for each team
Heads Up! Please make a copy of any documents you plan to share with students.
For the Students
- App User Testing Analysis - Activity Guide
- 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
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.
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)
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.
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.
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
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.
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)
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?
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.
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.
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.
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.
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.