Lesson 16: Project: Prototype an Innovation
App Lab | Maker Toolkit | Project
In this final project for the course, students team to develop and test a prototype for an innovative computing device based on the Circuit Playground. Using the inputs and outputs available on the board, groups will create programs that allow for interesting and unique user interactions.
This lesson is the culmination of Unit 6 and provides students an opportunity to build a Maker Toolkit project of their own from the ground up. This project is an opportunity to showcase technical skills, but they will also need to demonstrate collaboration, constructive peer feedback, and iterative problem solving as they encounter obstacles along the way. This project should be student-directed whenever possible, and provide an empowering and memorable conclusion to the final unit of CS Discoveries.
Warm Up (10 min)
Activity (80-200 min)
Wrap Up (30-60 min)
Students will be able to:
- Independently scope the features of a piece of software
- Prototype a physical computing device
- Implement a plan for developing a piece of software that integrates hardware inputs and outputs
For the Students
Warm Up (10 min)
Review Project Guide
Group: Place students into groups of 2-4 for this project. At your discretion you may choose to have students form larger groups or work independently.
Distribute: Provide a copy of Innovation Prototype - Project Guide to each group. As a class, review the different steps of the project and where they appear in the project guide. Direct students towards the Prototype An Innovation - Rubric so that they know from the beginning what components of the project you will be looking for.
Activity (80-200 min)
Define - Scope Innovation
Brainstorm: Students should spend the first 15-20 minutes brainstorming ideas for innovative devices built around the features of the Circuit Playground. Encourage students to review their prior work in this unit as well as the real world innovations they researched earlier for inspiration.
Prepare - Complete Project Guide
Distribute: Make available any construction materials that students may need for building their prototypes. While the focus of this step isn't to build the actual prototype, having these materials available can help with the brainstorming process.
Circulate: Once students have discussed their ideas for the project they should complete the Innovation Prototype - Project Guide. While this should be a fairly familiar process, encourage students to make each component as clear and detailed as they can at this point. Planning ahead can help them identify issues in their plan before they'll need to make more significant changes to their code or physical device. Encourage students to use additional paper to sketch out screens for their app or additional views of their physical device.
Try - Develop Prototypes
Distribute: Make available the physical prototyping materials (such as cardboard, tape, scissors, etc). Let students know that, just as we used paper prototypes to quickly test software ideas, hardware developers often used cheap materials such as cardboard and tape to quickly iterate on the design of physical devices. While not all student ideas may require a physically prototyped component, you should encourage students to consider how the shape and design (or form factor) or their innovation could impact its usability.
Transition: Depending on the nature of their innovations, students may need to spend some time building the physical components of their projects before moving online. When students are ready to program, they can transition to Code Studio. These levels provide some guidance on how students may go about implementing their projects, but are left quite open to allow for a broad range of ideas. If they wish, students can work in a different order than the one suggested in these levels.
Reflect - Peer Review
If you have the time for it, this can be a good opportunity to pull in the user testing process that students learned in Unit 4.
Group: Pair up groups to review each other's projects.
Distribute: Give each student a copy of Prototype An Innovation - Peer Review. Students should spend 15 minutes reviewing the other group's project and filling out the peer review guide.
Iterate - Revise Prototypes
Circulate: Students should complete the peer review guide's back side where they decide how to respond to the feedback they were given. They should then use that feedback to improve their game.
Wrap Up (30-60 min)
Celebrate: As this is the culminating project for the entire course, consider going big with this share out. Bring in parents and administrators, or even host a after school event to provide students with a real audience to share their accomplishments with.
Share: Give students a chance to share their innovations, either within the class or to a broader audience. If you choose to let students do a more formal presentation of their projects the project guide provides students a set of components to include in their presentations including:
- The original innovation they set out to build
- A description of the programming process including at least one challenge they faced and one new feature they decided to add
- A description of the most interesting or complex piece of code they wrote
- A live demonstration of the actual innovation
Send students to Code Studio to complete their reflection on their attitudes toward computer science. Although their answers are anonymous, the aggregated data will be available to you once at least five students have completed the survey.
Record and edit a short video to pitch your innovation.
Using Web Lab, design a website to market your innovation.
Have students design a crowdfunding campaign (along the lines of Kickstarter or Indiegogo) for their innovations. This could include:
- Design mockups for the final product
- A rough cost analysis for production
- A short pitch video
- Design Your Prototype
- Student Overview
Prototype your own innovation
Now that you have all the skills you need, it's time to make your own game!
With a partner or team, brainstorm some different physical devices you could prototype. You can build on the programs that you've already made in previous lessons, innovative devices that you've seen in the real world, or any wild ideas you can come up with.
Once you have settled on an idea with your team, fill out the Project Guide with the sketches of the physical components of your device, inputs and outputs that you'll need, and plans for what information you'll need to process.
To help kick off your brainstorming, check out these example projects:
Automatic Night Light
Using conductive thread, LEDs, and the light sensor, create a decorative piece of wall art the becomes a night light when the lights go out. This one is designed to look like flickering fireflies.
Design a musical instrument that can be played any way you like, using sensors or buttons for input. In this case we created five new buttons using conductive copper tape, though you could also use aluminum foil or any other conductive material.
Make a game! This one uses an array to store the different commands, which are picked at random each time you correctly follow the instructions on screen.
Designing the User Interface
Before worrying about the code for your program, start by laying out the user interface. As you add elements in Design Mode, make sure to give everything a meaningful ID. Even if you don't plan on accessing an element with code, making sure that all of your IDs are descriptive will help make your program more readable and easier to program.
Wiring Up the UI
With your user interface in place, you can now add event handlers for your interface elements. At this point you may want to just include
console.log() commands to make sure that your events are working as expected - you can add the functional code later one.
Board Input Events
Now you can add the events which will take input from the board. Again, feel free to just use
console.log() statements at this point to ensure that your events are working.
If you haven't already, use some of the output elements on the board to communicate useful information to the user.
As you continue to work through your program, look for patterns that can be abstracted into functions. Can you find code that is repeated multiple places, or chunks of code that could be better understood of given a name? Don't forget that you can use parameters to write functions for repeated code that is mostly the same, but varies a bit (such as setting color on multiple LEDs).
Add any finishing touches still needed to make your innovation awesome. If you have time, test out your innovation with some potential users to gather feedback and find opportunities for improvement. When you're totally finished, click the "Submit" button to turn it in!
CSTA K-12 Computer Science Standards (2017)
AP - Algorithms & Programming
- 2-AP-10 - Use flowcharts and/or pseudocode to address complex problems as algorithms.
- 2-AP-11 - Create clearly named variables that represent different data types and perform operations on their values.
- 2-AP-12 - Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
- 2-AP-13 - Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
- 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.
- 2-CS-02 - Design projects that combine hardware and software components to collect and exchange data.
- 2-CS-03 - Systematically identify and fix problems with computing devices and their components.