AP Computer Science Principles - Big Idea 1: Creative Development
Big Idea 1: Creative Development (10-13% AP Exam Weighting)
Developing Understanding
Collaboration is crucial for developing computing innovations.
Multiple perspectives can improve the design of innovations.
Students work collaboratively to design and develop programs using an iterative development process.
They identify the needs of all users by gathering input from people from different backgrounds and demographics.
After development, they test the program to ensure it meets the identified needs.
Effective collaboration requires equal participation and voice from all members.
Establishing collaborative practices and norms early in the school year is helpful.
Content in this big idea is often paired with Big Idea 3: Algorithms and Programming.
Building Computational Thinking Practices
When designing a solution, programmers consider both the program and the user interface.
A well-designed user interface makes it easy for the user to understand required data inputs needed for the program.
Diagrams can help students plan how their program should behave based on identified inputs.
Planning ahead can help determine abstractions and identify logic errors early.
Programmers use documentation to explain code segments and their functions.
Documenting smaller code segments is more manageable.
Preparing for the AP Exam
Students design and implement a program for the Create performance task.
Students select their own topic but must include elements like lists and procedures.
Exemplars can help students consider program types that meet requirements.
Students need practice identifying and correcting errors using prewritten code.
Essential Questions
CRD-1
How has working collaboratively with other students improved an overall project?
What are some ways you can collect additional feedback on your program to use for improvements?
CRD-2
What are some ways you currently plan your work before starting a project?
What apps or programs have you stopped using because you didn’t like the design of how you interacted with it?
Big Idea at a Glance
1.1 Collaboration
Learning Objectives: CRD-1.A, CRD-1.B, CRD-1.C
Skills: 1.C Explain how collaboration affects the development of a solution; 6.A Collaborate in the development of solutions (not assessed).
1.2 Program Function and Purpose
Learning Objectives: CRD-2.A, CRD-2.B, CRD-2.C, CRD-2.D
Skills: 1.A Investigate the situation, context, or task; 3.A Generalize data sources through variables; 4.A Explain how a code segment or program functions.
1.3 Program Design and Development
Learning Objectives: CRD-2.E, CRD-2.F, CRD-2.G, CRD-2.H
Skills: 1.B Determine and design an appropriate method or approach to achieve the purpose; 1.C Explain how collaboration affects the development of a solution; 4.A Explain how a code segment or program functions; 6.C Acknowledge the intellectual property of others (not assessed).
1.4 Identifying and Correcting Errors
Learning Objectives: CRD-2.I, CRD-2.J
Skills: 1.B Determine and design an appropriate method or approach to achieve the purpose; 4.C Identify and correct errors in algorithms and programs, including error discovery through testing.
Sample Instructional Activities
Activity 1 (Topic 1.1): Sharing and responding
Students develop a list of three questions that they would like to use data to answer.
In small groups, each student shares one question.
The group provides feedback to improve the question's focus and direction.
Students take turns until all questions have been considered.
Each group reaches a consensus on three questions to answer with data.
Activity 2 (Topic 1.3): Diagramming
In small groups, students play a board game for 10 minutes.
They record actions and decisions in a diagram or flowchart.
Groups trade games and play using the diagram for directions.
Students identify and correct any inaccuracies or missing steps in the diagram.
Topic 1.1: Collaboration
Enduring Understanding: CRD-1 Incorporating multiple perspectives through collaboration improves computing innovations as they are developed.
Learning Objective: CRD-1.A Explain how computing innovations are improved through collaboration.
Essential Knowledge:
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 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.
Learning Objective: CRD-1.B Explain how computing innovations are developed by groups of people.
CRD-1.B.1 Online tools support collaboration by allowing programmers to share and provide feedback on ideas and documents.
CRD-1.B.2 Common models such as pair programming exist to facilitate collaboration.
Learning Objective: CRD-1.C Demonstrate effective interpersonal skills during collaboration.
CRD-1.C.1 Effective collaborative teams practice interpersonal skills, including but not limited to:
communication
consensus building
conflict resolution
negotiation
Topic 1.2: Program Function and Purpose
Enduring Understanding: CRD-2 Developers create and innovate using an iterative design process that is user-focused, that incorporates implementation/feedback cycles, and that leaves ample room for experimentation and risk-taking.
Learning Objective: CRD-2.A Describe the purpose of a computing innovation.
CRD-2.A.1 The purpose of computing innovations is to solve problems or to pursue interests through creative expression.
CRD-2.A.2 An understanding of the purpose of a computing innovation provides developers with an improved ability to develop that computing innovation.
Learning Objective: CRD-2.B Explain how a program or code segment functions.
CRD-2.B.1 A program is a collection of program statements that performs a specific task when run by a computer. A program is often referred to as software.
CRD-2.B.2 A code segment is a collection of program statements that is part of a program.
CRD-2.B.3 A program needs to work for a variety of inputs and situations.
CRD-2.B.4 The behavior of a program is how a program functions during execution and is often described by how a user interacts with it.
Learning Objective: CRD-2.C Identify input(s) to a program.
CRD-2.C.1 Program inputs are data sent to a computer for processing by a program. Input can come in a variety of forms, such as tactile, audio, visual, or text.
CRD-2.C.2 An event is associated with an action and supplies input data to a program.
CRD-2.C.3 Events can be generated when a key is pressed, a mouse is clicked, a program is started, or any other defined action occurs that affects the flow of execution.
CRD-2.C.4 Inputs usually affect the output produced by a program.
CRD-2.C.5 In event-driven programming, program statements are executed when triggered rather than through the sequential flow of control.
CRD-2.C.6 Input can come from a user or other programs.
Learning Objective: CRD-2.D Identify output(s) produced by a program.
CRD-2.D.1 Program outputs are any data sent from a program to a device. Program output can come in a variety of forms, such as tactile, audio, visual, or text.
CRD-2.D.2 Program output is usually based on a program’s input or prior state (e.g., internal values).
CRD-2.B.5 A program can be described broadly by what it does, or in more detail by both what the program does and how the program statements accomplish this function.
Topic 1.3: Program Design and Development
Enduring Understanding: CRD-2 Developers create and innovate using an iterative design process that is user-focused, that incorporates implementation/feedback cycles, and that leaves ample room for experimentation and risk-taking.
Learning Objective: CRD-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.
Learning Objective: CRD-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:
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
Learning Objective: CRD-2.G Describe the purpose of a code segment or program by writing documentation.
CRD-2.G.1 Program documentation is a written description of the function of a code segment, event, procedure, or program and how it was developed.
CRD-2.G.2 Comments are a form of program documentation written into the program to be read by people and do not affect how a program runs.
CRD-2.G.3 Programmers should document a program throughout its development.
CRD-2.G.4 Program documentation helps in developing and maintaining correct programs when working individually or in collaborative programming environments.
CRD-2.G.5 Not all programming environments support comments, so other methods of documentation may be required.
Learning Objective: CRD-2.H Acknowledge code segments used from other sources.
CRD-2.H.1 It is important to acknowledge any code segments that were developed collaboratively or by another source.
CRD-2.H.2 Acknowledgement of a code segment(s) written by someone else and used in a program can be in the program documentation. The acknowledgement should include the origin or original author’s name.
Topic 1.4: Identifying and Correcting Errors
Enduring Understanding: CRD-2 Developers create and innovate using an iterative design process that is user-focused, that incorporates implementation/feedback cycles, and that leaves ample room for experimentation and risk-taking.
Learning Objective: CRD-2.I For errors in an algorithm or program:
a. Identify the error.
b. Correct the error.
CRD-2.I.1 A logic error is a mistake in the algorithm or program that causes it to behave incorrectly or unexpectedly.
CRD-2.I.2 A syntax error is a mistake in the program where the rules of the programming language are not followed.
CRD-2.I.3 A run-time error is a mistake in the program that occurs during the execution of a program. Programming languages define their own run-time errors.
CRD-2.I.4 An overflow error is an error that occurs when a computer attempts to handle a number that is outside of the defined range of values.
CRD-2.I.5 The following are effective ways to find and correct errors:
test cases
hand tracing
visualizations
debuggers
adding extra output statement(s)
Learning Objective: CRD-2.J Identify inputs and corresponding expected outputs or behaviors that can be used to check the correctness of an algorithm or program.
CRD-2.J.1 In the development process, testing uses defined inputs to ensure that an algorithm or program is producing the expected outcomes. Programmers use the results from testing to revise their algorithms or programs.
CRD-2.J.2 Defined inputs used to test a program should demonstrate the different expected outcomes that are at or just beyond the extremes (minimum and maximum) of input data.
CRD-2.J.3 Program requirements are needed to identify appropriate defined inputs for testing.