Unit 2 Lab 3 Teacher Guide

Students build various predicates (examples below) and use them with keep to perform various queries on a list of words to solve a crossword puzzle.
does (orange) have (6) letters? reporting true

does (orange) have (6) letters? reporting true

is letter (4) of (carrot) the letter (o)? reporting false

Predicates are reporters that report only Boolean values: true or false. Students have used predicates with conditionals such as if and repeat until.

Students learn to build new predicates by combining basic predicates (like = or >) with operations like length of or letter 1 of, or the mod block (which reports the remainder when a number is divided by another).
(17) mod (5) reporting 2

Then they learn to combine their predicates into more complex predicate expressions using Boolean operators (and, or, and not), so that they can select list items that meet multiple criteria.

Pacing

Lab Pages

Page 1: What's a Predicate?
- Learning Goals:
  - Formalize understanding of predicates and conditionals.
  - Use relational operators with conditionals to control the colors in a drawing project.
- Tips:
  - If students have trouble with the making the sprite draw only if the mouse button is down but their code looks fine, make sure they have unchecked the "draggable" box above the scripting area (as shown at right).
Page 2: Combining Predicates.
- Learning Goals:
  - Learn about, use, and interpret expressions with Boolean functions (and, or, and not).
  - Develop several versatile predicates: ≤, ≥, ≠, and between?.
  - Compare different correct algorithms for the same task (≥).
- Tips:
  - In English, "or" can be either inclusive (meaning and/or) or exclusive (meaning one or the other, but not both) as the examples on the lab page describe. In computer science, or is inclusive (if either or both of the inputs are true, the result is true), and a separate function, xor (pronounced x-or, for "exclusive or"), is used when two true inputs must result in a false output. Exclusive or is not included in Snap! and is not taught in BJC. Only two (and and or) of the 16 possible Boolean operators are included. Interested students may wish to do additional research on the other Boolean operators (such as nand meaning not (and); xnor meaning not (xor), etc.).
  - Technically, an operator is a function of two inputs, like +. Snap! uses the term loosely, so not everything in the "Operators" palette is a two-input function. So, technically, not isn't a operator.
Page 3: Combining Conditionals.
What is this commented out text about? --MF, 5/27/20
- Learning Goal: What is the primary difference between the first two examples of ways to define ≥ (shown below)? The goal of this discussion is for students to see that a good optimization is that you never need to program if some predicate report (true) else report (false), you can just do report (some predicate).
  
  After we finish the standards, we might go back and copy these images and draw circles around the relevant parts in the copies. --MF, 8/15/19
Page 4: Boolean Expression Experiments.
- Learning Goals:
  - Interpret and design expressions using Boolean and arithmetic operators.
  - Practice using and, or, and not.
- Tips:
  - Before solving the problems on this page, students must know that x coordinate goes left to right and is positive to the right of center and that the y coordinate goes up and down and is positive above the center. It's not important to know the precise dimensions of the stage.
  - Consider doing the first two problems with the whole class and then asking what the picture would look like if the and block in the second problem were replaced with or.
  - Picture "i" shows a parabola. Students who recall this curve from algebra may notice that one of the expressions has an ((x position) ^ 2) in it.
  - It's not until rather late on the page that students are told to load the corresponding project. This is because the previous exercises are meant to be done off the computer.
  - Students don't need to replicate the precise coordinates of the change in colors when asked to invent Boolean expressions to generate specific pictures. If they get roughly the right shape, they have the idea.
  - Don't let students get hung up on the use of random positions in the script. That's just a way to get the pattern to emerge visually when only a fraction of all the points have been colored. We could instead have used the script
    
    These images need alt/title text. Brian? --MF, 8/28/19
    
    The "pointillist" pictures look interesting, too.
  - The Take It Further challenges are quite hard, but they'll give students the understanding that this style of painting can produce nontrivial patterns.
Page 5: Keeping Items from a List.
- Learning Goals:
  - Understand that the keep block uses predicates to select items from a list.
  - Practice using keep.
- Tips:
  - Ask students to articulate the basic idea of the keep block: It's a reporter that takes a predicate and a list as input, and it reports only the items from the list that meet the criteria specified by the predicate. The predicate itself must have a blank for the list items to cycle through.
Page 6: Solving a Word Puzzle.
- Learning Goals:
  - Build several predicate blocks by constructing predicate expressions for specific cases first and then generalizing.
  - Use these new predicate blocks to solve a word puzzle.
- Tips:
  - Students may need to be reminded that all the words in the word puzzle are related to AP CSP vocabulary.
  - Students may find the linked Google Sheet version of the word puzzle helpful in keeping track of their progress.
- Resources:
  - Word Puzzle as Google Sheets and as printable PDF.
  - https://crosswordlabs.com/ was used to create the image on the student page. You may find it useful to develop other CS crossword puzzles for students to solve using their predicate blocks.

Solutions

Correlation with 2020 AP CS Principles Framework

Computational Thinking Practices: Skills

1.D: Evaluate solution options.
2.B: Implement an algorithm in a program.
4.B: Determine the result of code segments.

Learning Objectives:

AAP-2.C: Evaluate expressions that use arithmetic operators. (4.B)
AAP-2.E: For relationships between two variables, expressions, or values:
1. Write expressions using relational operators. (2.B)
2. Evaluate expressions that use relational operators. (4.B)
AAP-2.F: For relationships between Boolean values:
1. Write expressions using logical operators. (2.B)
2. Evaluate expressions that use logic operators. (4.B)
AAP-2.H: For selection:
1. Write conditional statements. (2.B)
2. Determine the result of conditional statements. (4.B)
AAP-2.I: For nested selection:
1. Write nested conditional statements. (2.B)
2. Determine the result of nested conditional statements. (4.B)
AAP-2.L: Compare multiple algorithms to determine if they yield the same side effect or result. (1.D)

Essential Knowledge:

AAP-1.C.3: An index is a common method for referencing the elements in a list or string using natural numbers.
AAP-1.C.4: A string is an ordered sequence of characters.
AAP-2.A.4: Every algorithm can be constructed using combinations of sequencing, selection, and iteration.
AAP-2.B.1: Sequencing is the application of each step of an algorithm in the order in which the code statements are given.
AAP-2.E.2: The exam reference sheet provides the following relational operators:
```
=, ≠, >, <, ≥, and ≤
```
.
- ```
a = b
```
- ```
a ≠ b
```
- ```
a > b
```
- ```
a < b
```
- ```
a ≥ b
```
- ```
a ≤ b
```
These are used to test the relationship between two variables, expressions, or values. A comparison using a relational operator evaluates to a Boolean value. For example,
```
a = b
```
evaluates to
```
true
```
if
```
a
```
and
```
b
```
are equal; otherwise, it evaluates to
```
false
```
.
AAP-2.F.1: The exam reference sheet provides the logical operators
```
NOT
```
,
```
AND
```
, and
```
OR
```
, which evaluate to a Boolean value.
AAP-2.F.2: The exam reference sheet provides
```
NOT condition
```
, which evaluates to
```
true
```
if
```
condition
```
is
```
false
```
; otherwise it evaluates to
```
false
```
.
AAP-2.F.3: The exam reference sheet provides
```
condition1 AND condition2
```
, which evaluates to
```
true
```
if both
```
condition1
```
and
```
condition2
```
are
```
true
```
; otherwise it evaluates to
```
false
```
.
AAP-2.F.4: The exam reference sheet provides
```
condition1 OR condition2
```
, which evaluates to
```
true
```
if
```
condition1
```
is
```
true
```
or if
```
condition2
```
is
```
true
```
or if both
```
condition1
```
and
```
condition2
```
are true; otherwise it evaluates to
```
false
```
.
AAP-2.F.5: The operand for a logical operator is either a Boolean expression or a single Boolean value.
AAP-2.G.1: Selection determines which parts of an algorithm are executed based on a condition being
```
true
```
or
```
false
```
.
AAP-2.H.1: Conditional statements or “if-statements” affect the sequential flow of control by executing different statements based on the value of a Boolean expression.
AAP-2.I.1: Nested conditional statements consist of conditional statements within conditional statements.
AAP-2.L.1: Algorithms can be written in different ways and still accomplish the same tasks.
AAP-2.L.3: Some conditional statements can be written as equivalent Boolean expressions.
AAP-2.L.4: Some Boolean expressions can be written as equivalent conditional statements.
AAP-2.L.5: Different algorithms can be developed or used to solve the same problem.

Lab 3: Making Decisions