In this lab, students use a sprite not as a character in an animation, but to draw pictures on the stage, using turtle graphics. They also have the opportunity to mimic the work of famous artists.

Pacing:

Lab Pages

Page 1: Exploring Motion.
- Learning Goals:
  - Use the repeat block to carry out the same action several times.
  - Control the relative sprite movement with the move block.
  - Control the relative sprite direction with the turn block.
  - Set the pen thickness with the set pen size block.
- To launch this lab—Make a Prediction: Repeat, Move, Turn
  - Project the script and ask students to predict what it does (discuss in small groups and/or as a class).
  - Discussion: Ask students "How do programs implement algorithms?" Listen for students to recognize that programs execute instructions in order (sequentially) and process each next step automatically.
- Tips:
  - The first page of this lab gives students a simple script to draw a square and asks them to experiment with it, changing various numbers in the script and observing the results. Students who are accustomed to being told exactly what to do may flounder. Tell them that creativity is one of the Big Ideas of Computer Science Principles and that in this sort of exploratory lesson there are no wrong answers.
Page 2: Angles and Turning.
- Learning Goals:
  - Explore the concept of turning angle through experimentation.
  - Adapt simple scripts by changing the inputs.
  - Work with multiple constraints to achieve a desired outcome.
- Tips:
  - This page is a prelude for the upcoming pages and is an opportunity for students to experiment and make discoveries on their own.
  - A recent update to Chrome introduced a bug that affects the Snap! set pen color to block with the square picture of the actual color (not the block with a color number). This is fixed in Chrome version 78.
Page 3: Blocks with Inputs.
Brian, is this commeted code still needed? If not, could you please remove it? --MF, 11/15/19
- Learning Goals:
  - Learn how to generalize the functionality of a block by introducing input parameters.
  - Gain some initial familiarity with the concept of abstraction as a big idea in Computer Science.
- Tips:
  - This page is one of students' earliest encounters with the concept of abstraction in Computer Science. Giving an input parameter to a block generalizes its functionality, enabling it to accomplish a wider variety of tasks. Unless, this first encounter with abstraction is highlighted, most students may miss what a big deal it is.
  - As a foreshadowing to the upcoming pages, ask students to anticipate how they can further generalize the pinwheel block by introducing more input parameters.
  - Most students may not yet be quite ready to explore artistic applications of the pinwheel block as shown in the Take It Further. These are intended as thought-provoking ideas that they can come back to later in the Unit.
  - At the end of class, ask students how they drew two pinwheels on the stage. After a few suggestions, ask students to identify the most effective strategy, guiding them to conclude that using the pinwheel block twice is better than other options (e.g., copying and pasting the same code, creating a second block called second pinwheel).
Page 4: Modify Your Pinwheel.
- Learning Goals:
  - Learn how to further generalize the functionality of a block by introducing input parameters for every possible variable aspect of the block function.
  - Gain some further experience with the concept of abstraction as a big idea in Computer Science.
- Tips:
  - It may be a good idea to highlight that in this page students will be further generalizing the pinwheel block by by introducing more input parameters. Again, this is an example of abstraction.
  - Some students may have difficulty creating the size parameter in between the branches and the backup parameters. It may help to point them to the "+" sign in between these two parameters.
  - On the If There Is Time circle problem, some students may need help realizing that a regular polygon with a large number of sides, for example a 30-gon, is a good approximation for a circle.
Page 5: Remix Your Pinwheel.
- Learning Goals:
  - Learn how to tailor a general-purpose procedure to create other, simpler special-purpose procedures that each do a particular job.
  - Understand how to draw polygons in Snap!.
- Tips:
  - On the If There Is Time circle block-building problem, the students may need help discovering what should the one input be for a circle block. A natural choice for the single input would be "radius". The students may need a reminder from the previous page that a regular polygon with a large number of sides, for example a 30-gon, is a good approximation for a circle. The difficulty in this case will be determining the "side length" of the approximating polygon. Students can discover this by experimenting or it may be helpful to remind them that for a regular polygon:
    $\text{side length} = \frac{\text{perimeter}}{\text{number of sides}} \approx \frac{2 \pi \cdot \text{radius}} {\text{number of sides}}$
Page 6: Looping with a Counter.
- Learning Goals:
  - Learn the similarities and differences between the forever, repeat, and for blocks.
  - Understand the power of a loop counter.
- Tips:
  - Highlight that the for block, in addition to providing looping functionality like to the forever and repeat blocks, also provides access to the individual stages of a loop with the use of a counter; this enhances the possibilities of what can be achieved by looping.
  - Most students may not realize that it is possible to loop backwards with the for block by letting the index start from a larger number and end with a smaller number as shown at right. This code will have the sprite count backwards from 10 to 1.

Assignments

Solutions

Page 1: Exploring Motion
Page 2: Angles and Turning 1, Angles and Turning 2
Page 3: Blocks with Inputs

Solution file for page 3 has pinwheel version from later page in TIF. Solutions need careful review. --MF, 1/31/19

Page 4: Modify Your Pinwheel

All 3 of the Page 5 Racetrack solutions have green flags in them, but that's not an important part of these projects, and they should be removed from the solution files. --MF, 3/19/18

Page 5: Remix Your Pinwheel, Take It Further: Circle in a Square, Racetrack1, Racetrack2, Racetrack3

The U1L3p6LoopingwithCounter(answer file) breaks the niceness of Snap! block names and our general rule for block naming. The housekeeping () () () block should be named housekeeping, x-position: () y-position: (), direction: () and draw squiral () () should be renamed as well as its variables input1 and input2, which should be more meaningful too. Same for other blocks: nest squares, nest polygons, and draw concentric squares. The code in this file should also be "cleaned up." --MF, 3/19/18

The same idea applies in U1L3-PinwheelArtAnimation2. And why are there 2 local blocks? There is only one sprite; shouldn't they be normal blocks? Also, the green flag should be removed from this solution. --MF, 3/19/18

All three issues (block naming, local blocks, green flag block) also appear in U1L3-PinwheelArtAnimation1. --MF, 3/19/18

Lastly, the filenames are mixed up: U1L3-PinwheelArtAnimation2 is for Animation 1 and U1L3-PinwheelArtAnimation1 is for Animation 2. --MF, 3/19/18

The solutions for page 6 are mis-numbered. We should NEVER number problems in solution files because the numbering on the pages changes all the time. Also, both TIF solutions start with a greenflag, and I thought we weren't doing that. Other solutions should be checked also. --MF, 8/6/19

Page 6: Looping with a Counter, Take It Further: Pinwheel Animation 1, Take It Further: Pinwheel Animation 2

Correlation with 2020 AP CS Principles Framework

Computational Thinking Practices: Skills

2.A: Represent algorithmic processes without using a programming language.
3.B: Use abstraction to manage complexity in a program.
4.A: Explain how a code segment or program functions.
4.B: Determine the result of code segments.

Learning Objectives:

CRD-2.G: Describe the purpose of a code segment or program by writing documentation. (4.A)
AAP-2.A: Express an algorithm that uses sequencing without using a programming language. (2.A)
AAP-3.A: For procedure calls:
1. Write statements to call procedures. (3.B)
2. Determine the result or effect of a procedure call. (4.B)

Essential Knowledge:

CRD-2.B.3: A program needs to work for a variety of inputs and situations.
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.
DAT-1.A.1: Data values can be stored in variables, lists of items, or standalone constants and can be passed as input to (or output from) procedures.
AAP-2.A.1: An algorithm is a finite set of instructions that accomplish a specific task.
AAP-2.A.2: Beyond visual and textual programming languages, algorithms can be expressed in a variety of ways, such as natural language, diagrams, and pseudocode.
AAP-2.A.3: Algorithms executed by programs are implemented using programming languages.
AAP-2.J.1: Iteration is a repeating portion of an algorithm. Iteration repeats a specified number of times or until a given condition is met.
AAP-2.K.1: Iteration statements change the sequential flow of control by repeating a set of statements zero or more times, until a stopping condition is met.
AAP-2.K.2: The exam reference sheet provides
```
REPEAT n TIMES
{
    <block of statements>
}
```
in which the
```
block of statements
```
is executed
```
n
```
times.
AAP-3.A.3: Parameters are input variables of a procedure. Arguments specify the values of the parameters when a procedure is called.
AAP-3.A.4: A procedure call interrupts the sequential execution of statements, causing the program to execute the statements within the procedure before continuing. Once the last statement in the procedure (or a return statement) has executed, flow of control is returned to the point immediately following where the procedure was called.
AAP-3.A.5: The exam reference sheet provides
```
procName (arg1, arg2, …)
```
as a way to call
```
PROCEDURE procName(parameter1, parameter 2, …)
```
which takes zero or more arguments;
```
arg1
```
is assigned to
```
parameter1
```
,
```
arg2
```
is assigned to
```
parameter2
```
, and so on.
AAP-3.B.4: A procedural abstraction may extract shared features to generalize functionality instead of duplicating code. This allows for program code reuse, which helps manage complexity.
AAP-3.B.5: Using parameters allows procedures to be generalized, enabling the procedures to be reused with a range of input values or arguments.
AAP-3.B.7: Using procedural abstraction in a program allows programmers to change the internals of the procedure (to make it faster, more efficient, use less storage, etc.) without needing to notify users of the change as long as what the procedure does is preserved.
AAP-3.C.1: The exam reference sheet provides
```
PROCEDURE procName(parameter1, parameter2, …)
{
    <block of statements>
}
```
which is used to define a procedure that takes zero or more arguments. The procedure contains
```
block of statements
```
.

Can we delete these "old mathematical notes"? --MF, 11/4/19

Old Mathematical Notes:

Mathematics Note: Direction. Snap! reports the direction that a sprite is facing using a system similar to that used by a magnetic compass:
- 0 is straight up, facing the top of the screen
- 90 faces the right-hand side of the screen
- 180 points "due south"
- 270 faces the left-hand side of the screen
The inputs to the point in direction block can be any number, and this gives an opportunity to talk about different inputs to point in direction that produce the same effect. Try, for example, turning on the direction reporter in the Motion palette (it reports the direction of the sprite), but try using point in direction with an input of -20 and then again with an input of 340. The sprite points the same way—nothing changes—but direction reports -20 and then 340. Clearly, -20 ≠ 340, but they differ by 360: 340 = -20 + 360 Sprite direction is determined only up to multiples of 360, because a complete turn is 360° and that brings you back to where you started. So, using inputs to point in direction that are multiples of 360: 0,360,720,1080,... will all bring you back to pointing straight up, and similarly, inputs that are, say, 75 more than these: 75,75+360,75+720,75+1080,... will all do the same thing as point in direction with an input of 75. The mathematical shorthand for this is to say something like "75 is the same as 435 modulo 360, which can be expressed in Snap! as shown at right. (The word modulo was introduced by Gauss as a way to say "except for multiples of." These days, the meaning is often used in other ways, like "The game will take place today, modulo rain.")
Mathematics Note: Circles. You sometimes hear people say "a circle is a polygon with an infinite number of sides." This isn't true in any precise sense, but it is true that a circle can be approximated by a polygon with many sides, each very short in length. This is similar to what children do when the walk around a circle—they take many small steps. And this is how Snap! models circles—it creates a polygon with many small turns and steps. For example:

This looks very much like a circle, but it's really a polygon with 360 sides, all of length 1 step.
In particular, you can apply facts about circles to these Snap! approximations, and they work quite well. For example, in the Take it Further challenge, the diameter of the red circle is 100. The circumference (perimeter) of a circle is π times its diameter. If your students know this fact, then they can reason that the circumference of the red circle is 100π. Using the approximation 3.14 for π, the circumference is approximately 314. So, if we want to cover this distance in 360 steps, the step size should be $\frac{314}{360}$ . Snap! can do the calculation for us.

	Josef Albers	Vassily Kandinsky	Kazimir Malevich	Alma Thomas
original
BJC

Lab 3: Modern Art with Polygons