Exam 1 Review Information

Topics

Exam #1 will cover material from the first 3-4 weeks of the course: pathnames, sketch structure and static vs active mode, drawing, interaction, animation, and two key patterns of change (steady motion and acceleration/deceleration). Other patterns of change (such as Perlin noise and constrained motion), functions, and conditionals will not be on this exam.

In particular, you should expect to see the following topics:

• core concepts — algorithmic thinking and fundamentals of drawing, interaction, and animation
  • decomposing a scene into primitives — what shapes will you draw? — and the basic primitives available in Processing (rectangles, ellipses, lines, triangles, arcs)
  • figuring out size and coordinates for shapes to build a scene
  • what RGB color is, the RGB representation for common colors (black, white, light gray, dark gray, red, green, blue, purple, yellow), and notion of how to figure out the RGB representation for other colors (e.g. what would be a darker or lighter shade of a particular color)
  • the difference between static and active sketches, the notion of an active mode sketch as a series of frames, and when to use each
  • what interaction and animation are and the difference between them
  • forms of interaction (using mouse position, event-driven)
  • identifying animation variables and the notion of representation
  • types of motion/change: steady motion vs acceleration and deceleration — what each is
  • the application of steady motion, acceleration, and deceleration to animating size, color, and other properties (not only position)
  • terminology (definitions): variable, expression, type
• programming elements — specific Linux and Processing elements
  • reading and writing pathnames
  • the structure of static mode and active mode sketches (writing setup() and draw() and what goes into each, opening a drawing window)
  • the elements of drawing (background(), fill()/stroke(), ellipseMode/rectMode, primitives — rectangles, ellipses, lines, triangles, arcs)
  • implementing a sketch involving interaction
  • implementing a sketch involving animation
  • working with variables: declaration, initialization, use, and update
  • int vs float
  • use of system variables width and height
  • use of system variables mouseX and mouseY
  • use and implementation of mouseClicked
  • the implementation of steady motion, acceleration, and deceleration

Format and Types of Questions

The exam will be in class, written (not on the computer), and closed book. You may have a single page of notes (8.5x11", one side) which will be handed in with your exam. This page may be handwritten or typed and can contain whatever you would like, but it must be a hardcopy — on a piece of paper, not a laptop, tablet, phone, or other device — and must be personally prepared by you — you may not copy another student's page or hand out copies of yours to others. Creating your own notes is an essential part of the learning process — deciding what to include requires engagement with the material which reinforces understanding and improves long-term retention of the material, provides an opportunity for review in order to identify gaps in your knowledge in time to ask questions before the exam, increases confidence in what you do know, and encourages taking ownership of your own learning.

For core concepts, expect short answer types of questions and questions similar to those on the in-class and lab worksheets. You should definitely expect to be asked to label pictures with the coordinates and sizes needing to draw the scene and to answer the animation questions for specific scenarios as was done on the worksheets for labs 2 and 3.

For programming elements, you will be asked to write code — this may take the form of writing a few lines of code to accomplish a specific thing or writing an entire (but short) sketch. You should be familiar with the syntax of the elements outlined in the topics above. You are expected to have correct syntax in any code written, but because you don't have the computer to point out problems, there is some leniency — the occasional small mistake such as a forgotten semicolon won't be penalized, but frequent mistakes of the same type or large errors that indicate a lack of understanding or knowledge of a particular syntax element will count against you.

How to Study

The best way to study for the exam is to practice as much as you can — work on the revise-and-resubmit for the labs if there are things you missed, and work on in-class exercises that you didn't get to or didn't finish in class for additional practice. Include both the worksheets and writing code in your practice.

To be fully prepared for the exam, you should know what to do for each question and be able to immediately start solving each problem — while being able to work out a solution eventually is an important fundamental, proficiency means that you are familiar with what to do and are able to spend your time constructing a solution rather than having to figure out how to go about solving the problem in the first place.