Lesson 3: Create PT - Complete the Task (12 hrs)
It is finally time for students to take on the Create Performance Task. For a total of 12 class hours, students should work on their projects with only types of teacher support allowed (essentially: Advise on process, don’t influence or evaluate ideas). Students may also work with a collaborative partner in in development of their program - written responses must be done on their own.
The lesson includes reminders about how you can interact with students while they are working on their projects, and suggestions about time line. The Create PT requires a minimum of 12 hours of class time. At the end, students will submit their program code, program video, and written responses through their AP digital portfolio.
There are no new CS concepts covered in this lesson. Students will work individually or with a collaborative partner on the Create Performance Task.
Activity (12 hours)
Students will be able to:
- Complete and submit the Create Performance Task.
- Review the AP CS Principles Course and Exam Description to understand the teacher's role on the Create PT
- Review how to create a stand-alone App Lab project to assist students
For the Teacher
For the Students
Creating an App Lab Project: Before students begin programming, they should make sure that they are creating their program in a new App Lab Project - NOT in a level associated with a previous lesson.
However, you can use a previous project as a starting point as long as you add new parts that fulfill the task requirements.
To build off a program started in a previous lesson:
Make sure to click “Remix” from the original program level. This will create a new copy of the program that can be accessed from the list of individual student projects found at https://studio.code.org/projects. Students should indicate using comments what parts of the program are copied from older projects.
For students who are creating an entirely new program:
Create a new App Lab project by visiting https://studio.code.org/projects/applab/new
How Can You Help as a Teacher: Review the AP CS Principles Course and Exam Description, in particular pages 79 - 83 to understand how you as a teacher can and cannot assist on the Create Performance Task.
- For the next ~12 days, you will be completing the Create Performance Task.
- Most of the work for this task must be done independently - but you are allowed to collaborate with another student to create a program. But you must have enough individual contributions to meet all the requirements of the written responses.
- I (teacher) can help you with process and timeline and keep you on task
- There are a few other last minute things we should look at to make sure you're clear before we start.
Before we start let's look at a few pages in AP CSP Performance Task Directions for Students - Resource.
Do these things:
Read page 3: Preparing for the Through-Course Performance Tasks
This is a general checklist of things you should do to prepare for any of the AP Performance Tasks. Let's see how we did:
Prompt: With a partner - one person reading from the top down, the other reading from bottom up - check off things we've done to prepare so far. Identify anything we haven't done, and be sure to note and Create PT-specific items.
Quick chat with your partner to summarize anything new or unexpected you discovered.
- Some of the items do not pertain to the Create PT so can be ignored.
Everything else should have been covered in one way or another if you've done the prep lessons prior to this and used the Create PT Survival guide.
Address any questions students have
Read page 12: Preparing for the Create Performance Task
This is another checklist of things you should do to prepare specifically for the Create Performance task. Again, let's see how we did.
Prompt: again divide and conquer - with a partner scan the page and check off things you feel confident about, and pull out things you're not sure about.
- Again most of the things on this list are things we've done in the previous preparation lessons.
- They suggest keeping a journal to log things like decision points about opportunities and difficulties, algorithm and abstraction -- we recommend using the Create PT Planning Organizer as a structured way to log that important information.
Read Page 2 - Policy on Plagiarism & Peer-to-Peer Collaboration
Read the two sections on Page 2, or point out the relevant portions (highlighted below). This is info to have in the background before you go read the guidelines for completing the task next.
Point out Plagiarism applies the the Create PT as well. Specifically:
Point out Collaboration is allowed as well:
...but you need to be careful that you have enough original work to submit as your own PT.
Hold off discussing these things until after you read the guidelines on pages 12-13.
Read Pages 12-13 - Guidelines for Completing the Create Performance Task
This is a final list of Do's and Don'ts for the Create PT.
Prompt: with your partner, read the You must, You may, and You may not sections of this page. Then with you partner summarize: what kinds of things can your teacher help you with?
- Let students read and discuss with partners
- Discuss specifically how you (teacher) are allowed to help and not. Short version: you can help students with the process of completing the task, you cannot help by evaluating their work or ideas in any way.
- There may be some gray area around these items:
- Taken together this means you can submit a project that you had worked on previously, as long as the algorithms and abstractions identified in your response are new and original - and you haven't received feedback on them from a teacher.
- If you modify an existing project for the Create PT make sure that the purpose is also new, or modified to fit the changes and updates you are making. For example: "The purpose was to add a login feature to a game I made previously".
Plagiarism and the Create PT
Students may also notice this line from the guidelines:
You must: ...
How to acknowledge others' work, previous work, and cite sources for the Create PT
add comments in the program code you submit to indicate which parts were written individually
In response 2b (development process) make sure to indicate that the work was done collaboratively and refer the reader to comments left in the code.
In responses 2a and 2b, if building off an earlier project, be sure to mention that the purpose was to extend previous work - whether your own or someone else's - and also make that clear in the development process section.
If using images, media or other copyrighted material found on the web, you should cite those sources in comments in your program code - usually at the top. Something like:
// The images used in this app came from: //  bird image - http://name-of-site.com/path/to/image.jpg //  flower image - http://site.com/path/to/flower.jpg
Take out your Create PT timeline that we developed and reviewed.
Ask and answer any remaining questions
Remind students of the overall timeline and that the official PT time is about to start
Activity (12 hours)
- The Create PT Programming Journal is designed to be modified to best suit your classroom needs.
- For example, a class with block periods might need less days to complete the hour requirements for the Performance Task. As a result, there could be less total journal entries, but student responses per entry could be longer.
- Note It is acceptable to grade these journals for participation. However, it's not appropriate to grade the content of the journals as that could be considered feedback on the student project.
GO! Complete Create Performance Task
- While completing the performance task, you should keep track of the progress you are making.
- To do this, at the end of each class period record your work in the Create PT Programming Journal.
- When finished with your program, use the information in your journal to help complete the Written Response .
Links in Code Studio:
Students can find links to AP documents on the student page in code studio associated with this lesson.
Students may use the Code.org Create PT Template to record their Written Response. Remind students that this must be exported as a PDF before uploading to the Digital Portfolio.
Students submit completed Create Performance Task
Submission Timeline: You may spread out submission over a few days if you like since students can save progress in the AP Digital Portfolio. As long as they finalize submission by the closing date of the PTs it's fine.
In the past submitting everything right at the deadline has been a risky proposition as the site sometimes experiences outages due to heavy traffic. Get something in early and modify later.
- You are encouraged to submit and save work in the AP digital portfolio as you go!
- At the designated end of the Task administration (having allowed for at least 12 hours of class time for work) students should submit their video of the program running, written responses, and program code to their AP Digital Portfolio Access - College Board Site. You can find more instructions as well by using the AP Digital Portfolio - Teacher Guide.
Before they submit their final work:
Encourage students to check over the Create PT - Survival Guide 2018/2019 checklists one more time to make sure they met the requirements.
Make sure they have all the components necessary for the Create Performance Task.
- Create PT - Complete the Task - Student Links
- (click tabs to see student view)
Students can find all the links they need on this page. (If you are viewing this from within the lesson plan click Student Overview to see the student view of the page).
Almost all of the links here are for student reference, to use while completing the task.
The only new document here is the "Guidelines for completing the task" which are mostly reminders about the requirements and how students are allowed to interact with each other and the teacher.
Deprecated - old content from this page
On Dec. 13, 2017 we updated this page with new resources and links. If you're looking for the old stuff, it is copied below, but should be considered out of date.
It's finally time for you to take on the Create Performance Task! For the next several days, you should work individually on your project without teacher support. At the end of the 12th day (or hour) of this task, you will submit your program code, video, and written responses to the AP Digital Portfolio.
Best of luck!
- Review Guidelines for completing the task and your plan
- Complete the Create Performance Task.
- Submit your program code, video, and written responses to the AP Portfolio
New this lesson
Where to write the code -
Remix an existing project: If you are planning to use a previous project as a starting point, make sure to click the "Remix" button from the original program. This will create a new copy of the program that can be accessed from your project list at https://studio.code.org/projects
- Make a new project: If you are creating an entirely new program, create a new App Lab project by visiting https://studio.code.org/projects/applab/new
College Board Documents
- Create PT - Guidelines before starting
- Create Performance Task - Task Description
- Scoring Guidelines - Create Performance Task
Create PT Samples - Sample A (video | written responses) | Sample B (video | written responses) | Sample C (video | written responses) | Sample D (video | written responses) | Sample E (video | written responses) | Sample F (video | written responses) | Sample G (video | written responses) | Sample H (video | written responses) | Sample I (video | written responses) | Sample J (video | written responses)
Create Scoring Commentary: For all samples - Sample Create PTs Scoring Commentary
Review and Planning Documents
Unit 6: Lesson 03 - Create PT - Complete the Task
The lesson includes some final reminders and guidelines for completing the Create PT before officially starting. For a total of 12 class hours, you will work on your project with only types of teacher support allowed (essentially: Advise on process, not ideas). You may also work with a collaborative partner in in development of you program - written responses must be done on your own.
- Review Guidelines for completing the task and your plan
- Complete the Create Performance Task.
- Submit your video, program code and written responses to the AP Digital Portfolio
AP CSP Performance Task Directions for Students - quick links
- Page 2 - Policy on Plagiarism
- Page 3 - Preparing for the Through-Course Performance Tasks
- Page 12 - Preparing for the Create Performance Task
- Pages 12-13 - Guidelines for Completing the Create Performance Task
College Board Documents
- AP CSP Performance Task Directions for Students - College Board Student Handout
- Create Performance Task - Scoring Guidelines 2018
Review and Planning Documents
Computer Science Principles
1.2 - Computing enables people to use creative development processes to create computational artifacts for creative expression or to solve a problem.
1.2.1 - Create a computational artifact for creative expression. [P2]
- 1.2.1A - A computational artifact is anything created by a human using a computer and can be, but is not limited to, a program, an image, audio, video, a presentation, or a web page file.
- 1.2.1B - Creating computational artifacts requires understanding and using software tools and services.
- 1.2.1C - Computing tools and techniques are used to create computational artifacts and can include, but are not limited to, programming IDEs, spreadsheets, 3D printers, or text editors.
- 1.2.1D - A creatively developed computational artifact can be created by using nontraditional, nonprescribed computing techniques.
- 1.2.1E - Creative expressions in a computational artifact can reflect personal expressions of ideas or interests.
1.2.2 - Create a computational artifact using computing tools and techniques to solve a problem. [P2]
- 1.2.2A - Computing tools and techniques can enhance the process of finding a solution to a problem.
- 1.2.2B - A creative development process for creating computational artifacts can be used to solve problems when traditional or prescribed computing techniques are not effective.
1.2.3 - Create a new computational artifact by combining or modifying existing artifacts. [P2]
- 1.2.3A - Creating computational artifacts can be done by combining and modifying existing artifacts or by creating new artifacts.
- 1.2.3B - Computation facilitates the creation and modification of computational artifacts with enhanced detail and precision.
- 1.2.3C - Combining or modifying existing artifacts can show personal expression of ideas.
1.2.4 - Collaborate in the creation of computational artifacts. [P6]
- 1.2.4A - A collaboratively created computational artifact reflects effort by more than one person.
- 1.2.4B - Effective collaborative teams consider the use of online collaborative tools.
- 1.2.4C - Effective collaborative teams practice interpersonal communication, consensus building, conflict resolution, and negotiation.
- 1.2.4D - Effective collaboration strategies enhance performance.
- 1.2.4E - Collaboration facilitates the application of multiple perspectives (including sociocultural perspectives) and diverse talents and skills in developing computational artifacts.
- 1.2.4F - A collaboratively created computational artifact can reflect personal expressions of ideas.
2.2 - Multiple levels of abstraction are used to write programs or create other computational artifacts
2.2.1 - Develop an abstraction when writing a program or creating other computational artifacts. [P2]
- 2.2.1A - The process of developing an abstraction involves removing detail and generalizing functionality.
- 2.2.1B - An abstraction extracts common features from specific examples in order to generalize concepts.
- 2.2.1C - An abstraction generalizes functionality with input parameters that allow software reuse.
2.2.2 - Use multiple levels of abstraction to write programs. [P3]
- 2.2.2A - Software is developed using multiple levels of abstractions, such as constants, expressions, statements, procedures, and libraries.
- 2.2.2B - Being aware of and using multiple levels of abstraction in developing programs helps to more effectively apply available resources and tools to solve problems.
4.1 - Algorithms are precise sequences of instructions for processes that can be executed by a computer and are implemented using programming languages.
4.1.1 - Develop an algorithm for implementation in a program. [P2]
- 4.1.1A - Sequencing, selection, and iteration are building blocks of algorithms.
- 4.1.1B - Sequencing is the application of each step of an algorithm in the order in which the statements are given.
- 4.1.1C - Selection uses a Boolean condition to determine which of two parts of an algorithm is used.
- 4.1.1D - Iteration is the repetition of part of an algorithm until a condition is met or for a specified number of times.
- 4.1.1E - Algorithms can be combined to make new algorithms.
- 4.1.1F - Using existing correct algorithms as building blocks for constructing a new algorithm helps ensure the new algorithm is correct.
- 4.1.1G - Knowledge of standard algorithms can help in constructing new algorithms.
- 4.1.1H - Different algorithms can be developed to solve the same problem.
- 4.1.1I - Developing a new algorithm to solve a problem can yield insight into the problem.
4.1.2 - Express an algorithm in a language. [P5]
- 4.1.2A - Languages for algorithms include natural language, pseudocode, and visual and textual programming languages.
- 4.1.2B - Natural language and pseudocode describe algorithms so that humans can understand them.
- 4.1.2C - Algorithms described in programming languages can be executed on a computer.
- 4.1.2D - Different languages are better suited for expressing different algorithms.
- 4.1.2E - Some programming languages are designed for specific domains and are better for expressing algorithms in those domains.
- 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.
- 4.1.2G - Every algorithm can be constructed using only sequencing, selection, and iteration.
- 4.1.2H - Nearly all programming languages are equivalent in terms of being able to express any algorithm.
- 4.1.2I - Clarity and readability are important considerations when expressing an algorithm in a language.
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).
5.1.1 - Develop a program for creative expression, to satisfy personal curiosity, or to create new knowledge. [P2]
- 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.
- 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.
- 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.
- 5.1.1D - Additional desired outcomes may be realized independently of the original purpose of the program.
- 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
- 5.1.1F - Advances in computing have generated and increased creativity in other fields.
5.1.2 - Develop a correct program to solve problems. [P2]
- 5.1.2A - An iterative process of program development helps in developing a correct program to solve problems.
- 5.1.2B - Developing correct program components and then combining them helps in creating correct programs.
- 5.1.2C - Incrementally adding tested program segments to correct, working programs helps create large correct programs.
- 5.1.2D - Program documentation helps programmers develop and maintain correct programs to efficiently solve problems.
- 5.1.2E - Documentation about program components, such as blocks and procedures, helps in developing and maintaining programs.
- 5.1.2F - Documentation helps in developing and maintaining programs when working individually or in collaborative programming environments
- 5.1.2G - Program development includes identifying programmer and user concerns that affect the solution to problems.
- 5.1.2H - Consultation and communication with program users is an important aspect of program development to solve problems.
- 5.1.2I - A programmerâ€™s knowledge and skill affects how a program is developed and how it is used to solve a problem.
- 5.1.2J - A programmer designs, implements, tests, debugs, and maintains programs when solving problems.
5.1.3 - Collaborate to develop a program. [P6]
- 5.1.3A - Collaboration can decrease the size and complexity of tasks required of individual programmers.
- 5.1.3B - Collaboration facilitates multiple perspectives in developing ideas for solving problems by programming.
- 5.1.3C - Collaboration in the iterative development of a program requires different skills than developing a program alone.
- 5.1.3D - Collaboration can make it easier to find and correct errors when developing programs.
- 5.1.3E - Collaboration facilitates developing program components independently.
- 5.1.3F - Effective communication between participants is required for successful collaboration when developing programs.
5.2 - People write programs to execute algorithms.
5.2.1 - Explain how programs implement algorithms. [P3]
- 5.2.1A - Algorithms are implemented using program instructions that are processed during program execution.
- 5.2.1B - Program instructions are executed sequentially.
- 5.2.1C - Program instructions may involve variables that are initialized and updated, read, and written
- 5.2.1D - An understanding of instruction processing and program execution is useful for programming.
- 5.2.1E - Program execution automates processes.
- 5.2.1F - Processes use memory, a central processing unit (CPU), and input and output.
- 5.2.1G - A process may execute by itself or with other processes.
- 5.2.1H - A process may execute on one or several CPUs.
- 5.2.1I - Executable programs increase the scale of problems that can be addressed.
- 5.2.1J - Simple algorithms can solve a large set of problems when automated.
- 5.2.1K - Improvements in algorithms, hardware, and software increase the kinds of problems and the size of problems solvable by programming.
5.3 - Programming is facilitated by appropriate abstractions.
5.3.1 - Use abstraction to manage complexity in programs. [P3]
- 5.3.1A - Procedures are reusable programming abstractions.
- 5.3.1B - A function is a named grouping of programming instructions.
- 5.3.1C - Procedures reduce the complexity of writing and maintaining programs.
- 5.3.1D - Procedures have names and may have parameters and return values.
- 5.3.1E - Parameterization can generalize a specific solution.
- 5.3.1F - Parameters generalize a solution by allowing a function to be used instead of duplicated code
- 5.3.1G - Parameters provide different values as input to procedures when they are called in a program.
- 5.3.1H - Data abstraction provides a means of separating behavior from implementation.
- 5.3.1I - Strings and string operations, including concatenation and some form of substring, are common in many programs.
- 5.3.1J - Integers and floatingpoint numbers are used in programs without requiring understanding of how they are implemented.
- 5.3.1K - Lists and list operations, such as add, remove, and search, are common in many programs.
- 5.3.1L - Using lists and procedures as abstractions in programming can result in programs that are easier to develop and maintain.
- 5.3.1M - Application program interfaces (APIs) and libraries simplify complex programming tasks.
- 5.3.1N - Documentation for an API/library is an important aspect of programming.
- 5.3.1O - APIs connect software components, allowing them to communicate.
5.4 - Programs are developed, maintained, and used by people for different purposes.
5.4.1 - Evaluate the correctness of a program. [P4]
- 5.4.1A - Program style can affect the determination of program correctness.
- 5.4.1B - Duplicated code can make it harder to reason about a program.
- 5.4.1C - Meaningful names for variables and procedures help people better understand programs.
- 5.4.1D - Longer code blocks are harder to reason about than shorter code blocks in a program.
- 5.4.1E - Locating and correcting errors in a program is called debugging the program.
- 5.4.1F - Knowledge of what a program is supposed to do is required in order to find most program errors.
- 5.4.1G - Examples of intended behavior on specific inputs help people understand what a program is supposed to do.
- 5.4.1H - Visual displays (or different modalities) of program state can help in finding errors.
- 5.4.1I - Programmers justify and explain a programâ€™s correctness.
- 5.4.1J - Justification can include a written explanation about how a program meets its specifications.
- 5.4.1K - Correctness of a program depends on correctness of program components, including code blocks and procedures.
- 5.4.1L - An explanation of a program helps people understand the functionality and purpose of it.
- 5.4.1M - The functionality of a program is often described by how a user interacts with it.
- 5.4.1N - The functionality of a program is best described at a high level by what the program does, not at the lower level of how the program statements work to accomplish this.
5.5 - Programming uses mathematical and logical concepts.
5.5.1 - Employ appropriate mathematical and logical concepts in programming. [P1]
- 5.5.1A - Numbers and numerical concepts are fundamental to programming.
- 5.5.1B - Integers may be constrained in the maximum and minimum values that can be represented in a program because of storage limitations.
- 5.5.1C - Real numbers are approximated by floating point representations that do not necessarily have infinite precision.
- 5.5.1D - Mathematical expressions using arithmetic operators are part of most programming languages.
- 5.5.1E - Logical concepts and Boolean algebra are fundamental to programming.
- 5.5.1F - Compound expressions using and, or, and not are part of most programming languages.
- 5.5.1G - Intuitive and formal reasoning about program components using Boolean concepts helps in developing correct programs.
- 5.5.1H - Computational methods may use lists and collections to solve problems.
- 5.5.1I - Lists and other collections can be treated as abstract data types (ADTs) in developing programs.
- 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.
7.5 - An investigative process is aided by effective organization and selection of resources. Appropriate technologies and tools facilitate the accessing of information and enable the ability to evaluate the credibility of sources.
7.5.1 - Access, manage, and attribute information using effective strategies. [P1]
- 7.5.1A - Online databases and libraries catalog and house secondary and some primary resources
- 7.5.1B - Advanced search tools, Boolean logic, and key words can refine the search focus and/or limit search results based on a variety of factors (e.g., peer-review status, type of publication)
- 7.5.1C - Plagiarism is a serious offense that occurs when a person presents another's ideas or words as his or her own. Plagiarism may be avoided by accurately acknowledging sources. 7.5.2 Evaluate online and print sources for appropriateness and credibility [P5]
CSTA K-12 Computer Science Standards (2017)
AP - Algorithms & Programming
- 3A-AP-16 - Design and iteratively develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.
- 3A-AP-18 - Create artifacts by using procedures within a program, combinations of data and procedures, or independent but interrelated programs.
- 3A-AP-19 - Systematically design and develop programs for broad audiences by incorporating feedback from users.
- 3A-AP-21 - Evaluate and refine computational artifacts to make them more usable and accessible.
- 3A-AP-23 - Document design decisions using text, graphics, presentations, and/or demonstrations in the development of complex programs.
- 3B-AP-14 - Construct solutions to problems using student-created components, such as procedures, modules and/or objects.