cf.edliostatic.comcf.edliostatic.com/zaSB2ICErKgfSMxfyYalo9DkGGE8mbc2.docx · Web viewText and 2D...

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, 2011Publisher: Prentice HallAuthors: Wanda P. Dann, Stephen Cooper, Randy PauschISBN 978-0-13-208516-8The 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 non-engineering 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 AliceAlice ConceptsText 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 object-oriented 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 StoryboardsOrientation and movement instructionsTranslating 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 controlsObjects 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 actionControl structures – a statement that controls the execution of instructionsFunctions - asks a question about a condition or computes a valueExpressions – 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 MethodsParametersObject-Level Methods and InheritanceProperties; 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 action-abstraction. 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 ProgrammingParameters and Event Handler MethodsCreating 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.


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 FunctionsExecution Control with If/Else and Boolean FunctionsRandom 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.


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:LoopsWhile – a conditional loopEvents 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.


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 RecursionAnother flavor of recursionEngineering 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 ProcessingList SearchGrouping 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.


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 variableDebugging 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. Class-level 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.


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 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.


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 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.


Students will practice creating and modify events (user interactions that will be covered in greater detail later in the course). Students will practice creating events such as clicking on an object and having action trigger.

Students will be able to create events for their worlds.


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.


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:

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).

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 create a visual and textual storyboard (two storyboards) for each of the following scenario:

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.


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 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 finish a program that has been initially setup for them, 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 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 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.


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.



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 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 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.

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.


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 time. They will use a

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 repetition control

distance to function to 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.

structures.


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.


Students will create a program from a given

Scenario - Gallop and Jump:

Students will practice using complex methods

scenario. 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.

(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 create a program from a given scenario.

Scenario - Magic ActA 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 to her original position on the table. Then the

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 bunny to make it appear that it disappears.

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).

Students will create their own original program.

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.


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 (web-based 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.



Flight Simulator Completion:Students will create a world for an acrobatic air-show. 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 forwardLoop stunt that works when the user presses the Enter key.

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.


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

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.


Scenario--Piano:Students will be asked to create a keyboard that plays notes when they click on the keys. This is a challenging project and will require the students to

The students will learn that there is more than one way to program the project and still have it work. Students will demonstrate that they understand that they

plan carefully. Students will learn to break up the project up into several smaller parts (stepwise-refinement).

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.


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.



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 the person’s feet are always on the side of the pyramid. To determine how far the person must

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.

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.

Student Challenge – student is presented a scenario and must create the code to create required actions.

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 3.75 meters, then move the skateboard back 10 meters. For this method, students will need to check each tree in the scene.

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).

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.


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.



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 re-using 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

Scenario—Make a working clock: A common display on a computer desktop is a digital time

Students will practice and master using loops with a While statement specifying how many

required actions. 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.

times a block of code will be repeated (for example, movement of hand and tracking of time), events and repletion.


Scenario—Drinking Bird:Students will be asked to recreate a small toy popular with child (a simulation of the drinking bird). The students must create a world (program) that includes a bird positioned in front of a container of water. Because of the counterbalance in front of

Students will practice and master using loops (infinite loop in this case), events and repetition.

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.


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.



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 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

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.

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).


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 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

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.

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.


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.


Student Challenge – student is presented a

Scenario—Pop the Balloon Game:

Students will practice and master using lists (in this

scenario and must create the code to create required actions.

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.

case – spheres) to make their code simpler to write, manage, and document. Students will master list processing as well as list searching.


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 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

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.

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.


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.



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. 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

Students will practice and master using array visualization using an index variable to create the permutations for their computer program.

possible permutations can be seen.


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 songThe 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 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

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 .

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 self-evaluation 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%

cf.edliostatic.comcf.edliostatic.com/zaSB2ICErKgfSMxfyYalo9DkGGE8mbc2.docx · Web viewText and 2D...

Documents

Transcript of cf.edliostatic.comcf.edliostatic.com/zaSB2ICErKgfSMxfyYalo9DkGGE8mbc2.docx · Web viewText and 2D...