Lesson Summary


Students will define, design and implement a programming project: a miniature version of the Create Performance Task. They will create presentations and share with groups the projects they developed and how their project used abstractions.


  • Students will complete a miniature version of the Create Performance Task.


Session 1:

  1. Presentation  (5 min) Students are introduced to the Create Task.

  2. Activity (15 min) Students select a small programming project to model the Create Task.

  3. Activity (10 min) Students identify an algorithm to use in their program and share within tabe groups.

  4. Activity (10 min) Students identify an an abstraction to use in their program.

  5. Wrap Up (5 min) Students share the algorithms and abstractions they will use with the class.


Session 2:

1. Journal (2 min) - What is your plan for today for the development of your project? What abstractions do you plan on using in your project?

2. Activity (43 min) - Students complete implementing their projects.

3. Journal (5 min) - Reflection. What abstractions did you use in your project?

Session 3:

1. Getting Started (5 min) - Students individually respond to three prompts about their projects.

2. Activity (20 min) - Students prepare one minute presentations of their projects.

3. Presentations (15 min) - Students present their project to table groups.

4. Wrap Up (5 min) - Students create exit slips with any questions about the Create Task.

Learning Objectives

CSP Objectives

Big Idea - Creativity
  • EU 1.1 - Creative development can be an essential process for creating computational artifacts.
    • LO 1.1.1 - Apply a creative development process when creating computational artifacts. [P2]
      • EK 1.1.1A - A creative process in the development of a computational artifact can include, but is not limited to, employing nontraditional, nonprescribed techniques; the use of novel combinations of artifacts, tools, and techniques; and the exploration of personal curiosities.
  • EU 1.2 - Computing enables people to use creative development processes to create computational artifacts for creative expression or to solve a problem.
    • LO 1.2.1 - Create a computational artifact for creative expression. [P2]
      • EK 1.2.1B - Creating computational artifacts requires understanding of and use of software tools and services.
    • LO 1.2.4 - Collaborate in the creation of computational artifacts. [P6]
      • EK 1.2.4D - Effective collaboration strategies enhance performance.
      • EK 1.2.4E - Collaboration facilitates the application of multiple perspectives (including sociocultural perspectives) and diverse talents and skills in developing computational artifacts.
Big Idea - Abstraction
  • EU 2.2 - Multiple levels of abstraction are used to write programs or create other computational artifacts.
    • LO 2.2.1 - Develop an abstraction when writing a program or creating other computational artifacts. [P2]
    • LO 2.2.2 - Use multiple levels of abstraction to write programs. [P3]
Big Idea - Algorithms
  • EU 4.1 - Algorithms are precise sequences of instructions for processes that can be executed by a computer and are implemented using programming languages.
    • LO 4.1.1 - Develop an algorithm for implementation in a program. [P2]
      • EK 4.1.1A - Sequencing, selection, and iteration are building blocks of algorithms.
      • EK 4.1.1B - Sequencing is the application of each step of an algorithm in the order in which the statements are given.
      • EK 4.1.1C - Selection uses a Boolean condition to determine which of two parts of an algorithm is used.
      • EK 4.1.1D - Iteration is the repetition of part of an algorithm until a condition is met or for a specified number of times.
      • EK 4.1.1E - Algorithms can be combined to make new algorithms.
      • EK 4.1.1F - Using existing correct algorithms as building blocks for constructing a new algorithm helps ensure the new algorithm is correct.
      • EK 4.1.1G - Knowledge of standard algorithms can help in constructing new algorithms.
      • EK 4.1.1H - Different algorithms can be developed to solve the same problem.
      • EK 4.1.1I - Developing a new algorithm to solve a problem can yield insight into the problem.
    • LO 4.1.2 - Express an algorithm in a language. [P5]
      • EK 4.1.2A - Languages for algorithms include natural language, pseudocode, and visual and textual programming languages.
      • EK 4.1.2B - Natural language and pseudocode describe algorithms so that humans can understand them.
      • EK 4.1.2C - Algorithms described in programming languages can be executed on a computer.
      • EK 4.1.2D - Different languages are better suited for expressing different algorithms.
      • EK 4.1.2F - The language used to express an algorithm can affect characteristics such as clarity or readability but not whether an algorithmic solution exists.
      • EK 4.1.2G - Every algorithm can be constructed using only sequencing, selection, and iteration.
      • EK 4.1.2H - Nearly all programming languages are equivalent in terms of being able to express any algorithm.
      • EK 4.1.2I - Clarity and readability are important considerations when expressing an algorithm in a language.
Big Idea - Programming
  • EU 5.1 - Programs can be developed for creative expression, to satisfy personal curiosity, to create new knowledge, or to solve problems (to help people, organizations, or society).
    • LO 5.1.1 - Develop a program for creative expression, to satisfy personal curiosity, or to create new knowledge. [P2]
      • EK 5.1.1A - Programs are developed and used in a variety of ways by a wide range of people depending on the goals of the programmer.
      • EK 5.1.1B - Programs developed for creative expression, to satisfy personal curiosity, or to create new knowledge may have visual, audible, or tactile inputs and outputs.
      • EK 5.1.1C - Programs developed for creative expression, to satisfy personal curiosity, or to create new knowledge may be developed with different standards or methods than programs developed for widespread distribution.
      • EK 5.1.1D - Additional desired outcomes may be realized independently of the original purpose of the program.
      • EK 5.1.1E - A computer program or the results of running a program may be rapidly shared with a large number of users and can have widespread impact on individuals, organizations, and society.
    • LO 5.1.2 - Develop a correct program to solve problems. [P2]
      • EK 5.1.2A - An iterative process of program development helps in developing a correct program to solve problems.
      • EK 5.1.2B - Developing correct program components and then combining them helps in creating correct programs.
      • EK 5.1.2C - Incrementally adding tested program segments to correct working programs helps create large correct programs.
      • EK 5.1.2D - Program documentation helps programmers develop and maintain correct programs to efficiently solve problems.
      • EK 5.1.2E - Documentation about program components, such as code segments and procedures, helps in developing and maintaining programs.
      • EK 5.1.2F - Documentation helps in developing and maintaining programs when working individually or in collaborative programming environments.
      • EK 5.1.2G - Program development includes identifying programmer and user concerns that affect the solution to problems.
      • EK 5.1.2I - A programmer's knowledge and skill affects how a program is developed and how it is used to solve a problem.
      • EK 5.1.2J - A programmer designs, implements, tests, debugs, and maintains programs when solving problems.
    • LO 5.1.3 - Collaborate to develop a program. [P6]
      • EK 5.1.3A - Collaboration can decrease the size and complexity of tasks required of individual programmers.
      • EK 5.1.3B - Collaboration facilitates multiple perspectives in developing ideas for solving problems by programming.
      • EK 5.1.3C - Collaboration in the iterative development of a program requires different skills than developing a program alone.
      • EK 5.1.3D - Collaboration can make it easier to find and correct errors when developing programs.
      • EK 5.1.3E - Collaboration facilitates developing program components independently.
      • EK 5.1.3F - Effective communication between participants is required for successful collaboration when developing programs.
  • EU 5.2 - People write programs to execute algorithms.
    • LO 5.2.1 - Explain how programs implement algorithms. [P3]
      • EK 5.2.1A - Algorithms are implemented using program instructions that are processed during program execution.
      • EK 5.2.1B - Program instructions are executed sequentially.
      • EK 5.2.1C - Program instructions may involve variables that are initialized and updated, read, and written.
      • EK 5.2.1E - Program execution automates processes.
      • EK 5.2.1G - A process may execute by itself or with other processes.
      • EK 5.2.1J - Simple algorithms can solve a large set of problems when automated.
  • EU 5.3 - Programming is facilitated by appropriate abstractions.
    • LO 5.3.1 - Use abstraction to manage complexity in programs. [P3]
      • EK 5.3.1A - Procedures are reusable programming abstractions.
      • EK 5.3.1B - A procedure is a named grouping of programming instructions.
      • EK 5.3.1C - Procedures reduce the complexity of writing and maintaining programs.
      • EK 5.3.1D - Procedures have names and may have parameters and return values.
      • EK 5.3.1E - Parameterization can generalize a specific solution.
      • EK 5.3.1F - Parameters generalize a solution by allowing a procedure to be used instead of duplicated code.
      • EK 5.3.1G - Parameters provide different values as input to procedures when they are called in a program.
      • EK 5.3.1I - Strings and string operations, including concatenation and some form of substring, are common in many programs.
      • EK 5.3.1J - Integers and floating-point numbers are used in programs without requiring understanding of how they are implemented.
      • EK 5.3.1L - Using lists and procedures as abstractions in programming can result in programs that are easier to develop and maintain.
      • EK 5.3.1M - Application program interfaces (APIs) and libraries simplify complex programming tasks.
      • EK 5.3.1N - Documentation for an API/library is an important aspect of programming.
      • EK 5.3.1O - APIs connect software components, allowing them to communicate.
  • EU 5.4 - Programs are developed, maintained, and used by people for different purposes.
    • LO 5.4.1 - Evaluate the correctness of a program. [P4]
      • EK 5.4.1A - Program style can affect the determination of program correctness.
      • EK 5.4.1C - Meaningful names for variables and procedures help people better understand programs.
      • EK 5.4.1D - Longer code segments are harder to reason about than shorter code segments in a program.
      • EK 5.4.1E - Locating and correcting errors in a program is called debugging the program.
      • EK 5.4.1F - Knowledge of what a program is supposed to do is required in order to find most program errors.
      • EK 5.4.1H - Visual displays (or different modalities) of program state can help in finding errors.
      • EK 5.4.1I - Programmers justify and explain a program’s correctness.
      • EK 5.4.1J - Justification can include a written explanation about how a program meets its specifications.
      • EK 5.4.1K - Correctness of a program depends on correctness of program components, including code segments and procedures.
      • EK 5.4.1L - An explanation of a program helps people understand the functionality and purpose of it.
  • EU 5.5 - Programming uses mathematical and logical concepts.
    • LO 5.5.1 - Employ appropriate mathematical and logical concepts in programming. [P1]
      • EK 5.5.1A - Numbers and numerical concepts are fundamental to programming.
      • EK 5.5.1D - Mathematical expressions using arithmetic operators are part of most programming languages.
      • EK 5.5.1E - Logical concepts and Boolean algebra are fundamental to programming.
      • EK 5.5.1F - Compound expressions using and, or, and not are part of most programming languages.
      • EK 5.5.1G - Intuitive and formal reasoning about program components using Boolean concepts helps in developing correct programs.
      • EK 5.5.1H - Computational methods may use lists and collections to solve problems.
      • EK 5.5.1I - Lists and other collections can be treated as abstract data types (ADTs) in developing programs.
      • EK 5.5.1J - Basic operations on collections include adding elements, removing elements, iterating over all elements, and determining whether an element is in a collection.

Key Concepts

Students practice choosing a project and planning how to implement it in a fixed time frame. 

Students have just two days to plan and implement a project.  Since these will be small projects, students may need help using algorithms and data abstraction. Since an algorithm is a list of steps that comes to a conclusion, if students develop pseudocode for their projects they can refer to the pseudocode as their algorithm. 

Students may receive most of the credit from an incomplete project if the project demonstrates the required components.

For this practice task, teachers may want to provide program stubs.  Stubs could include suggested functions. 


Essential Questions

  • How are algorithms implemented and executed on computers and computational devices?
  • How do computer programs implement algorithms?
  • How does abstraction make the development of computer programs possible?

Teacher Resources

Lesson Plan

Session 1:  Planning Day

Present an overview of the Create Task.

Explain that students will have 12 hours to complete the Create Task later in the course and they will three 50-minute sessions for this practice.  The actual Create Task will have a suggested collaborative component and be larger in scope.

Discuss the following guidelines for the full project and the practice project we will be doing.

Full Create Task Guidelines

Three components to create:

  • Program
  • Report
  • Video


One project - individual with collaboration in stages

12 hours of classroom time

Project must use functional and data abstraction.


Report: Written responses  (response to all prompts combined must not exceed 750 words, exclusive of the Program Code.):

a. Provide a written response or audio narration in your video that:  Identifies the programming language and identifies the purpose of your program.   

b. Describe the incremental and iterative development process of your program

c. Describe how a selected algorithm functions.

d. Explain how an abstraction you developed helped manage complexity


Practice Create Task Guidelines

For this practice task, students will complete simpler project and a one-minute presentation about it, rather than a video and a report.

Students work individually to select projects.


After completing the project, students will create a one-minute presentation about it.  Presentation should address the following.

a.  Identify the programming language and the purpose of your program.   

b. Describe the incremental and iterative development process of your program

c. Describe how a selected algorithm functions.

d. Explain how an abstraction you developed  helped manage complexity

The presentation must address at least points a and b of the above and c or d.

Projects are chosen by the student.  If they wish, their projects may be based on the following labs from How to Think Like a Computer Scientist.



Students select a project and share their ideas with partners. 

After collaborating with partners, students submit to their teacher a brief description of the project describing its most important features and how it will work.

Students identify an algorithm and an abstraction to use in their projects.  The algorithm should be written as pseudocode and then shared with their partners.

Students should discuss in groups what abstraction they chose and how they think it would be helpful.


Session 2: Implementation Day

Warm up (2 min)

Students complete a brief journal entry describing:

  • Their plan for today in the development of the project.
  • What abstractions they will be using in the project.

Work Time (43 min)

Students work to implement and test projects. Teachers may evaluate student performance based on student journal entries and their observations of their effort in implementing the project.


Closing (5 min)

Students reflect on their project and making journal entry of how they used abstraction in the project.


Day 3: Presentation Day

Warmup (5 min)

Students begin by individually responding to these prompts about their project:

b.    describe the purpose, how your program code works and the most important features and algorithms

d.    describe the development process

e.    explain an abstraction and how it helped manage complexity


Presentation Preparation (20 min)

Students prepare one-minute presentation about their projects including their responses to prompts b, d and e. 


Presentations (15 min)

Students present their project to table groups. Time the presentations so that they do not exceed 1 minute. Students share with table groups what they like about the project, what they learned and any questions they have.


Closing (5 min)

Students create exit slips with any questions they have about the Create Task after viewing and discussing the presentations.



Evidence of Learning

Formative Assessment

For the practice task, project descriptions and pseudocode for each proposed project should be assessed.  Assessment can be done by collaborative partners first.  If partners have concerns, they should be brought to the teacher.  If student projects are too big or too small in scope, teachers should provide feedback.

Summative Assessment

The project should be scored using the latest rubric provided by the College Board. 

The latest rubric (updated as of June 2016) is in the lesson folder.