Table of Contents


  1. Creating the Abstraction Journal

  2. Intro to Algorithms

  3. Intro to Boolean Logic

  4. Intro to Binary Numbers

  5. Algorithms: Sequencing, Selection, Iteration

  6. Abstraction

  7. Vocabulary from U1L2

  8. Developing an Algorithm to Make Shapes

  9. Explanation of Explore Task

  10. Grade Your Own Explore Task
  11. Explore Task Questions
  12. More on Abstraction and HW Due October 27

  13. U1L3 Reflection Handouts

  14. Midterm Review

  15. Unit 2 Objectives

  16. Unit 2 Lab 1 Page 3 - HW Due November 6

  17. Managing Code with Multiple Levels of Abstraction
  18. Guide to Developing Algorithms and Daily Exit Ticket for Explore Task




General College Board Information





Preparing for the Create Task





Preparing for the Multiple Choice Exam



General Links




For those who want to learn more or finish projects early



       CS Fieldguide


Computing In the News Resources


*Credible Sources for Computing in the News Articles*


Please comment with resources that you use and we’ll add them!  (UK-centric but definitely still useful!)  (UK-centric but definitely still useful!)




DeBugging -


Project Reflection - Print a copy if you need it


What is Abstraction?

Abstracting something means to give names to things, so that the name captures the core of what a function or a whole program does.

One example is given in the book you reference, where it says

Suppose we’re working with turtles, and a common operation we need is to draw squares. “Draw a square” is an abstraction, or a mental chunk, of a number of smaller steps. So let’s write a function to capture the pattern of this “building block”:

Forget about the turtles for a moment and just think of drawing a square. If I tell you to draw a square (on paper), you immediately know what to do:

  • draw a square => draw a rectangle with all sides of the same length.

You can do this without further questions because you know by heart what a square is, without me telling you step by step. Here, the word square is the abstraction of "draw a rectangle with all sides of the same length".

Abstractions run deep

But wait, how do you know what a rectangle is? Well, that's another abstraction for the following:

  • rectangle => draw two lines parallel to each other, of the same length, and then add another two parallel lines perpendicular to the other two lines, again of the same length but possibly of different length than the first two.

Of course it goes on and on - linesparallelperpendicularconnecting are all abstractions of well-known concepts.

Now, imagine each time you want a rectangle or a square to be drawn you have to give the full definition of a rectangle, or explain lines, parallel lines, perpendicular lines and connecting lines -- it would take far too long to do so.

The real power of abstraction

That's the first power of abstractions: they make talking and getting things done much easier.

The second power of abstractions comes from the nice property of composability: once you have defined abstractions, you can compose two or more abstractions to form a new, larger abstraction: say you are tired of drawing squares, but you really want to draw a house. Assume we have already defined the triangle, so then we can define:

  • house => draw a square with a triangle on top of it

Next, you want a village:

  • village => draw multiple houses next to each other

Oh wait, we want a city -- and we have a new concept street:

  • city => draw many villages close to each other, fill empty spaces with more houses, but leave room for streets
  • street => (some definition of street)

and so on...

How does this all apply to programmming?

If in the course of planning your program (a process known as analysis and design), you find good abstractions to the problem you are trying to solve, your programs become shorter, hence easier to write and - maybe more importantly - easier to read. The way to do this is to try and grasp the major concepts that define your problems -- as in the (simplified) example of drawing a house, this wassquares and triangles, to draw a village it was houses.

In programming, we define abstractions as functions (and some other constructs like classes and modules, but let's focus on functions for now). A function essentially names a set of single statements, so a function essentially is an abstraction -- see the examples in your book for details.

The beauty of it all

In programming, abstractions can make or break productivity. That's why often times, commonly used functions are collected into libraries which can be reused by others. This means you don't have to worry about the details, you only need to understand how to use the ready-made abstractions. Obviously that should make things easier for you, so you can work faster and thus be more productive:


Imagine there is a graphics library called "nicepic" that contains pre-defined functions for all abstractions discussed above: rectangles, squares, triangles, house, village.

Say you want to create a program based on the above abstractions that paints a nice picture of a house, all you have to write is this:

import nicepic

So that's just two lines of code to get something much more elaborate. Isn't that just wonderful?


slides + add metacognition questions