Communicating About Your Project

On this page, you will reread the Create Task guidelines and then develop your video and written response.

Until this point you may have been programming with a partner. For the video and the written portion of the Create Task, you will have to work alone.
  1. Once you have completed your program, reread the guidelines, focusing on the video and the written response. Discuss any questions you have with your classmates or teacher.
  2. If you are working on the practice Create Task, decide how you are going to create your video and learn to use the technology well enough that you are comfortable doing it along. That way, when you complete the official Create Task, you don't have to think about how to make the video; you can just focus on making it meet the guidelines.
    3. CRD-2.B.5
  3. Develop your video to show what input the program takes, what it does, and what it outputs. You can't include any audio, but it will help the grader see how you've met the guidelines if you include some text.
    4. CRD-2.B.5
  4. Develop your written response to describe:
    1. The purpose of your program
    2. What your video shows
    3. How your program uses a list as an abstraction to manage complexity
    4. What one algorithm in your project does and how it works

    5. Showing Your Code

    Snap! has two convenient ways to get image files of some or all of your code:

    • Creating Script Pics

      You can download a PNG image file of any block or script by right-clicking it (or control-clicking it on a Mac) and selecting "script pic..." Look in your browser's Downloads folder for the image file.

      If you shift-right-click (or shift-control-click) on a reporter block, you can get a script pic of the reporter with its report bubble showing.
      image of pinwheel block definition with right-click drop-down menu showing and mouse over 'script pic...' There is a balloon showing above the pointer that says, 'open a new window with a picture of this script'

    • Exporting All the Images at Once

      You can download an HTML file of all of the blocks in your whole project as well as a picture of the stage by selecting "Export summary..." from the Snap! File menu (File button). The HTML file also lands in your browser's Downloads folder. Open it (in a browser), right-click (or control-click on a Mac) to copy the images you need, and paste them into the document where you are describing your code.
      image of Snap! file menu open with mouse over 'Export summary...' There is a balloon showing above the pointer that says, 'open a new browser browser window with a summary of the project'

    Commenting this out for now because things appear to be changing... --MF, 8/31/19

    Describing Abstraction and Algorithm

    You've been creating algorithms and using abstraction all year. All you need to know for the Create Task is how to call attention to and describe what you've done:

    • Algorithm

      In Unit 1, you created an algorithm for drawing this pinwheel shape:
      image of pinwheel drawn in Snap!

      The shape consists of eight line segments, each the same length. The first segment is 100 steps long. To prepare for the next segment, the sprite backs up 70 steps along the first segment and turns 45 degrees to the right. Each new line segment follows the same pattern: move 100, move -70, turn 45. It could be written using eight sets of those three blocks (24 blocks total), but that would be hard to read and hard to see whether all the blocks are there. Using repeat makes the algorithm clearer, briefer, and easier to read. This is how the algorithm is now expressed:
      repeat (8) {move (100) steps, move (-70) steps, turn clockwise (45) degrees}

      Your program for the AP task will have different algorithms (stretches of code that accomplish a particular purpose), and you can point to any chunk of code like that in your program as an example of an algorithm.
    • Abstraction

      The last step shown under Algorithm, using repeat to clarify the structure is also a simple example of abstraction. It hides a lot of repetitive detail and shows the structure better. This type of abstraction is not what the AP Create Task is looking for though.

      You used another abstraction as well. The way you actually wrote the algorithm in Unit 1 recognized that the 45° turn was \frac{1}{8} of the total turning of 360°. So you wrote the algorithm this way:
      repeat (8) {move (100) steps, move (-70) steps, turn clockwise ((360) / (8)) degrees}

      Changing both eights to fives in that algorithm would create a pinwheel with 5 branches. Instead of changing the numbers each time you wanted a new pinwheel, you created a block that contained the algorithm and let you just input whatever number of branches you want:
      pinwheel, branches: (number of branches): {repeat(number of branches) {move (100) steps, move (-70) steps, turn clockwise (360/number of branches) degrees}}

      This is the kind of example you need to show for the Create Task: a custom block used multiple times in your project. Loops are an example of abstraction, but the expectation for the Create Task is that you create and submit your own example of abstraction rather than just pointing out existing abstractions like loop blocks.

      The abstraction of pinwheel helps in three ways:

      1. It saves you from having to change two numbers each time you use the code, which is prone to error (such as accidentally changing only one of them but not the other).
      2. Instead of putting all this code
        repeat (8) {move (100) steps, move (-70) steps, turn clockwise ((360) / (8)) degrees}
        in your program everywhere you want it to draw a pinwheel, you now need only
        pinwheel, branches: (8)
      3. Your code is easier for someone else to read, because it now says what it does: it makes a pinwheel with 8 branches.

      When you create a block and give it a name that describes its purpose, you are creating an abstraction. You are hiding the details and showing only the purpose. When you use that pinwheel block, it shows the structure of your program more clearly. Someone reading your program doesn't need to figure out what the details inside pinwheel do; they can tell from the name that it makes a pinwheel with a given number of branches.

      Note that while packing your entire program into a single block might the page cleaner, it is not a good example of abstraction. The best examples of abstraction to highlight for the AP are pieces of code that you use multiple times in your program and are clearer because they are packed into a well-named block. You can often use what's in that block as an example of the algorithm for the purpose that the block serves.