It's Alive!
Experience: 1st year, 4th quarter
Practice: Recognizing and defining computational problems, Creating computational artifacts, Testing and refining computational artifacts, and Communicating about computing
Concept: Algorithms, Control, Modularity, and Program Development
Length: 60+
Overview and Purpose
Coders learn how to add costumes to a sprite to simulate lifelike movements or animations in a scene or short story. The purpose of this project is to reinforce understanding of the image editor while learning how to better simulate motion/animations when a sprite has a limited number of costumes.
Lesson plan
Overview videoObjectives and Standards
Process objective(s):
Statement:
- I will learn how to create several new costumes in a sprite to simulate motion.
- I will learn how to use a variety of blocks to simulate a sprite’s motion.
Question:
- How can we create several new costumes in a sprite that are used to simulate motion?
- How can we use a variety of blocks to simulate a sprite’s motion?
Product objective(s):
Statement:
- I will create a project that simulates lifelike motion of a sprite (or several sprites).
Question:
- How can we create a project that simulates lifelike motion of a sprite (or several sprites)?
Main standard(s):
1B-AP-10 Create programs that include sequences, events, loops, and conditionals
- Control structures specify the order (sequence) in which instructions are executed within a program and can be combined to support the creation of more complex programs. Events allow portions of a program to run based on a specific action. For example, students could write a program to explain the water cycle and when a specific component is clicked (event), the program would show information about that part of the water cycle. Conditionals allow for the execution of a portion of code in a program when a certain condition is true. For example, students could write a math game that asks multiplication fact questions and then uses a conditional to check whether or not the answer that was entered is correct. Loops allow for the repetition of a sequence of code multiple times. For example, in a program that produces an animation about a famous historical character, students could use a loop to have the character walk across the screen as they introduce themselves. (source)
1B-AP-13 Use an iterative process to plan the development of a program by including others' perspectives and considering user preferences.
- Planning is an important part of the iterative process of program development. Students outline key features, time and resource constraints, and user expectations. Students should document the plan as, for example, a storyboard, flowchart, pseudocode, or story map. (source)
Reinforced standard(s):
1B-AP-11 Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process.
- Decomposition is the act of breaking down tasks into simpler tasks. For example, students could create an animation by separating a story into different scenes. For each scene, they would select a background, place characters, and program actions. (source)
1B-AP-12 Modify, remix, or incorporate portions of an existing program into one's own work, to develop something new or add more advanced features.
- Programs can be broken down into smaller parts, which can be incorporated into new or existing programs. For example, students could modify prewritten code from a single-player game to create a two-player game with slightly different rules, remix and add another scene to an animated story, use code to make a ball bounce from another program in a new basketball game, or modify an image created by another student. (source)
1B-AP-15 Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended.
- As students develop programs they should continuously test those programs to see that they do what was expected and fix (debug), any errors. Students should also be able to successfully debug simple errors in programs created by others. (source)
1B-AP-17 Describe choices made during program development using code comments, presentations, and demonstrations.
- People communicate about their code to help others understand and use their programs. Another purpose of communicating one's design choices is to show an understanding of one's work. These explanations could manifest themselves as in-line code comments for collaborators and assessors, or as part of a summative presentation, such as a code walk-through or coding journal. (source)
Practices and Concepts
Main practice(s):
Practice 3: Recognizing and defining computational problems
- "The ability to recognize appropriate and worthwhile opportunities to apply computation is a skill that develops over time and is central to computing. Solving a problem with a computational approach requires defining the problem, breaking it down into parts, and evaluating each part to determine whether a computational solution is appropriate." (p. 77)
- P3.2. Decompose complex real-world problems into manageable subproblems that could integrate existing solutions or procedures. (p. 77)
Practice 5: Creating computational artifacts
- "The process of developing computational artifacts embraces both creative expression and the exploration of ideas to create prototypes and solve computational problems. Students create artifacts that are personally relevant or beneficial to their community and beyond. Computational artifacts can be created by combining and modifying existing artifacts or by developing new artifacts. Examples of computational artifacts include programs, simulations, visualizations, digital animations, robotic systems, and apps." (p. 80)
- P5.2. Create a computational artifact for practical intent, personal expression, or to address a societal issue. (p. 80)
- P5.3. Modify an existing artifact to improve or customize it. (p. 80)
Reinforced practice(s):
Practice 6: Testing and refining computational artifacts
- "Testing and refinement is the deliberate and iterative process of improving a computational artifact. This process includes debugging (identifying and fixing errors) and comparing actual outcomes to intended outcomes. Students also respond to the changing needs and expectations of end users and improve the performance, reliability, usability, and accessibility of artifacts." (p. 81)
- P6.1. Systematically test computational artifacts by considering all scenarios and using test cases." (p. 81)
- P6.2. Identify and fix errors using a systematic process. (p. 81)
Practice 7: Communicating about computing
- "Communication involves personal expression and exchanging ideas with others. In computer science, students communicate with diverse audiences about the use and effects of computation and the appropriateness of computational choices. Students write clear comments, document their work, and communicate their ideas through multiple forms of media. Clear communication includes using precise language and carefully considering possible audiences." (p. 82)
- P7.2. Describe, justify, and document computational processes and solutions using appropriate terminology consistent with the intended audience and purpose. (p. 82)
Main concept(s):
Modularity
- "Modularity involves breaking down tasks into simpler tasks and combining simple tasks to create something more complex. In early grades, students learn that algorithms and programs can be designed by breaking tasks into smaller parts and recombining existing solutions. As they progress, students learn about recognizing patterns to make use of general, reusable solutions for commonly occurring scenarios and clearly describing tasks in ways that are widely usable." (p. 91)
- Grade 5 - "Programs can be broken down into smaller parts to facilitate their design, implementation, and review. Programs can also be created by incorporating smaller portions of programs that have already been created." (p. 104)
Reinforced concept(s):
Algorithms
- "Algorithms are designed to be carried out by both humans and computers. In early grades, students learn about age-appropriate algorithms from the real world. As they progress, students learn about the development, combination, and decomposition of algorithms, as well as the evaluation of competing algorithms." (p. 91)
- Grade 5 - "Different algorithms can achieve the same result. Some algorithms are more appropriate for a specific context than others." (p. 103)
Control
- "Control structures specify the order in which instructions are executed within an algorithm or program. In early grades, students learn about sequential execution and simple control structures. As they progress, students expand their understanding to combinations of structures that support complex execution." (p. 91)
- Grade 5 - "Control structures, including loops, event handlers, and conditionals, are used to specify the flow of execution. Conditionals selectively execute or skip instructions under different conditions." (p. 103)
Program Development
- "Programs are developed through a design process that is often repeated until the programmer is satisfied with the solution. In early grades, students learn how and why people develop programs. As they progress, students learn about the tradeoffs in program design associated with complex decisions involving user constraints, efficiency, ethics, and testing." (p. 91)
- Grade 5 - "People develop programs using an iterative process involving design, implementation, and review. Design often involves reusing existing code or remixing other programs within a community. People continuously review whether programs work as expected, and they fix, or debug, parts that do not. Repeating these steps enables people to refine and improve programs." (p. 104)
Vocabulary
Iterative
- Involving the repeating of a process with the aim of approaching a desired goal, target, or result (source)
- Iteration is a single pass through a group of instructions. Most programs contain loops of instructions that are executed over and over again. The computer iterates through the loop, which means that it repeatedly executes the loop. (source)
- The computational practice of developing a little bit, then trying it out, then developing some more. (source)
Modularity
- The characteristic of a software/web application that has been divided (decomposed) into smaller modules. An application might have several procedures that are called from inside its main procedure. Existing procedures could be reused by recombining them in a new application (source)
Parallel
- Refers to processes that occur simultaneously. Printers and other devices are said to be either parallel or serial. Parallel means the device is capable of receiving more than one bit at a time (that is, it receives several bits in parallel). Most modern printers are parallel. (source)
- The computational concept of making things happen at the same time. (source)
Remix
- The process of creating something new from something old. Originally a process that involved music, remixing involves creating a new version of a program by recombining and modifying parts of existing programs, and often adding new pieces, to form new solutions. (source)
- A creative work that is derived from an original work (or from another remix). A remix typically introduces new content or stylistic elements, while retaining a degree of similarity to the original work. (source)
Storyboard
- Like comic strips for a program, storyboards tell a story of what a coding project will do and can be used to plan a project before coding.
More vocabulary words from CSTA
Connections
Integration
- Potential subjects: History, language arts, media arts, physical education, science, social studies
- Example(s): This project could be modified to animate a historical, contemporary, or fictional sprite in a specific time period or location. For example, animating a sprite or scene from a story read in class. As another example, animating a historical figure or event from a time period and culture coders are learning about. Click here to see other examples and share your own ideas on our subforum dedicated to integrating projects or click here for a studio with similar projects.
Vocations
- Scientists and researchers often create models or simulations of environments in order to better understand the processes and systems at play. In this project we are creating a fictional model or simulation of a sprite’s movement. Click here to visit a website dedicated to exploring potential careers through coding.
