Unit 2 Lab 4: Making Computers Do Math, Page 2

Using libraries simplifies the development of new programs. When you use procedures that you already know work correctly, you reduce the amount of time you need to spend coding, the number of possible bugs your code can have, and how much of your project you need to test.

You can create algorithms from scratch or by combining or modifying existing algorithms. When you are thinking of using existing code, you can either use your own code or use code from someone else's library.

AAP-2.M parts a and b
Develop a block (using keep), and use it to answer these questions:
- What kinds of numbers have an odd number of divisors?
- What kinds of numbers have exactly two divisors?
You can do this on your own or follow these steps.
1. Build a divisors block using keep.
  Hints about building the divisors block
  You could build this with for or for each, but it will require less code to build it with . (You learned about keep on Unit 2 Lab 3 Page 5: Keeping Items from a List.)
  
  You could build this with mod, but you already built (using mod), so divisible by? will be simpler to use.
  
  The block may be helpful.
2. Build a number of divisors block.
3. Build an expression using keep to answer each of these questions that were introduced above:
  - What kinds of numbers have an odd number of divisors?
  - What kinds of numbers have exactly two divisors?

You've now made a small library, and you might want to write a list of instructions for how to use the functions in your library (for example, divisors of takes a positive integer as input and reports a list of numbers). The instructions form an Application Program Interface for the library.

Don't cut this commented out text about PIPE until we are all set with the pipe into in U5. --MF, 8/28/19

I'm not convinced the following works here. It's a lot of text and "talking about" how pipe works. I don't believe it's going to work as a pre-teaching for 5.3 because they are likely to forget stuff, so the question is: what does it offer here? And can we do it better? For that matter, is divisors even a particularly elucidating example of using pipe? What if we offered it in the TG and combined the stuff before this todo with the MOD stuff on the previous page? Or maybe keep the two pages separate for the sake of breathing room, but move some of the quizlets and review questions at the end of that page to the end of this page (e.g. #7-9)... --MF, 8/12/19

Nested functions (that is, functions used inside of other functions, like the way you used divisible by? and numbers inside of keep) can be hard to read. Snap! offers another way to write code with multiple functions. You can use the pipe () → () function from the "Frequency Distribution Analysis" library to write your code one function at at time.

image needs alt/title tags --MF, 6/11/19

The pipe function sends input number through numbers from (1) to () to report a list of numbers and then that list goes through keep items such that ((input number) divisible by ()?) from () to get the numbers from that list that are divisible by the input number.

Notice that the empty input slots in each function are filled by the output of the previous function (or filled by the starting data in the case of the first function):

The empty slot in the function is filled by input number.
The empty list input slot () in is filled by the output of numbers.

As usual, the blank input slot in the predicate for keep (that is, in ) is filled by each item of keep's input list (here, the output of numbers) so that keep can decide whether each number will be kept.

It's like a pipe of made of pieces connected together; the input number goes in one end and works through each function, producing a new output at each step.

I find this description painful. If we're going to teach pipe at all, what's needed here is a CS-Illustrated-style picture with a specific number as input and then all the intermediate values shown with arrows pointing to which empty slot each one fills. But, why do this? Is the theory that pipe will be easier for most kids than nesting? And if so, wouldn't it be easier still to make a bunch of script variables and set each one to the result of one function call? And then show how that turns into a pipe. Or do it instead of pipe. -bh

Brian means some kind of horizontal diagram: 8 -->1, 2, 3, 4, 5, 6, 7, 8 --> 1, 2, 4, 8 --MF, 1/15/20

Pipe is a higher order function; it is a function that takes functions as input. You've seen a higher order function before: keep (in Unit 2 Lab 3).

Look at the pipe version of divisors above. What would happen if you did keep before numbers?
Choose "Libraries..." in the Snap! file menu (), and select and import the "Frequency Distribution Analysis" library.
Rebuild your number of divisors block using the pipe function.
You can either create a new function called something like number of divisors 2 or pipe version of number of divisors, or you can rewrite the same block and just drag off the original report instruction but leave it inside the number of divisors block unattached from the hat block so will be saved in there but it won't run.

You don't ever have to use pipe again, but if you find it hard to write a function with a bunch of nested reporters, you can always import pipe again.

Making a Mathematical Library

Exporting Blocks

Importing Blocks

Debugging Dependencies