At the third visit, your clients use a real, running version of your app for the first time. As at the second visit, your job is to watch and listen. See Preparing to Share Your Ideas: the missions, taking turns, and “don’t rescue” all still apply.
What “working” means this time
You have had several classes to build, and you chose what to build. Your app will not be finished, and it does not need to be. Whatever runs, your clients try; whatever does not, they try on paper. The visit is most useful when:
- Some path through the app runs from start to finish, so each child can choose, tap, answer, and see what happens.
- Your procedure runs on your list somewhere a child reaches, so you can watch what they make of its output.
- Everything else can still be paper. Screens you have not built yet can be frames on your storyboard from the last visit. A child taps the real app, then you point to the next frame. That is normal.
- Looks can wait. Plain buttons and default fonts are fine. Big enough to tap is not optional: see Designing for Young Users.
If part of your app is not running yet, test that part on paper. Tell me before we leave.
Before we leave
What is different about a real app
A real app shows things paper cannot. Watch for:
- Waiting. Does the child know something is happening? Do they tap again, and again?
- Taps that do nothing. Where do they tap that is not a button?
- Wrong answers and mistakes. What does your app do when a child does something unexpected? Is it forgiving?
- Reading. Do they read the words on the screen, or guess? Do they ask you to read them?
- Your procedure’s output. Is what appears after they choose what they expected? Does it ever show nothing at all?
Taking turns
One child uses the device at a time while the others watch. You sit beside them, hold nothing, and say as little as possible; jot notes between turns. Nobody touches the device while a child is using it, unless the app has frozen. Between turns, go back to the start screen so every child starts from the same place.
Don’t rescue
When a child gets stuck, wait. Count to ten in your head. Then ask “What do you think you should do?” Only if they are really unhappy, help, and write down exactly where it happened. That spot is the most useful note on your page.
Your feedback sheet
Use the sheet I provide:
| Who (first name) | Mission | What they did | What the app did | What they said | Where they got stuck | Their ideas |
|---|
First names only, never a last name. No photos, and no screen recordings, of the children or of the app while a child is using it.
At the end, ask the closing questions from How to close. Do not promise a feature or a date.
Before we leave LDPS, take five minutes to fill in anything you remember that is not on the sheet yet.
Curriculum connection
CRD-1.A
Explain how computing innovations are improved through collaboration.
CRD-1.A.1 A computing innovation includes a program as an integral part of its function.
CRD-1.A.2 A computing innovation can be physical (e.g., self-driving car), nonphysical computing software (e.g., picture editing software), or a nonphysical computing concept (e.g., e-commerce).
CRD-1.A.3 Effective collaboration produces a computing innovation that reflects the diversity of talents and perspectives of those who designed it.
CRD-1.A.4 Collaboration that includes diverse perspectives helps avoid bias in the development of computing innovations.
CRD-1.A.5 Consultation and communication with users are important aspects of the development of computing innovations.
CRD-1.A.6 Information gathered from potential users can be used to understand the purpose of a program from diverse perspectives and to develop a program that fully incorporates these perspectives.
Link to originalCRD-2.E
Develop a program using a development process.
CRD-2.E.1 A development process can be ordered and intentional, or exploratory in nature.
CRD-2.E.2 There are multiple development processes. The following phases are commonly used when developing a program:
- investigating and reflecting
- designing
- prototyping
- testing
CRD-2.E.3 A development process that is iterative requires refinement and revision based on feedback, testing, or reflection throughout the process. This may require revisiting earlier phases of the process.
CRD-2.E.4 A development process that is incremental is one that breaks the problem into smaller pieces and makes sure each piece works before adding it to the whole.
Link to originalCRD-2.F
Design a program and its user interface.
CRD-2.F.1 The design of a program incorporates investigation to determine its requirements.
CRD-2.F.2 Investigation in a development process is useful for understanding and identifying the program constraints, as well as the concerns and interests of the people who will use the program.
CRD-2.F.3 Some ways investigation can be performed are as follows:
- collecting data through surveys
- user testing
- interviews
- direct observations
CRD-2.F.4 Program requirements describe how a program functions and may include a description of user interactions that a program must provide.
CRD-2.F.5 A program’s specification defines the requirements for the program.
CRD-2.F.6 In a development process, the design phase outlines how to accomplish a given program specification.
CRD-2.F.7 The design phase of a program may include:
Link to original
- brainstorming
- planning and storyboarding
- organizing the program into modules and functional components
- creation of diagrams that represent the layouts of the user interface
- development of a testing strategy for the program