Section 1 – Brief Course Description
In 2009, the College Board, in partnership with the National Science Foundation,
received a grant to prototype the development of this new course, titled AP
Computer Science: Principles. The course will introduce students to programming
but will also give them an understanding of the fundamental concepts of computing,
its breadth of application and its potential for transforming the world we live in. It is
rigorous, engaging and accessible. Computer Science Principles is a proposed AP
course under development that seeks to broaden participation in computing and
computer science. This course covers/explores many important concepts in
computing such as, storyboarding (flowcharts), object oriented and event driven
programming, how to create an use world/object methods, use of parameters,
functions and If/Else statements, Boolean functions, randomness, loops and
conditional loops, recursion, list search and list processing, variables, debugging,
and array visualization using an index variable.
Section 2 – Textbooks/Supplemental Instructional Materials
Textbook: Learning to Program with Alice (3rd Edition)
Publication Date: March 7, 2011
Publisher: Prentice Hall
Authors: Wanda P. Dann, Stephen Cooper, Randy Pausch
ISBN 978-0-13-208516-8
The text will be read entirely over the duration of the course.
When/how/why this text is used is integrated in the key assignment section
The class, Computer Science Principles is modeled after the CSE 3 course
(informational fluency), taught at University of California San Diego by Professor
Beth Simon. This course uses the same textbook and is a required class for all nonengineering freshman at the university.
Supplemental instructional materials:
Website: Expeditions through Alice
https://sites.google.com/a/eng.ucsd.edu/expeditions-through-alice/
Website is read in entirely over the duration of the course.
When/how/why this text is used is integrated in the key assignment section
Section 3 – Course Purpose
This course is designed to provide the student with the analytical and logic skills to
understand and apply computational logic and processes to the understanding and
use of basic programming (using Alice) and the ability to explain the logic behind
basic sequencing of functions in programs such as Excel. The emphasis in this
course is the ability of the student to understand the logic behind the actions of the
computer, the analytical skills to be able to explain the logic or the errors in the
logic, and the communication skills to explain the logic to peers and instructors. This
course is rigorous and rich in computational content, and includes computational
and critical thinking and skills, while engaging students in the creative aspects of the
field. Through both its content and pedagogy, this course aims to appeal to a broad
audience.
CS Principles – Section 4
Unit 1 – Getting Started With The Alice Programming Environment
Major themes to be covered:
Introduction to Alice
Alice Concepts
Text and 2D Graphic Images
Alice is a 3D programming environment that makes it easy to create an animation
for telling a story, playing an interactive game, or a video to share on the web. Alice
is a freely available teaching tool designed to be a student's first exposure to objectoriented programming. It allows students to learn fundamental programming
concepts in the context of creating animated movies and simple video games. In
Alice's interactive interface, students drag and drop graphic tiles to create a
program, where the instructions correspond to standard statements in a production
oriented programming language, such as Java, C++, and C#. By manipulating the
objects in their virtual world, students gain experience with all the programming
constructs typically taught in an introductory programming course.
Alice allows students to create cartoon-like animations of objects. The objects are
three dimensional, having width, height, and depth. Each object has an orientation
that provides a sense of direction. That is, an object “knows” which way
Is up, down, left, right, forward, and backward relative to itself.
A computer program can be thought of as a sequence of instructions that tell the
computer what to do. Importantly a computer program is also a way to tell another
human being what you want the computer to do. Learning to think about arranging
a sequence of instructions to carry out a task (how to design a program) is probably
the most important part of learning to program.
Students will be shown the interface and basic operations such as importing objects,
methods, how to order and modify instructions, and execute the code. Students will
be shown some examples of what is possible with Alice as well as how to insert text
and 2D images into their worlds (billboards).
Learning Goals and Outcomes:
Students will understand that learning to program is actually learning how to think
about arranging a sequence of instructions to carry out a task. Students will
understand that a program is a sequence of instructions that tell the computer what
to do. It is a also a sequence of instructions that tell another human being what you
want the computer to do. In Alice, the animation of 3D objects takes place in a
virtual world. Students will know that Alice provides a huge number of 3D models.
Furthermore, an Alice object has a unique center set by graphic artist when the 3D
model is first created. The center of the ground in an Alice world is located at the
position(0, 0, 0). Students will know how to insert text know how to insert text and
the how to use billboards (2D images).
Unit 2 - Program Design and Implementation
Major themes to be covered
Scenarios and Storyboards
Orientation and movement instructions
Translating a written description/scenario into Alice code
Fundamental concepts of Alice will be introduced. Students will begin with reading
scenarios and designing a storyboard. A scenario helps programmers set the stage.
It will tell them what objects will be used and what actions they will perform.
Students will be shown how to break down a scenario into a sequence of scenes that
provide a sense of the order in which the actions will take place. The resulting
storyboards can be used as a guide for the implementation (writing the code).
Finally, Testing code (writing the program) will be an important step in finding and
removing bugs (errors in the program). Students will be shown how to use
comments to explain their coding.
Learning Goals and Outcomes:
Students will understand that a scenario is a problem statement that describes the
overall animation in terms of what problem needs to be solved. Students will
understand that storyboards can be visual or textual. A visual storyboard is a
sequence of hand-drawn sketches or images that break down a scenario into a
sequence of major scenes with transitions between scenes. Each sketch represents a
state of the animation – sort of a snap-shot of a scene – showing the position, color,
size, and other properties of objects in the scene. A textual storyboard is more like a
to-do list, providing and algorithmic list of steps that describe sequential and/or
simultaneous actions.
Students will understand that a program consists of lines of code that specify the
actions objects are to perform. The characters that are used in Alice are known as
objects. Students will understand that we write program statements to make the
objects move by dragging their action instructions (methods) into the editor. Also
students will understand that within the Alice programming environment that code
is structured in Do in order and Do together blocks to tell Alice which instructions
are to be executed in order and which are to be executed simultaneously.
Complicated animations may be constructed from simple compositions of Do in
order and Do together blocks of code. Knowing what each means and knowing how
to combine them (by nesting on inside the other) is powerful; it provides an easy
way to put together more complicated actions.
Unit 3 - Programming: Putting Together the Pieces of Program Code to Create
Programs
Major themes to be covered: Built-in Functions and Expressions:
Simple Control Structures
Camera and animation controls
Objects Oriented and Event driven Programming Concepts
Students will be introduced to the different types of “pieces” of program code such
as:
Instructions – statements that execute to make objects perform a certain action
Control structures – a statement that controls the execution of instructions
Functions - asks a question about a condition or computes a value
Expressions – a math operation on numbers or other kinds of values.
The Alice programming environment provides the students built-in functions for the
World and for objects within. Students will be shown how expressions will allow
them to compute a value or preform a comparison of some property of two objects.
Understanding that one of the uses of functions and expressions in an animation
program is to help avoid collisions (when an object moves into the same position as
another object).
Students will be shown how to use the built-in functions and Boolean expressions to
check the current condition in their world (program) and make decisions about
whether (or not) a section of the program will be executed. The students will learn
that within the Alice programming environment, that the conditional execution
control structure is the If/Else statement. An If statement has two parts: the If part
and the Else part. In the If part, a condition is checked and a decision is made
depending on the condition is true, the If part of the If/Else statement is executed.
Otherwise, the Else part of the statement is executed. It is possible that the Else part
of the statement may be Do nothing, in which case no action is taken. Also that the
simple repetition control structure is the Loop. A Loop statement allows you to
repeat a section of program code a counted number of times.
Learning Goals and Outcomes:
Students will understand that functions can be used in Alice to ask questions about
properties of the World or properties of an object within it. Also that functions can
also be used compute a value. Students will know that when a function is called, that
it returns a particular type of value. For example, a Boolean function returns either
true of false.
Students will understand that an expression may use an arithmetic operation
(addition, subtraction, multiplication, division) to compute a numeric value.
Students will understand that another kind of expression compares one object to
another, using relational operators (==, !=, >=, <, <=) and the result is true of false.
The conditional execution control structure (within Alice, an If/Else statement) is
used to make a decision about whether a particular section of the program will be
executed. Lastly, that a repetition control structure is used to repeat a section of
program code again and again. For example, a simple repetition control in Alice is
the Loop statement.
Unit 4 - Classes, Objects, Methods and Parameters
Major themes to be covered:
World-Level Methods
Parameters
Object-Level Methods and Inheritance
Properties; visible and invisible objects
Students will learn how to write their own methods and how to use parameters to
send information to a method when it called. An advantage of using methods is that
the programmer can think about a collection of instructions as all one actionabstraction. Also, methods will make it easier for the students to debug their code.
Two different kinds of methods can be written: world-level methods that involve
two or more objects interacting in some way, and object-level methods that define a
complex action carried out by a single object acting
Students will be shown that parameters are used to communicate values from one
method to another. In a method, a parameter acts as a placeholder for a value of a
particular type. Furthermore, when an argument is sent in to a method, the
parameter represents that argument in the instructions in the method. Students will
be exposed to and practice working with object, sound, string, and numbers, and
other types of values.
Students will be shown that methods can be thought of as extending an object’s
behavior. Once new object-level methods are defined, a new class can be saved out.
The new class has a different name and has all the new methods (and also the old
methods) as available actions. It inherits the properties and actions of the original
class but defines more things than the original class. A major benefit is that you can
use objects of the new class over and over again in new worlds. This major benefit is
that the students can use objects of the new class over and over again in the new
worlds. This allows you to take advantage of methods you have written without
having to write them again.
Students will be exposed to guidelines for writing object-level methods: only sounds
imported for the class should be played in a object-level method; world-level
methods should not be called; and instructions involving other objects should not be
used. Following those guidelines will help ensure that objects of their newly defined
classes be safely be used in other worlds.
Stepwise refinement will be covered, which is a design technique where a complex
task is broken down into small pieces and then each piece is broken down further –
until the entire task is completely defined by simple actions. The simple actions all
work together to carry out the complex task.
Learning Goals and Outcomes:
Students will be master the concept of how to run (or execute) a method, and that
this requires that the method must be called. In a call to a method, a value sent in to
a method parameter is an argument.
Parameters are used for communication with a method. Students will understand
that a parameter must be declared to represent a value of a particular type. Types of
values for parameters include object, Boolean (“true” or “false”), number, sound,
color, string, and others.
Students will be able to create new classes by defining object-level methods and
then saving out the class with a new name. The concept of inheritance, which is an
object-oriented concept where a new class is defined based on an existing class will
by understood.
Students will understand that object-level methods can be written that accept object
parameters. This allows programmers to write a object-level method and pass in
another object. Then, the object performing the object-level method can interact
with the parameterized object.
Unit 5 – Interaction: Events and Event Handling
Major Themes to be covered:
Interactive Programming
Parameters and Event Handler Methods
Creating your own models
Students will focus on the creation of interactive (event-driven) worlds. Creating
worlds with events will allow them to build significantly more interesting worlds
(programs), such as game like animations and simulations. Just like many other
object-programming languages, event-driven programming requires knowledge of
advanced of topics. Students will be able to use the Events Editor to create events
and link them to event handling methods. The event handling method has the
responsibility of taking action each time the event occurs. The Events Editor will
handle many of the messy details of event-driven programing and will allow
students not be held back syntax structures.
Learning Goals and Outcomes:
Students will understand that an event is something that happens (usually a user
interaction). Events are created by user input such as a keyboard press, mouse click,
joystick movement) and that evens are linked to an event handling method. The
concept that each time an event occurs, its corresponding event handling method
will be practiced and understood. Students will understand that this is what is
meant by event-driven programming.
Students will understand that an event handling method contains instructions to
carry out a response to the event and that a parameter can be passed to an event
handling method when an event occurs. The idea of incremental development will
be covered and practiced. Incremental development is a skill used by programmers
where they will write and test a small piece of code, then write another small bit of
code and test, and so on until the entire program is completed. Incremental
development is a technique that will make it easier for the students to debug their
work.
Unit 6 - Using Functions and Control Statements
Major Themes to be covered:
Functions and If/Else
Functions
Execution Control with If/Else and Boolean Functions
Random numbers and random motion
Students will be shown different ways to use functions and If statements in
methods. In Alice, an If statement allows for the conditional execution of a section of
code (based on the value of a Boolean condition, true or false). The Boolean
condition is used to determine whether the If part of the Else part of the statement
will be executed at runtime. Thus, an If statement allows us to control the flow of
execution of a section of a program code.
The idea built-in functions do not always meet the particular needs of a program
will be covered. Students will be shown how to write functions that return different
types of values. The benefit of writing their own functions is it that they can think
about the task on a higher plane – a form of abstraction. The concept that functions
that compute and return a number value make program code much less cluttered
and easier to read, because the computation is hidden in a function will be
discussed. Such functions will be useful in many situations. For example, the
students could write a function to return the number of visible objects on the screen
in an arcade-style game.
Students will be shown how parameters can be used to allow a function to be used
with different objects. As with class-level methods, you can write a class-level
function and save it out with the object. This allows the function to be reused in
another program.
Learning Goals and Outcomes:
Students will be able to correctly use if statements. A If statement is a block of
program code that allows for the conditional execution of that code. Also, an If
statement contains a Boolean condition used to determine whether the segment of
code will execute. Students will understand that if the Boolean condition evaluates
to true, the If part of the statement is executed. If the expression evaluates to false,
the Else part is executed. Boolean conditions may call built-in functions that return a
true of false value.
Students will be able to use logical operators (and, or, not) to combine simple
Boolean expressions into more complex expressions. Students will understand that
relational operators (<, >, >=, <=, ==, !=) can be used to compare values in a Boolean
expression. Students will be able to write functions that return a Boolean value used
in If statements. Students will understand that functions can also be written to
compute and return other types of values.
Unit 7 - Repetition: Definite and conditional Loops
Major Themes to be covered:
Loops
While – a conditional loop
Events and repetition
Students will be introduced to concepts of Loop and While (conditional) as control
structures for repeating an instruction or block of instructions. A counted Loop
allows programmers to specify exactly how many times a block of code will be
repeated, and a While statement allows you to repeat a block of code as long as
some condition remains true. The advantage of using loops will be immediately
obvious to the students. Students will shown that they are easy to write and also
easy to understand. This will be a powerful tool that the students will be able to
incorporate into their code.
Learning Goals and Outcomes:
Students will be able to use counted Loop statements to repeat an instruction, or
block of several instructions. Students will grasp the concept that a key component
in a counted Loop is the count – the number of times the instruction within the loop
will be repeated. Also, that the count must be a positive whole number or infinity. A
negative value for the count would result in the Loop statement not execution at all.
Furthermore, students will understand that if the count if infinity, the loop will
repeat until the program shuts down.
Students will be able be able to use Do in order or Do together in a nested loop and
that that otherwise Alice will assume that the instructions are to be executed in
order. Students will understand that when a loop is nested within a loop, the inner
loop will fully execute each time the outer loop executes, once.
The students will understand that a While statement is a conditional loop as well as
the concept that the Boolean condition used for entry in a While statement is the
same as used in If statements. The difference is that the While statement is a loop,
and the condition is checked again after the instructions within the While statement
have been executed. If the condition is still true, the loop repeats. Lastly, If
statements can be combines with While statements. In some programs, a While
statement is nested within an If statement. In other situations, an If statement may
be nested within a While statement.
Unit 8 - Repetition: Recursion
Major Themes to be covered:
Introduction to Recursion
Another flavor of recursion
Engineering look and feel
Students will be introduced to the concept of using recursion as a mechanism for
repetition. Recursion is a powerful tool that programmers use for building more
complex and interesting worlds (programs). Recursion is often used where we do
not know (at the time a program is written) the number of times a block of code
should be repeated. There are two major situations where we do not know (even at
runtime, what the program first starts to run) the count of repetitions. The first is
when random motion is involved. Students will explore a type of recursion where
more executions of a section of program code are “generated” each time the result of
the previous decision is true. The second flavor of recursion will be demonstrated
about how a complex problem is broken down in simper and simpler versions. The
solutions to the smaller subproblems are used to cooperatively solve the larger
problem.
Learning Goals and Outcomes:
Students will understand that recursion is most useful when they cannot use a Loop
statement because they will not know (at the time they are writing a program) how
many loops iterations will be needed. Students will learn that recursion occurs
when a method calls itself and that recursion enables a method to be repeatedly
called. Furthermore, any recursive method must have at least one base case, where
no recursive call is made. When the base case occurs, the recursion stops. Students
will understand that when you use recursion, you generally do not generally also
use a loop statement (Loop or While). Instead, an If statement is used to check a
condition, and the decision to recursively call the method depends on the value of
the condition.
At this point in the course students have learned three ways for accomplishing
repetition in a program: Loop, While, and recursion. Students will be able to
critically look at a programming situation and decide the best course of action to
create repetition for the program that they are creating.
Unit 9 – Lists and List Processing
Major Themes to be covered:
Lists and List Processing
List Search
Grouping Objects
In programming, many different kinds of organizing structures can be used to create
a collection of objects or information about objects. Each kind of structure offers
different capabilities or features. In Alice, lists are used as organizing structures
(data structures). A list is a collection of several items of the same type (such as
Object or Color).
Students will be shown how to create a list as well as iterating through a list. Alice
provides two mechanisms for iterating through a list: sequentially (using For all in
order) and simultaneously (using For all together). The students will be shown that
the For all together iteration is like setting up a multiway telephone conference call
– everyone is on the line at the same time. The For all in order statement is similar to
Do in order in that actions are performed in sequence, and the For all together
statement is similar to Do together in that actions are performed simultaneously. A
common application of list is searching for an item in a list. A list search walks
through each item in the list, on at a time, until we find the one we want.
Learning Goals and Outcomes:
Students will understand that a list is a collection of items. The items in a list all
have the same type (such as Object). In Alice, objects in a list do not all need to be
instances, of the same model. For example, a student will understand that a list
containing five chickens is fine. A list containing three chickens and two dogs is also
fine, as both of these are the same type – in this case Object. Students will know that
a list can be iterated through either sequentially or simultaneously. If a list contains
objects, and each object is to perform some action, the list item is often passed as a
parameter to a method, where the object performs the action.
Unit 10 – Variables and Revisiting Inheritance:
Major Themes to be covered:
Variables
Array visualization using an index variable
Debugging with watch and text output
Students will review the use of properties to store information about an object in a
world. We call this state information. Students will be introduced to the
term/concept mute variable to describe those properties that can be changed at
runtime. The mutable variable presented to the students will be class-level. Classlevel variables keep track of information about a specific object.
Students will learn how to add a new class-level variable to an object and then save
out the object and its new variable to create a new class. This is a form of
inheritance similar to previous units, where students defined their own methods
and saved out the object and its new methods as a new class. The difference is that
previously the students extended a class by adding behavior (methods), but now
they extend a class by adding state information.
Array visualizations are created to illustrate the concept of an array structure. In
Alice, an array Visualization object has a built-in elements variable that tracks the
index (position) of each element in the array.
Learning Goals and Outcomes:
Students will understand that mutable variables can be useful for extending the
capabilities of a class. Like object-level methods, object-level variables are saved out
with the object and reused when instances of the new class are added to other
worlds. Students will know that an array structure organizes a collection of
elements. Each element is located in a particular position in the array. An array
index variable is used to refer to the location of an element in the array.
CS Principles – Section 5
Unit 1 – Key Assignments
Built in Alice tutorials 1-4: Prior to working the key assignments for unit 1,
students will read pages 5-18 and pages 331-361(appendix A/B) from the textbook
Learning to Program with Alice. Students will complete a series of Essential
Questions (p19, Learning to Program With Alice) aligned with text at the end of the
unit using classroom response systems to allow the instructor to gauge the level of
understanding and the opportunity to reteach any unclear concepts. For the first
unit students will work through a series of tutorials embedded within the software.
These are guided, interactive tutorials that introduce students to the software.
Students are shown basic concepts and then asked to do simple tasks themselves.
The tutorials give feedback to the student if they did something incorrectly and
allows them to revise their mistakes. These tutorials are broad in nature and give
the students an over/pre view about many of the concepts that they will learn
during the course of the class.
Key Assignments: Built
in Alice tutorials
Activity
Objective
Built-in Software
Tutorial 1:
Introduces students to the
Alice software interface
and basic operations.
Students will be given
guided practice on the
following topics and
concepts; how to open and
save worlds, importing,
placing, and sizing objects
in to the world, object tree,
drag and drop (graphical)
programming, executing a
program, examples of how
order of instructions
matter and how to modify
and or rearrange the
instructions, and
understanding primitive
methods for each object
work and how to apply
them to an object
Students will practice
creating methods. This will
be covered in depth later
in unit 4. Students will
practice creating, naming,
opening, and editing their
own methods with
guidance from the
software. Students will
practice calling world level
methods. Students will
practice controlling the
duration of an instruction.
Students will practice
working with the subparts
of an object (left or right
Students will understand
the Alice interface and
controls, how to import
objects, and how create
and modify a method.
Students will know how
to execute code as well as
save and open program
files.
Built-in Software
Tutorial 2:
Students will be able to
create methods for the
whole or subpart of an
object. Students will be
able to edit and call
methods as needed.
leg, or head of a person for
example) and learn that
they have their own
methods.
Built-in Software
Tutorial 3:
Students will practice
Students will be able to
creating and modify events create events for their
(user interactions that will worlds.
be covered in greater
detail later in the course).
Students will practice
creating events such as
clicking on an object and
having action trigger.
Built-in Software
Tutorial 4:
Students will practice
creating scenes. This will
prove useful when
students create
storyboards and then
program them in the next
unit. Students will create a
new world, practice
importing and copying
objects, positioning and
sizing them, as well as
control the camera (view).
Students will be
comfortable importing
and positioning objects
within their worlds.
Unit 2 – Key Assignments
Prior to working the key assignments for unit 2, students will read pages 22-57 from
the textbook Learning to Program with Alice. Next the students will work through
the guided and interactive materials from Chapter 1 – Telling A Story, Expeditions
Through Alice (web-based multimedia textbook companion materials). Students will
complete a series of Essential Questions (p58, Learning to Program With Alice)
aligned with text at the end of the unit using classroom response systems to allow
the instructor to gauge the level of understanding and the opportunity to reteach
any unclear concepts. Students will work individually and in groups, with guidance
from the instructor to complete a series of predefined scenarios that accompany the
text to practice and master the key concepts for the unit. The goal of this approach is
to allow traditional programming concepts to be more easily taught and more
readily understood.
Key Assignments:
Activity
Objective
Students create a visual
and textual storyboard
(two storyboards) for
each of the following
scenario:
Students create a visual
and textual storyboard
(two storyboards) for
each of the following
scenario:
Students will finish a
program that has been
initially setup for them,
(from the authors from
the text) such as
background scenery and
objects.
Scenario 1: A child’s
game: Alice, the white
rabbit, and the Cheshire
cat enjoy a game of
musical chairs in a tea
party scene (program).
One of the characters yells
“switch” and they all run
around the table to stand
beside the next chair. After
the switch, a chair is
tipped over and the
character standing next to
it is eliminated from the
game (moves away form
the table).
Scenario 2: A video game:
A jet fighter plane is
returning to the carrier
deck after a training
mission. The plane makes
a half-circle around the
carrier to get into position
for landing and then
gradually descends. The
carrier is in motion, so the
plane has to continually
adjust its decent to finally
land on the deck. After the
plane touches down on the
carrier, it continues to
move across the deck to
finally come to a halt.
Scenario 3: An Olympic
simulation: An ice skater is
a practicing her skating
routine for the Olympic
trials. She will perform a
sequence of jumps and
spins, while classical music
is playing.
Students will practice and
master the concept of
visual and textual
storyboards. Students
will practice and master
the concept of sequencing
instructions and that a
program consists of lines
of code that specify the
actions objects are to
perform.
Students will practice and
master the concept of
visual and textual
storyboards. Students
will practice and master
the concept of sequencing
instructions and that a
program consists of lines
of code that specify the
actions objects are to
perform.
Students will practice and
master the concept of
visual and textual
storyboards. Students
will practice and master
the concept of sequencing
instructions and that a
program consists of lines
of code that specify the
actions objects are to
perform.
Students will finish a
program that has been
initially setup for them,
such as background
scenery and objects.
Students will finish a
program that has been
initially setup for them,
(from the authors from
the text) such as
background scenery and
objects.
Students will create an
island world with fish in
the water. Students will
position the fish and the
camera point of view. Next
the students will have the
fish swim around the
island. Finally, they have
the fish jump out of the
water and then dive down
into the water.
Students will create a
world having a tortoise
(animal object), a stool
(furniture), and a cookie
(food). Students will
position the tortoise and
the stool side by side and
then use a move method to
move the tortoise 2 meters
away from the stool. They
will use a turn to face
method to sure the
tortoise is facing the stool.
Students will write a
program to move the
tortoise to the stool to get
the cookie. Finally the
students will program the
tortoise to show its thanks
(for the cookie) by looking
at the camera and waving
an arm.
Students will practice and
master using Do in order
and Do together blocks
telling the software which
instructions are to be
executed and in what
order. Students will
practice and master
combining these blocks
by nesting them inside
one another.
Students will practice and
master using Do in order
and Do together blocks
telling the software which
instructions are to be
executed and in what
order. Students will
practice and master
combining these blocks
by nesting them inside
one another.
Unit 3 – Key Assignments
Prior to working the key assignments for unit 3, students will read pages 62-82 from
the textbook Learning to Program with Alice. Next the students will work through
the guided and interactive materials from Chapter 2 – Dividing The Story(methods),
Expeditions Through Alice (web-based multimedia textbook companion materials).
Students will complete a series of Essential Questions (p82-83, Learning to Program
With Alice) aligned with text at the end of the unit using classroom response
systems to allow the instructor to gauge the level of understanding and the
opportunity to reteach any unclear concepts. Students will work individually and in
groups, with guidance from the instructor to complete a series of predefined
scenarios that accompany the text to practice and master the key concepts for the
unit. The goal of this approach is to allow traditional programming concepts to be
more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Students will finish a
program that has been
initially setup for them,
(from the authors from
the text) such as
background scenery and
objects.
Students will create a
world from a template
provided for them (snow
template). Students will
add a snowman and a
ramp. They will write
instructions to move the
snowman to the base of
the ramp. When the
snowman reaches the base
of the ramp, the snowman
will turn around and move
far away from the ramp
very quickly and say
“Yikes!”
Students will create a
scene with a blimp and a
dragon. In this scenario
students will program that
scene that the dragon has
found a blimp and is
curious. The dragon will
fly around the blimp to
check it out. The students
must program to have the
dragon move to the blimp
and then fly around it
(lengthwise) three times.
The students will use a
number function as the
count for a loop. Students
will place a snowman and
stool in a world. The
students will use a loop to
make the snowman move
to the stool, one meter at a
Students will practice
using functions and
understand a function can
be used to compute and
return a value. In this
case the snowman and
the base of the ramp.
Students will finish a
program that has been
initially setup for them,
(from the authors from
the text) such as
background scenery and
objects.
Students will finish a
program that has been
initially setup for them,
(from the authors from
the text) such as
background scenery and
objects.
Students will practice
using functions and
understand a function can
be used to compute and
return a value. Students
will practice and master
using repetition control
structures.
Students will practice and
master using If/Else
statements and relational
operators to determine if
a statement will be
executed using Boolean
operators. Students will
practice and master using
time. They will use a
repetition control
distance to function to
structures.
determine the number of
times the loop repeats.
(The distance to function
might return a fractional
distance such as 3.75
meters. The students will
practice and understand
that the Loop statement
truncates the fractional
numbers to the integer 3
and will repeat three
times.) Students test their
solution by moving the
snowman to the stool to
different locations on the
screen and running the
program with each change,
so they can know whether
it works no matter where
the snowman and the stool
are located.
Unit 4 – Key Assignments
Prior to working the key assignments for unit 4, students will read pages 89-127
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 3 – Stories from Pieces
(methods), Expeditions Through Alice (web-based multimedia textbook companion
materials). Students will complete a series of Essential Questions (p128-129,
Learning to Program With Alice) aligned with text at the end of the unit using
classroom response systems to allow the instructor to gauge the level of
understanding and the opportunity to reteach any unclear concepts. Students will
work individually and in groups, with guidance from the instructor to complete a
series of predefined scenarios that accompany the text to practice and master the
key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Students will create a
Scenario - Gallop and
Students will practice
program from a given
scenario.
Students will create a
program from a given
scenario.
Jump:
Kelly has entered an
equestrian show as an
amateur jumper. She is
somewhat nervous about
the competition so she and
the horse are practicing a
jump. Students will be
asked to create an initial
scene with a horse and
rider facing a fence.
Students will be tasked to
write a program with two
world-level methods, one
named gallop (horse and
rider gallop forward one
step) and another named
jump (horse and rider
jump the fence). In the
gallop method the horse’s
front legs should lift and
then go down as the back
legs lift and the horse
moves forward. Then the
back legs should go back
down. The jump method
should be similar, but the
horse should move up far
enough to clear the fence
in mid-stride. Students will
test each method to be
sure that it works as
expected. Students will
need to adjust the distance
amounts to make each
look somewhat realistic.
Scenario - Magic Act
A magician is performing a
levitation illusion, in which
objects seem to rise
magically into the air. The
magician points a magic
wand at this assistant, and
she gently rises into the air
and then floats back down
using complex methods
(world and object) to
control objects. Students
will have learned how
and when to use different
pieces of program code
(instructions, control
structures, functions, and
expressions).
Students will practice and
master world-level
methods and parameters
to provide variation while
writing the code for this
scenario. Students will
understand and be able to
adjust and object’s
opacity, such as the
Students will create their
own original program.
to her original position on
the table. Then the
magician performs the
same trick with the rabbit.
The rabbit, being a lighter
object, floats up higher
than the magician’s
assistant. Because the
magician’s assistant and
rabbit are each to levitate
in the same way, use a
single method and use
parameters to
communicate which object
is to float and the distance
the object is to move
upward (and back down).
bunny to make it appear
that it disappears.
Challenge -Student
Creation (Open-ended):
Students will be asked to
choose an animal or a
person from one of the
galleries. The object
selected must have at least
two legs, arms, and/wings
that can move, turn, and
roll. Students will be
asked to write three object
level methods that
substantially add
functionality to what the
objects of the class know
how to do. They must use
save object to create a new
class with a different
name. They must also add
an instance of their new
class to their world
(program). Lastly, then
write an animation to
demonstrate the new
methods.
Students will show
mastery of unit concepts
by creating their own
world (program) that
includes object-level
methods, creating a new
class, correctly using
instances of their new
class, all to create a short
story.
Unit 5 – Key Assignments
Prior to working the key assignments for unit 5, students will read pages 140-169
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 4 – Acting The Same
(parameters) and Chapter 5 – Acting Differenty, Expeditions Through Alice (webbased multimedia textbook companion materials). Students will complete a series
of Essential Questions (p159, Learning to Program With Alice) aligned with text at
the end of the unit using classroom response systems to allow the instructor to
gauge the level of understanding and the opportunity to reteach any unclear
concepts. Students will work individually and in groups, with guidance from the
instructor to complete a series of predefined scenarios that accompany the text to
practice and master the key concepts for the unit. The goal of this approach is to
allow traditional programming concepts to be more easily taught and more readily
understood.
Key Assignments:
Activity
Objective
Students will create a
program from a given
scenario.
Flight Simulator
Completion:
Students will create a
world for an acrobatic airshow. They will be asked
to create implement a
flyForward and barrel
event handling methods
and link them to the
corresponding events.
They will be asked to make
the move and roll actions
have an abrupt style to
reduce the pause in the
animation between key
presses. The students will
use sound to make the
animation more realistic.
Once the students have the
basic movements
programmed they will
next add a flyLeft and
flyRight event handling
methods. Lastly, the
students will add a
Students will practice and
demonstrate mastery of
interactive programming
(use of events – control
flying by user input).
Students will be able to
apply properties (in this
case sound) to their
program to make a more
interesting and realistic
program. Students will
show be able to link their
events to a method within
their program.
Students will create a
program from a given
scenario.
Students will create a
program from a given
scenario.
forwardLoop stunt that
works when the user
presses the Enter key.
Scenario – A Clicker’s
Dream:
Students will create a
world that provides a
place where a person can
click on lots of objects an
watch interesting things
happen. Students will use
the sand template and add
a saloon, a house, a
windmill, a well, a fence, a
cloud, a tumbleweed, and
three crates. Students will
be asked to add several
other items to make the
world more interesting.
Students will make
methods for each of the
objects described below
and create an event that
calls the method when a
person clicks the object.
•Windmill: turnBlades—
turns the windmill’s blades
two revolutions
•Saloon left door:
swingLeftDoor—swings
the saloon’s right door
open, then closes it
•Crate: breakApart—
explodes the crate
•Cloud: lightningFlash—
quickly turns the lightning
bolt on and off twice
•Tumbleweed: burnUp—
starts the tumbleweed on
fire
•Students will define
actions for their objects
Scenario--Piano:
Students will be asked to
create a keyboard that
Students will show
mastery of user triggered
events. Students will
make methods for
objects. They will show
mastery of creating an
event that call the method
when a person clicks on
the object. Students will
demonstrate the mastery
of parameters to add
variation and simplify
their programming.
The students will learn
that there is more than
one way to program the
plays notes when they
click on the keys. This is a
challenging project and
will require the students to
plan carefully. Students
will learn to break up the
project up into several
smaller parts (stepwiserefinement).
project and still have it
work. Students will
demonstrate that they
understand that they
must make methods for
each individual key to
play. Students will
demonstrate how to
import graphics and
sounds into Alice and use
them in a program.
Unit 6 – Key Assignments
Prior to working the key assignments for unit 6, students will read pages 173-200
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 6 – Get in the Story
(events), and Chapter 7 – Calculation Realism(mathematical expressions and
functions), Expeditions Through Alice (web-based multimedia textbook companion
materials). Students will complete a series of Essential Questions (p200-201,
Learning to Program With Alice) aligned with text at the end of the unit using
classroom response systems to allow the instructor to gauge the level of
understanding and the opportunity to reteach any unclear concepts. Students will
work individually and in groups, with guidance from the instructor to complete a
series of predefined scenarios that accompany the text to practice and master the
key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Students will create a
program from a given
scenario.
Pyramid Climb –
Scenario:
On spring break, a student
is visiting the land of the
Pharaohs. The student
decides to climb one of the
pyramids, starting at the
bottom and moving
straight up the side.
Students will be asked to
setup and initial scene
consisting of a person and
a pyramid. Students will be
asked to write a method to
animate the climb so that
Students will practice and
master applying functions
to solve a programming
problem (in this case
having an object walk up
the side of a pyramid).
Students will understand
that function will result in
a number that can be
used in various ways.
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
the person’s feet are
always on the side of the
pyramid. To determine
how far the person must
move to complete the
climb, the climb method
must call a method. The
function will compute the
side length of the pyramid.
The formula the students
will use to compute the
distance up the side of the
pyramid is based on the
Pythagorean theorem. The
value of c will provide a
rough estimate of how far
the person should move
(in a diagonal direction)
up the side of the pyramid.
Scenario -- Help the
Snowman get Home
Game:
Students are asked to
create a game where the
goal is to move the
snowman through a forest
to get him home to his
igloo. The hazard in the
their game is that if the
snowman gets too close to
a tree (object location on
the grid), he moves back
10 meters. Students will
add the snowman, a
snowbard, an igloo, and
eight pine trees. Students
will create an event so that
the skateboard can be
controlled by the user.
Students must create a
method for the skateboard
name check
ForCollisionWithTrees. If
the skateboard’s distance
to the pine tree is less than
Students practice and
master the concepts of
using If/Else
statements(checking
locations of trees for
example) and Boolean
Functions (distance to the
tree true/false).
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
3.75 meters, then move
the skateboard back 10
meters. For this method,
students will need to check
each tree in the scene.
Once they have the If/Else
working for one tree, the
should copy it for each of
the trees
Scenario--Random
Sphere Catch Game:
Students are asked to
create a game where the
goal is to click on spheres
that are randomly flying in
the air. When the player
successfully catches (clicks
on) a sphere, a puff of
smoke appears and then
quickly disappears. When
the puff of smoke
disappears, the spere also
disappears. The game is
over when all the spheres
have been caught.
Students should add a
World-level method
named startGame that
calls the
moveAroundRandomly
method for each sphere, all
at the same time. Students
will need to add an event
that calls startGame and
another event that calls
disappear.
Students practice and
master the concepts of
random numbers and
random motion,
execution control with
If/Else statements, and
applying functions in a
correct manner.
Unit 7 – Key Assignments
Prior to working the key assignments for unit 7, students will read pages 213-228
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 8 – Choosing your path (If
statements) and Chapter 9 – More Complex Control Of Execution (compound Boolean
expressions and nested If/Elses), Expeditions Through Alice (web-based multimedia
textbook companion materials). Students will complete a series of Essential
Questions (p228-229, Learning to Program With Alice) aligned with text at the end
of the unit using classroom response systems to allow the instructor to gauge the
level of understanding and the opportunity to reteach any unclear concepts.
Students will work individually and in groups, with guidance from the instructor to
complete a series of predefined scenarios that accompany the text to practice and
master the key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Lock
Combination: Students
are tasked with the
challenge of creating a new
class of combination lock
with four class-level
methods—leftOne,
rightOne, leftReveolution,
rightRevolution—that turn
the dial one number left,
one number right, one
revolution left, and one
revolution right,
respectively. For this
challenge students must
create a method named
open that opens it, and
another named close that
closes it. Students should
use a loop instruction to
turn the dial left 25 times.
They then should use a
loop to turn the dial right
and finally use a loop to
turn the dial back to the
left three times. (The
combination is 25, 16, 3)
They should be able to pop
open the latch, close the
latch, and return the dial
to zero. The students will
use Wait to make the lock
pause between each turn
of the dial.
Students will practice and
master creating and reusing methods (for
example, lock
operations), Conditional
loops (combination), and
nested loops.
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Make a
working clock: A common
display on a computer
desktop is a digital time
display, showing the hour,
minute, and second hands
all working continuously
display the time, second by
second and updating the
minutes and hours as time
passes. All three hands of
the clock should rotate just
like a real clock. To create
the clock, students must
import an
alarmClock(object) and a
katana(object). They must
position the katana on the
clock to be used as a
second hand. The world’s
(program) functions
include several time
functions that access the
computer’s built in clock.
Students will be asked to
use the world functions of
hour of Am or PM, minute
of the hour, and second of
the minute to roll the
hands to their correct
starting positions. They
must also use a while loop
to continuously update the
second hand and If/Else
statements to decide when
to move each of the minute
and hour hands.
Scenario—Drinking
Bird:
Students will be asked to
recreate a small toy
popular with child (a
simulation of the drinking
bird). The students must
Students will practice and
master using loops with a
While statement
specifying how many
times a block of code will
be repeated (for example,
movement of hand and
tracking of time), events
and repletion.
Students will practice and
master using loops
(infinite loop in this case),
events and repetition.
create a world (program)
that includes a bird
positioned in front of a
container of water.
Because of the
counterbalance in front of
weights on either end of its
body, the parrot should
repeatedly lover its head
into the water. Students
should use an infinite Loop
statement to make the bird
drink.
Unit 8 – Key Assignments
Prior to working the key assignments for unit 8, students will read pages 239-257
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 10 – Doing Things Over
And Over (Loops), Expeditions Through Alice (web-based multimedia textbook
companion materials). Students will complete a series of Essential Questions (p258,
Learning to Program With Alice) aligned with text at the end of the unit using
classroom response systems to allow the instructor to gauge the level of
understanding and the opportunity to reteach any unclear concepts. Students will
work individually and in groups, with guidance from the instructor to complete a
series of predefined scenarios that accompany the text to practice and master the
key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Butterfly
Chase:
Students will be asked to
use recursion to make a
rabbit chase a butterfly.
The butterfly should fly to
a random, nearby location
(within 0.2 meters in any
direction). The white
rabbit, however, must
always remain on the
ground (rabbits do not fly).
Each time the butterfly
Students will practice and
master the concept of
recursion as they write
the code for the butterfly
in this world. They will
understand how a
complex problem such as
this can be broken down
into smaller more
manageable problems to
solve.
moves, the student will use
a turn to face method to
make the rabbit turn
toward the butterfly and
then move the rabbit
toward the butterfly 0.5
meters. When the rabbit
gets close enough he
should catch the butterfly
in a net. To complete this
program students will
need to utilize the
randomMotion method and
the butterfly’s flight
pattern will need to be
controlled so it does not go
to high or low
(underground). Students
will use an If statement to
check the butterfly’s
distance above the ground
and them move the
butterfly up or down
accordingly. The
butterfly’s distance above
the ground should always
be within the range of 0
(ground level) and 1
(meter above the ground).
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Why Did the
Chicken Cross The Road?
For this project students
will program a chicken
that has a sweet-tooth and
crosses the road to eat the
gumdrops along the way.
Students must write a
game animation where the
player guides the chicken
across the road to get to
the gumdrops. Cars and
other vehicles should
move in both directions as
the chicken tries to cross
Students will practice and
master the concept of
recursion as they write
the code for the butterfly
in this world. They will
understand how a
complex problem such as
this can be broken down
into smaller more
manageable problems to
solve.
to where the gumdrops
are located. Students will
program the arrow keys to
make the chicken jump
left, right, forward, and
back. The spacebar will be
programmed to make the
chicken peck (if pecked on
gumdrops they should
disappear) A recursive
method should be used to
control the play of the
game. If the chicken gets
hit by a vehicle, the game
is over. The game
continues as long as the
chicken has not managed
to peck all the gumdrops
and has not been hit by a
vehicle. If the chicken
manages to cross the road
and peck at all the
gumdrops along the way,
the player wins the game.
At that point the player is
shown text or has a sound
play signaling that the
game has been won.
Unit 9 – Key Assignments
Prior to working the key assignments for unit 9, students will read pages 267-279
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 11 – Grouping Items
Together(Lists), Chapter 13 – Intro to Spreadsheets, and Chapter 14 – Spreadsheets:
Working With Large DataSets, Expeditions Through Alice (web-based multimedia
textbook companion materials). Students will complete a series of Essential
Questions (p279-280, Learning to Program With Alice) aligned with text at the end
of the unit using classroom response systems to allow the instructor to gauge the
level of understanding and the opportunity to reteach any unclear concepts.
Students will work individually and in groups, with guidance from the instructor to
complete a series of predefined scenarios that accompany the text to practice and
master the key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Pop the
Balloon Game:
Students will take the code
they wrote in unit 6
(Random Sphere Catch)
and add code to modify the
behavior of the program.
Students will now be
asked to use a list to make
the code less complex and
easier to understand. They
will be first be asked to
create a world –level list
named spheres and add
each of the 10 sphere
objects to the list. They
will also need to modify
the disappear method to
use a For all in order to
check if the item that was
clicked was a sphere. If
that is the case they will
need to make it disappear.
Students will practice and
master using lists (in this
case – spheres) to make
their code simpler to
write, manage, and
document. Students will
master list processing as
well as list searching.
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Monty’s
Dilemma:
Students will be presented
as famous mathematical
problem (the Monty
Dilemma) which states,
suppose you are on a game
show, and your give the
choice of three doors.
Behind one is a car, behind
the others, toy monkeys.
You pick a door, say
number 1, and host, and
the host who knows what’s
behind the doors, opens
Students will practice and
master using lists (in this
case – doors) to make
their code simpler to
write, manage, and
document. Students will
master list processing as
well as list searching.
another door, say number
3, which has a toy monkey.
He says to you, “Do you
want to pick door number
2?’ Is it to your advantage
to switch your choice of
doors? One way the
students could find an
answer to this question is
to create a simulation of
the game where the
objects are placed
randomly behind the
doors. Then play the game
25 times where you do not
switch and 25 times where
they do switch. They will
need to keep track of their
success rate when they
switch and when they do
not switch. Students will
create an initial setup for
their world with three
doors spaced evenly with
2 monkeys and 1 car. To
program the game,
students will make a list
containing the three doors.
When the animation
begins, randomly pick two
doors and swap them.
They will be asked to use
method called swap that
takes two doors as
parameters. The two doors
should swap by moving in
opposite directions. The
two doors should only
swap if they are different.
The swap should repeat 10
times. (The idea is to make
it difficult for the player to
know what object is
behind what door.)
Text will prompt the
player to choose a door.
After the player clicks on
one of the doors, they will
pick another door that
hides a monkey and open
that door. The player will
be asked if he/she wants
to switch the choice. If the
object behind the door
(selected by the player) is
the car, the player has
won.
Unit 10 – Key Assignments
Prior to working the key assignments for unit 10, students will read pages 289-312
from the textbook Learning to Program with Alice. Next the students will work
through the guided and interactive materials from Chapter 12 – Object-Oriented
Design (Class-Level Methods), Expeditions Through Alice (web-based multimedia
textbook companion materials). Students will complete a series of Essential
Questions (p312, Learning to Program With Alice) aligned with text at the end of the
unit using classroom response systems to allow the instructor to gauge the level of
understanding and the opportunity to reteach any unclear concepts. Students will
work individually and in groups, with guidance from the instructor to complete a
series of predefined scenarios that accompany the text to practice and master the
key concepts for the unit. The goal of this approach is to allow traditional
programming concepts to be more easily taught and more readily understood.
Key Assignments:
Activity
Objective
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—All Possible
Permutations:
A permutation is a
rearrangement of a set of
objects. For example, a
permutation of the
numbers 1,2,3 could be
2,1,3 or it could be 2,3,1.
Students will be asked to
create an array containing
three 3D text numbers
objects. They will be asked
to write a swap method.
Students will practice and
master using array
visualization using an
index variable to create
the permutations for
their computer program.
They will then be asked to
write a program that calls
the swap method to show
the numbers moving
around to create
permutations of the
numbers. Students will
need the call the swap
method with different
parameters so that all
possible permutations can
be seen.
Student Challenge –
student is presented a
scenario and must create
the code to create
required actions.
Scenario—Record and
Play a Song:
The program that the
students write should
allow the user to record
their own songs and play
them back. This will use
some to the code that the
students wrote in unit 5
(piano assignment). The
students will need to add
four buttons:
• Start recording-start
recording a song
• Stop recording-stop
recording this song
• Play recording-play the
latest recorded song
•Clear recording-erase the
latest recorded song
The students will need to
create a program where to
record a song, the user
first clicks the Record
button and then clicks on
the piano keys to create a
sequence of notes. As the
users clicks each note, the
note is played (to give
feedback to the user) and
is also records. To record
the notes, the students
Students will practice and
master the use of
variables (Boolean and
numerical) as they create
their music program.
Students will be able to
effectively debug their
code with watch and text
output to catch any
errors. Students will be
able to effectively use
arrays .
must create a world-level
list named newSong.
Initially, the newSong list
will be empty, but during
the recording process
notes are added to the end
of the list. To stop
recording, the user clicks
the Stop Record button.
Students will need to
create a Boolean variable
named recording. It should
be set to true when
recording but false when
recording stops. Also any
methods that play a note
should check this
condition before recording
the note (or not). Students
can use debugging with
watch and text output to
help when they have
problems with their code.
Section 6 – Instructional Methods and/or Strategies
For the class Computer Science Principles, instructional methods and are modeled
after professor Beth Simon’s, from the University of California San Diego’s school of
Computer Science and Engineering CSE3 (Fluency in Information Technology)
course. This course utilizes multiple instructional methods and strategies to
accommodate diverse learning styles and the development of different skills sets.
Methods and/or Strategies to be used include:
• teacher facilitated Socratic questioning using classroom response systems
• direct instruction/lecture
• reading assignments
• guided learning - scaffold/guided programming and writing assignments
• group and independent programming assignments
• project based learning
Direct instruction will be used in a limited manner to introduce concepts and ideas
before readings are assigned to assist students understand concepts to a greater
degree. Reading assignments will be assigned with each unit to introduce ideas and
concepts. To provide deeper learning and greater understanding of materials, the
majority of class instruction (on an ongoing basis) will focus on the Socratic
questioning method using classroom response systems to insure participation by all
students and provide each participant a voice. The Socratic method will be modeled
for students (question, restating, clarifying, explaining, challenging others, taking a
position) and they will engage in this method as the instructor and college tutors
facilitate. With each unit students will complete a series of scaffold/guided
interactive media lessons to provide the student practice and basic mastery of the
materials/concepts/ideas. At this point students will be prepared to engage in
project based assignments, working as a group or independently to complete a
series of challenging programming scenarios to provide true mastery of the
material.
Section 7 – Assessment Methods and/or Tools
For the class Computer Science Principles, appropriate AP level assessments
(providing the rigor for this class) were created by professor Beth Simon, from the
University of California San Diego’s school of Computer Science and Engineering. All
quizzes and exams are the same as those used in her CSE3 (Fluency in Information
Technology) class.
Both formative and summative assessments are used as on-going throughout this
course to make insure that the instructional methods used are effective. The
instructor uses multiple reviews of concepts and skills. Peer assessments and
classroom response systems are used to facilitate Socratic Questioning, as well as
review of student-designed programs, periodic unit tests of multiple choice and
short answer to assess student mastery of key concepts. Student feedback during
instruction and from formative and informative assessments will be used to modify
instructional methods as necessary.
Assessments are aligned with the course purpose, the instructional strategies used,
and with the CCTE standards and Common Core Standards that apply across major
themes in the subject content. These assessments will allow students to
demonstrate the mastery of specific key concepts in Computer Science Principles.
Students are provided with the opportunity to implement analytical and logical
skills of computational thinking to understand and employ computational logic and
processes in basic programming.
During formative assessments students apply logical and analytical strategies, to
explain the reason behind basic functions, both verbally to peers and to the
instructor, which will reflect their mastery of the subject and determine how
instructional methods can be improved upon. This will give students the chance to
attain enough practice to master skills required for the course.
Teamwork and Peer Assessments allow the students to reflect on course content
and to practice newly obtained knowledge. A teamwork and peer assessment rubric
measuring impact of performance, program development quality prior to and
during development, validity of project content, and sophistication of knowledge
applied to final program project gives the instructor the tool to evaluate individual
and team skill levels. Also, upon completion of a project students will fill out a selfevaluation questionnaire that will also contribute to the overall assessment of the
final project.
The team rubric assessment also allows for the instructor to determine next steps
during the learning process as the instruction approaches the summative
assessment. These informal assessments give students specific feedback about what
they are doing well or need to change.
Peer assessments, teamwork rubric evaluations, classroom polls (interactive
classroom response systems) and review of student-designed programs also allows
the instructor an opportunity to identify individual student learning goals and set
criteria for student success. These evaluations are real evidence of student growth
and true learning towards mastery of course content and help the instructor to
modify instructional methods as needed.
Summative assessments provide students with a variety of reviews in different
contexts that address content learned throughout the year. Instructor uses these
assessments to monitor if proficiency is maintained over time. Assessment grading
percentages contribute to the student’s quarter course grade.
Participation 10%
Quizzes 20%
Class Assignments/Projects 20%
Exams 50%