├── .gitignore ├── 83.PNG ├── 84.PNG ├── 90degreesquare.PNG ├── Final Project Development Plan.docx ├── Final Project Plan Organizer.docx ├── GLOSSARY.md ├── Lab 1.3 Solution.xml ├── Lab 2.1 Solution.xml ├── Lab 2.2 Solution.xml ├── Lab 2.3 Solution.xml ├── PostVariableCreate.PNG ├── Project 1 - Nursery Rhyme.docx ├── Projects ├── Projects PDF │ ├── Project 1 Nursery Rhyme.pdf │ ├── Project 2 Platform Game Easy.pdf │ ├── Project 2 Platform Game.pdf │ ├── Project 3 Pong.pdf │ ├── Project 4 Hangman.pdf │ ├── Project 4 Snowman.pdf │ └── Project 5 Space Invaders.pdf └── Projects Word │ ├── Project 1 Nursery Rhyme.docx │ ├── Project 2 Platform Game Easy.docx │ ├── Project 2 Platform Game.docx │ ├── Project 3 Pong.docx │ ├── Project 4 Hangman.docx │ ├── Project 4 Snowman.docx │ └── Project 5 Space Invaders.docx ├── QuadrilateralSets.PNG ├── README.md ├── SNAP Program Design and Planning Worksheet.docx ├── SUMMARY.md ├── TEALS Intro CS Curriculum Guide - handout.docx ├── Unit 0 ├── Lab 0.4.docx ├── Lab 0.4.pdf └── README.md ├── Unit 1 PDF ├── Lab 1.1 Welcome To SNAP.pdf ├── Lab 1.2 SNAP Scavenger Hunt.pdf ├── Lab 1.3 Squares Triangles.pdf └── Lab 1.4 Sprites in Action.pdf ├── Unit 1 Word ├── Lab 1.1 Welcome To SNAP.docx ├── Lab 1.2 SNAP Scavenger Hunt.docx ├── Lab 1.3 Squares Triangles.docx └── Lab 1.4 Sprites in Action.docx ├── Unit 2 PDF ├── Lab 2.1 Triangles and Squares Redux.pdf ├── Lab 2.2 Another Brick in the Wall.pdf ├── Lab 2.3 What Shape Is That.pdf ├── Lab 2.4 Guessing Game.pdf ├── Lab 2.4 Triangles of All Kinds.pdf ├── Lab 2.5 Triangles of All Kinds.pdf ├── Lab 2.5 What Goes Up.pdf └── Lab 2.6 What Goes Up.pdf ├── Unit 2 Word ├── Lab 2.1 Triangles and Squares Redux.docx ├── Lab 2.2 Another Brick in the Wall.docx ├── Lab 2.3 What Shape Is That.docx ├── Lab 2.4 Guessing Game.docx ├── Lab 2.4 Triangles of All Kinds.docx ├── Lab 2.5 Triangles of All Kinds.docx ├── Lab 2.5 What Goes Up.docx └── Lab 2.6 What Goes Up.docx ├── Unit 3 PDF ├── .DS_Store ├── Lab 3.1 Guessing Game.pdf ├── Lab 3.2 Drawing Shapes Again.pdf ├── Lab 3.3 Let Me Check My Calendar.pdf └── Lab 3.4 If My Calculations Are Correct.pdf ├── Unit 3 Word ├── Lab 3.1 Guessing Game.docx ├── Lab 3.2 Drawing Shapes Again.docx ├── Lab 3.3 Let Me Check My Calendar.docx └── Lab 3.4 If My Calculations Are Correct.docx ├── Unit 4 PDF ├── Lab 4.2 You Talkin To Me.pdf ├── Lab 4.3 Guess Who.pdf ├── Lab 4.4 Number Cruncher.pdf └── Lab 4.5 Its Around Here Somewhere.pdf ├── Unit 4 Word ├── Lab 4.2 You Talkin To Me.docx ├── Lab 4.3 Guess Who.docx ├── Lab 4.4 Number Cruncher.docx └── Lab 4.5 Its Around Here Somewhere.docx ├── Unit 5 PDF ├── Lab 5.1 Connect the Dots.pdf ├── Lab 5.2 Lots of Balls.pdf └── Lab 5.3 Fewer Balls.pdf ├── Unit 5 Word ├── Lab 5.1 Connect the Dots.docx ├── Lab 5.2 Lots of Balls.docx └── Lab 5.3 Fewer Balls.docx ├── VariableCreateImage.PNG ├── VariableImage.PNG ├── VariableInUse.PNG ├── ZoomBlocks.PNG ├── addition.png ├── additional_curriculum_resources.md ├── and.png ├── answer.png ├── appendix-bjc-video-lectures.md ├── ask.png ├── basicSequentialSearch.jpg ├── bjc_videosuggestions.md └── bjcvideosuggestions.md ├── book.json ├── brick wall.png ├── broadcast.png ├── changeY.png ├── changepensize.png ├── chapter1.md ├── clear.png ├── cloudButton.png ├── cloudSignup.png ├── contributing.md ├── createACloneOf.png ├── culture_day_lesson_a.md ├── culture_day_lesson_b.md ├── curriculum_map.md ├── deleteThisClone.png ├── distanceTo.png ├── dots.PNG ├── draw squares.png ├── forever.png ├── foreverIf.png ├── foreverdrawsomething.png ├── forevergotomouse.png ├── forevermove.png ├── foreversay.png ├── foreversayanimals.png ├── glide.png ├── gotomousex30.png ├── gotox-y.png ├── if-else.png ├── if.png ├── importcostumes.png ├── importingListInstructions.PNG ├── kaleidoscopegif.gif ├── lab_04.md ├── lab_11.md ├── lab_12.md ├── lab_13.md ├── lab_14.md ├── lab_21.md ├── lab_22.md ├── lab_23.md ├── lab_24.md ├── lab_25.md ├── lab_26.md ├── lab_32.md ├── lab_33.md ├── lab_34.md ├── lab_42.md ├── lab_43.md ├── lab_44.md ├── lab_45.md ├── lab_51.md ├── lab_52.md ├── lab_53.md ├── lab_day_lesson.md ├── lessThan.png ├── lesson_01.md ├── lesson_02.md ├── lesson_03.md ├── lesson_04.md ├── lesson_11.md ├── lesson_12.md ├── lesson_13.md ├── lesson_14.md ├── lesson_15.md ├── lesson_21.md ├── lesson_22.md ├── lesson_23.md ├── lesson_24.md ├── lesson_25.md ├── lesson_26.md ├── lesson_27.md ├── lesson_31.md ├── lesson_32.md ├── lesson_33.md ├── lesson_34.md ├── lesson_35.md ├── lesson_41.md ├── lesson_42.md ├── lesson_43.md ├── lesson_44.md ├── lesson_45.md ├── lesson_46.md ├── lesson_51.md ├── lesson_52.md ├── lesson_53.md ├── lesson_54.md ├── lesson_61.md ├── lesson_62.md ├── lesson_63.md ├── lesson_64.md ├── lesson_65.md ├── menucostumes.png ├── mouseX.png ├── mousex.png ├── mousey.png ├── move.png ├── moveDragged.png ├── offset bricks.png ├── pendown.png ├── penup.png ├── pickrandom.png ├── playNote.png ├── playnotes.png ├── pointInDirection.png ├── pointindirection.png ├── pointtowards.png ├── project_1.md ├── project_2.md ├── project_2_platform_game_easy.md ├── project_3.md ├── project_4.md ├── project_5.md ├── project_6.md ├── random.png ├── repeat until.png ├── repeat.png ├── restforbeats.png ├── rotateButton.PNG ├── save as.png ├── say.png ├── scriptwithhighlightedborder.png ├── scriptwithmoveandsayblocks.png ├── setVar1ToVar2.png ├── seteffect.png ├── setpencolor.png ├── setsize.png ├── signin page.png ├── simpleListTraversal.png ├── simpleProgram.png ├── snap window.png ├── snapOverview.png ├── squarediagram.png ├── stop.png ├── stopAllSounds.png ├── stopall.png ├── stopbutton.png ├── styles ├── pdf.css └── website.css ├── subtraction.png ├── think.png ├── touching.png ├── turn15degrees.png ├── two bricks.png ├── twoblocksabouttosnaptogether.png ├── twosquares.png ├── twosquaresnested.png ├── unit_0.md ├── unit_1.md ├── unit_2.md ├── unit_3.md ├── unit_4.md ├── unit_5.md ├── unit_6.md ├── useIndexInLoop.png ├── whenIReceive.png ├── whenIStartAsAClone.png ├── xposition.png ├── xpositioncheckbox.png ├── xpositionreporting.png ├── xpositionwatcher.png ├── xygrid.png └── yposition.png /.gitignore: -------------------------------------------------------------------------------- 1 | # Node rules: 2 | ## Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) 3 | .grunt 4 | 5 | ## Dependency directory 6 | ## Commenting this out is preferred by some people, see 7 | ## https://docs.npmjs.com/misc/faq#should-i-check-my-node_modules-folder-into-git 8 | node_modules 9 | 10 | # Book build output 11 | _book 12 | 13 | # eBook build output 14 | *.epub 15 | *.mobi 16 | -------------------------------------------------------------------------------- /83.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/83.PNG -------------------------------------------------------------------------------- /84.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/84.PNG -------------------------------------------------------------------------------- /90degreesquare.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/90degreesquare.PNG -------------------------------------------------------------------------------- /Final Project Development Plan.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Final Project Development Plan.docx -------------------------------------------------------------------------------- /Final Project Plan Organizer.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Final Project Plan Organizer.docx -------------------------------------------------------------------------------- /GLOSSARY.md: -------------------------------------------------------------------------------- 1 | # Glossary 2 | 3 | ## loop 4 | 5 | A type of block that causes other code to run multiple times in succession 6 | -------------------------------------------------------------------------------- /PostVariableCreate.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/PostVariableCreate.PNG -------------------------------------------------------------------------------- /Project 1 - Nursery Rhyme.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Project 1 - Nursery Rhyme.docx -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 1 Nursery Rhyme.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 1 Nursery Rhyme.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 2 Platform Game Easy.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 2 Platform Game Easy.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 2 Platform Game.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 2 Platform Game.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 3 Pong.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 3 Pong.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 4 Hangman.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 4 Hangman.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 4 Snowman.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 4 Snowman.pdf -------------------------------------------------------------------------------- /Projects/Projects PDF/Project 5 Space Invaders.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects PDF/Project 5 Space Invaders.pdf -------------------------------------------------------------------------------- /Projects/Projects Word/Project 1 Nursery Rhyme.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 1 Nursery Rhyme.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 2 Platform Game Easy.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 2 Platform Game Easy.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 2 Platform Game.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 2 Platform Game.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 3 Pong.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 3 Pong.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 4 Hangman.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 4 Hangman.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 4 Snowman.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 4 Snowman.docx -------------------------------------------------------------------------------- /Projects/Projects Word/Project 5 Space Invaders.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Projects/Projects Word/Project 5 Space Invaders.docx -------------------------------------------------------------------------------- /QuadrilateralSets.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/QuadrilateralSets.PNG -------------------------------------------------------------------------------- /SNAP Program Design and Planning Worksheet.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/SNAP Program Design and Planning Worksheet.docx -------------------------------------------------------------------------------- /SUMMARY.md: -------------------------------------------------------------------------------- 1 | # Summary 2 | 3 | * [Introduction](README.md) 4 | * [Curriculum Map](curriculum_map.md) 5 | * [Unit 0: Beginnings](unit_0.md) 6 | * [Lesson 0.1: The First Day](lesson_01.md) 7 | * [Lesson 0.2: Algorithms](lesson_02.md) 8 | * [Lesson 0.3: Programming Languages](lesson_03.md) 9 | * [Lesson 0.4: SNAP Self-Portrait](lesson_04.md) 10 | * [Lab 0.4: Getting to Know You](lab_04.md) 11 | * [Unit 1: SNAP Basics](unit_1.md) 12 | * [Lesson 1.1: Welcome to SNAP](lesson_11.md) 13 | * [Lab 1.1: Welcome to SNAP!](lab_11.md) 14 | * [Lesson 1.2: Building Blocks](lesson_12.md) 15 | * [Lab 1.2: SNAP Scavenger Hunt](lab_12.md) 16 | * [Lesson 1.3: Drawing Shapes](lesson_13.md) 17 | * [Lab 1.3: Squares, Triangles, and Stars, Oh My!](lab_13.md) 18 | * [Lesson 1.4: Animation](lesson_14.md) 19 | * [Lab 1.4: Sprites in Action](lab_14.md) 20 | * [Lesson 1.5: Nursery Rhyme Project](lesson_15.md) 21 | * [Project 1: Animated Nursery Rhyme](project_1.md) 22 | * [Unit 2: Loops](unit_2.md) 23 | * [Lesson 2.1: Loops](lesson_21.md) 24 | * [Lab 2.1: Squares and Triangles Redux](lab_21.md) 25 | * [Lesson 2.2: Nested Loops](lesson_22.md) 26 | * [Lab 2.2: Another Brick in the Wall](lab_22.md) 27 | * [Lesson 2.3: Inputs and Conditionals](lesson_23.md) 28 | * [Lab 2.3: What Shape is That?](lab_23.md) 29 | * [Lesson 2.4: Variables](lesson_24.md) 30 | * [Lab 2.4: Guessing Game](lab_24.md) 31 | * [Lesson 2.5: Boole in the House](lesson_25.md) 32 | * [Lab 2.5: Triangles of All Kinds](lab_25.md) 33 | * [Lesson 2.6: Combining Loops and Conditionals](lesson_26.md) 34 | * [Lab 2.6: What Goes Up...](lab_26.md) 35 | * [Lesson 2.7: Platform Game Project](lesson_27.md) 36 | * [Project 2: Platform Game](project_2.md) 37 | * [Project 2: Platform Game \(Easy\)](project_2_platform_game_easy.md) 38 | * [Unit 3: Variables and Customization](unit_3.md) 39 | * [Lesson 3.1: Abstraction and Friends](lesson_31.md) 40 | * [Lesson 3.2: Procedures](lesson_32.md) 41 | * [Lab 3.2: Drawing Shapes \(Again\)](lab_32.md) 42 | * [Lesson 3.3: Customization 1](lesson_33.md) 43 | * [Lab 3.3: Let Me Check My Calendar](lab_33.md) 44 | * [Lesson 3.4: Customization II](lesson_34.md) 45 | * [Lab 3.4: If My Calculations Are Correct...](lab_34.md) 46 | * [Lesson 3.5: Pong Project](lesson_35.md) 47 | * [Project 3: Pong](project_3.md) 48 | * [Unit 4: Lists](unit_4.md) 49 | * [Lesson 4.1: Intro to Lists](lesson_41.md) 50 | * [Lesson 4.2: Static Lists](lesson_42.md) 51 | * [Lab 4.2: You Talkin' to Me?](lab_42.md) 52 | * [Lesson 4.3: List Practice I](lesson_43.md) 53 | * [Lab 4.3: Guess Who](lab_43.md) 54 | * [Lesson 4.4: List Practice II](lesson_44.md) 55 | * [Lab 4.4: Number Cruncher](lab_44.md) 56 | * [Lesson 4.5: Sequential Search](lesson_45.md) 57 | * [Lab 4.5: It's Around Here Somewhere](lab_45.md) 58 | * [Lesson 4.6: Hangman Project](lesson_46.md) 59 | * [Project 4: Hangman](project_4.md) 60 | * [Unit 5: Cloning](unit_5.md) 61 | * [Lesson 5.1: Intro to Cloning](lesson_51.md) 62 | * [Lab 5.1: Connect the Dots](lab_51.md) 63 | * [Lesson 5.2: Cloning Sprites](lesson_52.md) 64 | * [Lab 5.2: Lots of Balls](lab_52.md) 65 | * [Lesson 5.3: Communicating with Clones](lesson_53.md) 66 | * [Lab 5.3: Fewer Balls](lab_53.md) 67 | * [Lesson 5.4: Space Invaders Project](lesson_54.md) 68 | * [Project 5: Space Invaders](project_5.md) 69 | * [Unit 6: Final Project](unit_6.md) 70 | * [Lesson 6.1: Design Basics](lesson_61.md) 71 | * [Lesson 6.2: Brainstorming and Evaluating](lesson_62.md) 72 | * [Lesson 6.3: Defining Requirements](lesson_63.md) 73 | * [Lesson 6.4: Building a Plan](lesson_64.md) 74 | * [Lesson 6.5: Project Implementation](lesson_65.md) 75 | * [Project 6: Final Project](project_6.md) 76 | * [Additional Curriculum Resources](additional_curriculum_resources.md) 77 | * [Contributing](contributing.md) 78 | * [Appendix: BJC Lecture Videos](bjc_videosuggestions.md/bjcvideosuggestions.md) 79 | * [Lab Day Lesson](lab_day_lesson.md) 80 | * [Culture Day Lesson A: Video\/Reading](culture_day_lesson_a.md) 81 | * [Culture Day Lesson B: Student Research](culture_day_lesson_b.md) 82 | 83 | -------------------------------------------------------------------------------- /TEALS Intro CS Curriculum Guide - handout.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/TEALS Intro CS Curriculum Guide - handout.docx -------------------------------------------------------------------------------- /Unit 0/Lab 0.4.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 0/Lab 0.4.docx -------------------------------------------------------------------------------- /Unit 0/Lab 0.4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 0/Lab 0.4.pdf -------------------------------------------------------------------------------- /Unit 0/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 0/README.md -------------------------------------------------------------------------------- /Unit 1 PDF/Lab 1.1 Welcome To SNAP.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 PDF/Lab 1.1 Welcome To SNAP.pdf -------------------------------------------------------------------------------- /Unit 1 PDF/Lab 1.2 SNAP Scavenger Hunt.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 PDF/Lab 1.2 SNAP Scavenger Hunt.pdf -------------------------------------------------------------------------------- /Unit 1 PDF/Lab 1.3 Squares Triangles.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 PDF/Lab 1.3 Squares Triangles.pdf -------------------------------------------------------------------------------- /Unit 1 PDF/Lab 1.4 Sprites in Action.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 PDF/Lab 1.4 Sprites in Action.pdf -------------------------------------------------------------------------------- /Unit 1 Word/Lab 1.2 SNAP Scavenger Hunt.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 Word/Lab 1.2 SNAP Scavenger Hunt.docx -------------------------------------------------------------------------------- /Unit 1 Word/Lab 1.3 Squares Triangles.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 Word/Lab 1.3 Squares Triangles.docx -------------------------------------------------------------------------------- /Unit 1 Word/Lab 1.4 Sprites in Action.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 1 Word/Lab 1.4 Sprites in Action.docx -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.1 Triangles and Squares Redux.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.1 Triangles and Squares Redux.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.2 Another Brick in the Wall.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.2 Another Brick in the Wall.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.3 What Shape Is That.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.3 What Shape Is That.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.4 Guessing Game.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.4 Guessing Game.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.4 Triangles of All Kinds.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.4 Triangles of All Kinds.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.5 Triangles of All Kinds.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.5 Triangles of All Kinds.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.5 What Goes Up.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.5 What Goes Up.pdf -------------------------------------------------------------------------------- /Unit 2 PDF/Lab 2.6 What Goes Up.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 PDF/Lab 2.6 What Goes Up.pdf -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.1 Triangles and Squares Redux.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.1 Triangles and Squares Redux.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.2 Another Brick in the Wall.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.2 Another Brick in the Wall.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.3 What Shape Is That.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.3 What Shape Is That.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.4 Guessing Game.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.4 Guessing Game.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.4 Triangles of All Kinds.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.4 Triangles of All Kinds.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.5 Triangles of All Kinds.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.5 Triangles of All Kinds.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.5 What Goes Up.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.5 What Goes Up.docx -------------------------------------------------------------------------------- /Unit 2 Word/Lab 2.6 What Goes Up.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 2 Word/Lab 2.6 What Goes Up.docx -------------------------------------------------------------------------------- /Unit 3 PDF/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 PDF/.DS_Store -------------------------------------------------------------------------------- /Unit 3 PDF/Lab 3.1 Guessing Game.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 PDF/Lab 3.1 Guessing Game.pdf -------------------------------------------------------------------------------- /Unit 3 PDF/Lab 3.2 Drawing Shapes Again.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 PDF/Lab 3.2 Drawing Shapes Again.pdf -------------------------------------------------------------------------------- /Unit 3 PDF/Lab 3.3 Let Me Check My Calendar.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 PDF/Lab 3.3 Let Me Check My Calendar.pdf -------------------------------------------------------------------------------- /Unit 3 PDF/Lab 3.4 If My Calculations Are Correct.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 PDF/Lab 3.4 If My Calculations Are Correct.pdf -------------------------------------------------------------------------------- /Unit 3 Word/Lab 3.1 Guessing Game.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 Word/Lab 3.1 Guessing Game.docx -------------------------------------------------------------------------------- /Unit 3 Word/Lab 3.2 Drawing Shapes Again.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 Word/Lab 3.2 Drawing Shapes Again.docx -------------------------------------------------------------------------------- /Unit 3 Word/Lab 3.3 Let Me Check My Calendar.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 Word/Lab 3.3 Let Me Check My Calendar.docx -------------------------------------------------------------------------------- /Unit 3 Word/Lab 3.4 If My Calculations Are Correct.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 3 Word/Lab 3.4 If My Calculations Are Correct.docx -------------------------------------------------------------------------------- /Unit 4 PDF/Lab 4.2 You Talkin To Me.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 PDF/Lab 4.2 You Talkin To Me.pdf -------------------------------------------------------------------------------- /Unit 4 PDF/Lab 4.3 Guess Who.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 PDF/Lab 4.3 Guess Who.pdf -------------------------------------------------------------------------------- /Unit 4 PDF/Lab 4.4 Number Cruncher.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 PDF/Lab 4.4 Number Cruncher.pdf -------------------------------------------------------------------------------- /Unit 4 PDF/Lab 4.5 Its Around Here Somewhere.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 PDF/Lab 4.5 Its Around Here Somewhere.pdf -------------------------------------------------------------------------------- /Unit 4 Word/Lab 4.2 You Talkin To Me.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 Word/Lab 4.2 You Talkin To Me.docx -------------------------------------------------------------------------------- /Unit 4 Word/Lab 4.3 Guess Who.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 Word/Lab 4.3 Guess Who.docx -------------------------------------------------------------------------------- /Unit 4 Word/Lab 4.4 Number Cruncher.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 Word/Lab 4.4 Number Cruncher.docx -------------------------------------------------------------------------------- /Unit 4 Word/Lab 4.5 Its Around Here Somewhere.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 4 Word/Lab 4.5 Its Around Here Somewhere.docx -------------------------------------------------------------------------------- /Unit 5 PDF/Lab 5.1 Connect the Dots.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 PDF/Lab 5.1 Connect the Dots.pdf -------------------------------------------------------------------------------- /Unit 5 PDF/Lab 5.2 Lots of Balls.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 PDF/Lab 5.2 Lots of Balls.pdf -------------------------------------------------------------------------------- /Unit 5 PDF/Lab 5.3 Fewer Balls.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 PDF/Lab 5.3 Fewer Balls.pdf -------------------------------------------------------------------------------- /Unit 5 Word/Lab 5.1 Connect the Dots.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 Word/Lab 5.1 Connect the Dots.docx -------------------------------------------------------------------------------- /Unit 5 Word/Lab 5.2 Lots of Balls.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 Word/Lab 5.2 Lots of Balls.docx -------------------------------------------------------------------------------- /Unit 5 Word/Lab 5.3 Fewer Balls.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/Unit 5 Word/Lab 5.3 Fewer Balls.docx -------------------------------------------------------------------------------- /VariableCreateImage.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/VariableCreateImage.PNG -------------------------------------------------------------------------------- /VariableImage.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/VariableImage.PNG -------------------------------------------------------------------------------- /VariableInUse.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/VariableInUse.PNG -------------------------------------------------------------------------------- /ZoomBlocks.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/ZoomBlocks.PNG -------------------------------------------------------------------------------- /addition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/addition.png -------------------------------------------------------------------------------- /additional_curriculum_resources.md: -------------------------------------------------------------------------------- 1 | TEALS Volunteers and Teachers can find additional Intro CS curriculum resources in the TEALS Curriculum Repository. To access the repository, sign in to the TEALS Dashboard at , and click on "Additional Curriculum Materials" under "Resources." 2 | -------------------------------------------------------------------------------- /and.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/and.png -------------------------------------------------------------------------------- /answer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/answer.png -------------------------------------------------------------------------------- /appendix-bjc-video-lectures.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/appendix-bjc-video-lectures.md -------------------------------------------------------------------------------- /ask.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/ask.png -------------------------------------------------------------------------------- /basicSequentialSearch.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/basicSequentialSearch.jpg -------------------------------------------------------------------------------- /book.json: -------------------------------------------------------------------------------- 1 | { 2 | "plugins": [ 3 | "mathjax" 4 | ], 5 | "pluginsConfig": {} 6 | } -------------------------------------------------------------------------------- /brick wall.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/brick wall.png -------------------------------------------------------------------------------- /broadcast.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/broadcast.png -------------------------------------------------------------------------------- /changeY.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/changeY.png -------------------------------------------------------------------------------- /changepensize.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/changepensize.png -------------------------------------------------------------------------------- /chapter1.md: -------------------------------------------------------------------------------- 1 | # First Chapter 2 | 3 | GitBook allows you to organize your book into chapters, each chapter is stored in a separate file like this one. 4 | -------------------------------------------------------------------------------- /clear.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/clear.png -------------------------------------------------------------------------------- /cloudButton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/cloudButton.png -------------------------------------------------------------------------------- /cloudSignup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/cloudSignup.png -------------------------------------------------------------------------------- /contributing.md: -------------------------------------------------------------------------------- 1 | 2 | # Contributing 3 | 4 | ## Repository Location 5 | The curriculum's source code is hosted on Github at: https://github.com/TEALS-IntroCS/introduction-to-computer-science-principles 6 | 7 | You can open issues, fork the curriculum, or submit pull requests to suggest changes. 8 | 9 | ## Markdown style 10 | 11 | To keep the curriculum's underlying markdown consistent, we use [this markdown style guide](http://www.cirosantilli.com/markdown-style-guide). Since markdown is not a strict specification, there are a few options we choose to take from the style guide 12 | * [space-sentence:1]( http://www.cirosantilli.com/markdown-style-guide/#option-space-sentence-1) 13 | * [wrap:inner-sentence](http://www.cirosantilli.com/markdown-style-guide/#option-wrap-inner-sentence) 14 | * [header:atx](http://www.cirosantilli.com/markdown-style-guide/#option-header-atx) 15 | * [list-space:mixed](http://www.cirosantilli.com/markdown-style-guide/#option-list-space-mixed) 16 | * [code:fenced](http://www.cirosantilli.com/markdown-style-guide/#option-code-fenced) 17 | 18 | ### Updating GitBook with changes 19 | 20 | If you make changes to file names and links, make sure to update the GitBook references in summary.md accordingly. 21 | 22 | ### Lint tool 23 | 24 | We use [mdast-lint](https://github.com/wooorm/mdast-lint) to enforce the above style. All submissions will be run through [mdast-lint](https://github.com/wooorm/mdast-lint) and free of any errors and warnings. 25 | 26 | ## Curriculum style 27 | 28 | ### How to write *Snap!* 29 | ``` 30 | *Snap!* 31 | ``` 32 | 33 | 34 | ### *Snap!* Code 35 | Blocks and scripts should always be presented as they would be in *Snap!*—as an image. 36 | 37 | Good 38 | > Use the ![move 10 steps](move.png) block to move your sprite. 39 | 40 | Bad 41 | > Use the move block to move your sprite. 42 | 43 | If it is absolutely necessary that a block not have a picture, wrap the name in blockquotes (e.g. ```move 10 steps``` block). 44 | 45 | #### Creating new script images 46 | Use the "script pic..." feature to create new images. If you need the result of a reporter block, use shift-right-click to get the "script pic with result..." option. 47 | 48 | If you are adding a block, the file name should follow the text of the block with lower camel case. 49 | 50 | Good 51 | > ![move 10 steps](move.png) -> ```move10Steps.png``` 52 | 53 | Bad 54 | > ![move 10 steps](move.png) -> ```move.png``` 55 | 56 | #### Reusing existing script images 57 | Before you create new blocks images, check to see of blocks are stored in the curriculum in ```/blocks```. 58 | 59 | All script images should be stored in ```/scripts```. 60 | 61 | ### Vocabulary words 62 | 63 | ### Labs 64 | 65 | ### Lesson plans 66 | 67 | ## Creating a pull request 68 | 69 | Each pull request should have it's own branch. Here are a few examples of a proper pull request workflow 70 | * http://codeinthehole.com/writing/pull-requests-and-other-good-practices-for-teams-using-github/ 71 | * https://github.com/skyscreamer/yoga/wiki/GitHub-Best-Practices 72 | * https://www.thinkful.com/learn/github-pull-request-tutorial/ 73 | 74 | 75 | -------------------------------------------------------------------------------- /createACloneOf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/createACloneOf.png -------------------------------------------------------------------------------- /culture_day_lesson_b.md: -------------------------------------------------------------------------------- 1 | # Culture Day Lesson B: Student Research Project/Presentation 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Describe in detail the topic of their assigned/chosen project 6 | * Answer questions about their topic 7 | * Connect the project and topic to computer science 8 | 9 | ## Materials/Preparation 10 | * A list of possible topics for research projects 11 | * Guidelines for projects and/or presentations 12 | 13 | 14 | ## Pacing Guide 15 | |Duration | Description| 16 | |--|--| 17 | |5 minutes | Welcome, attendance, bell work, announcements | 18 | |15 minutes | Presentation #1 | 19 | |15 minutes | Presentation #2 | 20 | |15 minutes | Presentation #3 | 21 | |5 minutes | Debrief and wrap-up | 22 | 23 | ## Instructor's Notes 24 | 1. _**Prior to Culture Day**_ 25 | * Assign each student one or more topics to research and present to the class on a future day 26 | * Topics can be assigned, chosen by students from a pre-defined list, or suggested by students and approved by instructors 27 | * Possible options include: 28 | * Famous figures in computer science (Grace Hopper, Alan Turing, Kernighan & Ritchie, etc.) 29 | * Important technologies or algorithms (RSA, Dijstra's Algorithm, RAID, etc.) 30 | * Societal or cultural topics (social media, cyberbullying, computer security, etc.) 31 | * Create a schedule of when culture days will occur and which students will present on each day 32 | 33 | 2. Student presentations 34 | * Each student should give a 5-7 minute presentation on their assigned topic, followed by 8-10 minutes for Q&A 35 | * Students should have a visual aspect to their project (poster, PowerPoint, prop bag, etc.) as well as giving a verbal presentation 36 | * Use your judgement regarding the level of technical detail expected in the presentation. It is probably not realistic to expect students to become experts in advanced technologies such as RSA, but they should be able to explain, at least at a high level, the details of their topic. 37 | * Do not allow students to simply read a textbook or online definition of the topic-- ensure they can at least explain the subject in their own words. 38 | * Allow classmates to ask questions, but beware of students trying to stump each other. 39 | * Have a few questions for each assigned topic prepared ahead of time for instructors to ask in case classmates do not have questions. 40 | 41 | 42 | ## Accommodation/Differentiation 43 | * In smaller classes, each student may be able to present twice in a single semester. 44 | * For classes where students are less experienced with presentations, consider a "science fair"-style event where students produce a display that can be viewed by others to present their topic. 45 | -------------------------------------------------------------------------------- /deleteThisClone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/deleteThisClone.png -------------------------------------------------------------------------------- /distanceTo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/distanceTo.png -------------------------------------------------------------------------------- /dots.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/dots.PNG -------------------------------------------------------------------------------- /draw squares.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/draw squares.png -------------------------------------------------------------------------------- /forever.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/forever.png -------------------------------------------------------------------------------- /foreverIf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/foreverIf.png -------------------------------------------------------------------------------- /foreverdrawsomething.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/foreverdrawsomething.png -------------------------------------------------------------------------------- /forevergotomouse.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/forevergotomouse.png -------------------------------------------------------------------------------- /forevermove.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/forevermove.png -------------------------------------------------------------------------------- /foreversay.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/foreversay.png -------------------------------------------------------------------------------- /foreversayanimals.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/foreversayanimals.png -------------------------------------------------------------------------------- /glide.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/glide.png -------------------------------------------------------------------------------- /gotomousex30.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/gotomousex30.png -------------------------------------------------------------------------------- /gotox-y.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/gotox-y.png -------------------------------------------------------------------------------- /if-else.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/if-else.png -------------------------------------------------------------------------------- /if.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/if.png -------------------------------------------------------------------------------- /importcostumes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/importcostumes.png -------------------------------------------------------------------------------- /importingListInstructions.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/importingListInstructions.PNG -------------------------------------------------------------------------------- /kaleidoscopegif.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/kaleidoscopegif.gif -------------------------------------------------------------------------------- /lab_04.md: -------------------------------------------------------------------------------- 1 | # Lab 0.4 - Getting to Know You 2 | In this lab, you will explore SNAP and create a simple "self-portrait" program to introduce yourself to your instructors and classmates. 3 | 4 | ## Part 1 - Who Are You? 5 | 1. Open [SNAP](http://snap.berkeley.edu/snapsource/snap.html) on your computer and spend a few minutes looking around, trying things out, and seeing what the language can do. Don't worry about understanding everything completely-- we'll go through things in a lot more detail soon. Just try to get a sense of some of the basic capabilities. 6 | 7 | 2. Write down three things you found that SNAP can do and how to do them. Be as specific as you can! 8 | 9 | |SNAP can do this...| If I do this...| 10 | |---|---| 11 | |1. | | 12 | |2. | | 13 | |3. |. | 14 | 15 | 3. Find a partner and compare notes. Share your findings with your partner and ask him or her about what he or she learned. Write down the three capabilities your partner found below. 16 | 17 | |SNAP can do this...| If I do this...| 18 | |---|---| 19 | |1. | | 20 | |2. | | 21 | |3. |. | 22 | 23 | 4. Using what you've learned and other things you might discover, create a SNAP program that describes yourself. This can take whatever form and use whatever SNAP tools and blocks you want. Make sure that somehow, at some point in your program you show the following information: 24 | * Your name 25 | * Your current grade 26 | * Your age 27 | * Your favorite class in school 28 | * One of your hobbies or interests 29 | * Any previous programming or computer experience you have -------------------------------------------------------------------------------- /lab_13.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 1.3: Squares and Triangles and Stars, Oh, My! 3 | 4 | In this lab, you will write your first SNAP programs to draw some simple shapes on the stage. 5 | 6 | ## 1. Drawing a square 7 | 8 | 1.1) Write a SNAP script that draws a square when the number 1 is pressed on the keyboard. Remember that each corner of a square is a 90° angle, as shown in the figure below. 9 | 10 | ![square diagram](90degreesquare.PNG) 11 | 12 | 1.2) Add code so that the sprite says the word "square" while it is drawing. The sprite should stop saying "square" once it has finished drawing the square. 13 | 14 | 1.3) Add code so that pressing the space bar clears the pen marks from the stage. 15 | 16 | ## 2. Adding more shapes 17 | 18 | 2.1) Now that you've drawn a square, add code to draw the shapes in the following table. Each shape should be drawn when the number next to it is pressed on the keyboard. (For example, pressing 3 on the keyboard should draw a diamond.) 19 | 20 | | When this key is pressed... | Draw a ... | 21 | | --------------------------- | ----------------------------------- | 22 | | 1 | Square | 23 | | 2 | Equilateral triangle | 24 | | 3 | Diamond | 25 | | 4 | Pentagon | 26 | | 5 | Parallelogram ("leaning rectangle") | 27 | | 6 (optional) | 5-pointed star | 28 | 29 | You may want to draw a diagram similar to the one above of a square to figure out the angles in each shape. 30 | 31 | 2.2) Add code so that as each shape is being drawn, the sprite is saying the name of shape. The sprite should stop saying the name of the sprite when it is finished drawing. 32 | 33 | 2.3) Modify your code so that each different shape is drawn in a _different_ color and with a _different line thickness_. So, for example, if the square is drawn in blue with a line thickness of 3, each other shape must be drawn in a color that is not blue and with a line thickness that is not 3. 34 | 35 | 2.4) Add code so that the sprite is hidden when it is not drawing. This is will make sure that the sprite is not obstructing the view of your beautiful artwork! 36 | -------------------------------------------------------------------------------- /lab_14.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 1.4: Sprites in Action 3 | 4 | In this lab, you will use costumes and movement to create simple SNAP animations. 5 | 6 | ## 1. Run, Spot, Run! 7 | 8 | 1.1) In a SNAP project, click on the file menu, then click costumes. Import the costumes "dog2-b" and "dog2-c". 9 | 10 | ![Menu->Costumes](menucostumes.png) 11 | 12 | ![Import Costumes](importcostumes.png) 13 | 14 | 1.2) Write a script to make the sprite change costume each time the space bar is pressed. The sprite should switch back and forth between the two costumes. 15 | 16 | 1.3) Add code so that the sprite will face to the left, move a few steps, and change costume when the left arrow key is pressed. If you've done it right, it should look like the dog is walking when you press the left arrow key repeatedly. 17 | 18 | 1.4) Add code so that the dog can walk to the right as well. 19 | 20 | ## 2. Here be Dragons! 21 | 22 | 2.1) Create a new sprite. Following the same steps as in part 1.1, import the costumes "dragon1-a" and "dragon1-b" 23 | 24 | 2.2) Write a script to make the sprite appear to breathe fire when the 'f' key is pressed. The sprite should switch to the "fire-breathing" costume for a few seconds, then switch back to the "normal" costume. 25 | 26 | 2.3) Modify your code so that the dragon "attacks" the mouse pointer when the 'f' key is pressed. When the 'f' key is pressed, the dragon should take the following actions in order: 27 | 28 | - Make sure it is in the "normal" costume 29 | - Point at the mouse pointer 30 | - Glide to the mouse pointer's position 31 | - Change to the "fire-breathing" costume 32 | - Pause to breathe fire 33 | - Change back to the "normal" costume 34 | 35 | ## 3. Run Away! 36 | 37 | 3.1) Add another sprite to your program. (This sprite can have any costume you choose.) 38 | 39 | 3.2) Write a script to make this new sprite point away from the dragon and move when the 'r' key is pressed. (You'll need more than one block to do this.) 40 | 41 | 3.3) Modify your code so that instead of moving when the 'r' key is pressed, the new sprite moves when the dragon "attacks." The "fleeing" sprite should move when the dragon starts breathing fire. 42 | 43 | 3.4) Add a second sprite that runs away from the dragon as well. 44 | -------------------------------------------------------------------------------- /lab_21.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 2.1 - Squares and Triangles Redux 3 | In this lab, you will rewrite your SNAP programs from Lab 1.3 to draw shapes using loops. 4 | 5 | ## Section 1 - Back In Time 6 | 7 | 1. Open your solution to the original "Squares and Triangles and Stars, Oh My!" activity. Go to the "File" menu and select "Save as..." to give your project a new name. 8 | ![]() 9 | 10 | ## Section 2 - Simplifying Code 11 | 12 | 1. Look at your code to draw a square. It is probably quite long and has lots of repeated blocks. Using what you have learned about loops, rewrite this script to be shorter and have less redundancy. Make sure that your code still works as originally intended. 13 | 14 | 2. Now modify your other shape scripts to also use loops. In all cases, try to have as few blocks and as little redundancy as possible while still keeping your code easy to read and understand. 15 | 16 | ## Section 3 - Adding More Shapes 17 | 18 | 1. Add code to your program to draw the extra shapes below. Follow all the original guidelines (different color and line thickness for each shape, say the name while drawing) and use loops to keep your scripts as short as possible. 19 | 20 | | _When this key is pressed..._ | _Draw a..._ | 21 | | ----------------------------- | -------------------------- | 22 | | 7 | Decagon (10-sided polygon) | 23 | | 8 | Circle | 24 | 25 | You may not be able to draw a true circle, but you should get as close as you can. 26 | -------------------------------------------------------------------------------- /lab_22.md: -------------------------------------------------------------------------------- 1 | # Lab 2.2 - Another Brick in the Wall 2 | 3 | In this lab, you will use nested loops to draw a large brick wall using as little code as possible. 4 | 5 | ## Part 1 - Brick by Brick 6 | 7 | 1. Write a SNAP script to draw a single 20x10 "brick" in the lower left corner of the stage when the green flag is clicked. 8 | 9 | 2. Modify your code to draw two bricks side by side. The bricks should share a short edge, like this: ![]() 10 | 11 | 3. Now modify your code again to build a full row of bricks across the entire length of the stage. Use a loop to keep your code as concise as possible. Remember that the stage is 480 pixels wide. 12 | 13 | ## Part 2 - Build a Wall 14 | 15 | 1. Now that you can build a row of bricks, add code to build a second row above the first row. The bricks in the second row should share a long edge with those in the first row, but should be "offset" so that the ends of the second row bricks are at the middle of the first row bricks, like this: ![]() 16 | 17 | 2. Modify your code to build four total rows, alternating back and forth between the "regular" and "offset" rows. Use nested loops to keep your code concise. 18 | 19 | 3. Finish off the wall the by building alternating rows all the way to the top of the stage. Remember that the stage is 360 pixels tall. Your final wall should look like this: 20 | ![]() 21 | -------------------------------------------------------------------------------- /lab_23.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 2.3 - What Shape is That? 3 | In this lab, you will use user input and conditional statements to identify shapes based on the number of sides and some other properties as given by the user. 4 | 5 | ## Part 1 - Triangle...or no triangle? 6 | 7 | 1. Write a SNAP program that asks the user to think of a shape and input how many sides it has. Then, if the user is thinking of a triangle, tell him or her so. Regardless of whether or not the shape was a triangle, thank the user for playing. 8 | 9 | 2. Modify your program to give an appropriate message both when the user _is_ thinking of a triangle and when he or she is _not_ thinking of a triangle. Give the same thank you message afterward in either case. 10 | 11 | ## Part 2 - Name That Polygon! 12 | 13 | You will now expand your program from above so that instead of just deciding if a shape is a triangle or not, your program will be able to name the specific polygon. Your program must be able to identify at least the following shapes: 14 | 15 | | _Number of sides_ | _Polygon name_ | 16 | | ----------------- | -------------- | 17 | | 3 | Triangle | 18 | | 4 | Quadrilateral | 19 | | 5 | Pentagon | 20 | | 6 | Hexagon | 21 | | any other number | Unknown | 22 | 23 | 1. Fill out a [Planning Worksheet] (https://github.com/TEALS-IntroCS/introduction-to-computer-science-principles/blob/master/SNAP%20Program%20Design%20and%20Planning%20Worksheet.docx?raw=true) for the above program. Make sure you consider all aspects of the program carefully. 24 | 25 | 2. Write the program. Be sure that your program works correctly in all cases. 26 | 27 | ## Part 3 - Quadrilateral Fever! 28 | 29 | Quadrilaterals come in many different varieties. Add code to your program so that, if the user is thinking of is a quadrilateral, you ask more questions to find out which type of quadrilateral it is. Your program should give the most specific name that applies. The following table describes the quadrilaterals you should know about from most to least specific: 30 | 31 | | _Property_ | _Quadrilateral name_ | 32 | | ----------------------------------------------------------------------------- | --------------------- | 33 | | All four sides have the same length and all four angles have the same measure | Square | 34 | | Not a square and all four angles have the same measure | Rectangle | 35 | | Not a rectangle and each side is parallel to one other side | Parallelogram | 36 | | Not a parallelogram and two sides are parallel to each other | Trapezoid | 37 | | Not a trapezoid | Unknown quadrilateral | 38 | 39 | ![](QuadrilateralSets.PNG) 40 | 41 | 1. Fill out a [Planning Worksheet] (https://github.com/TEALS-IntroCS/introduction-to-computer-science-principles/blob/master/SNAP%20Program%20Design%20and%20Planning%20Worksheet.docx?raw=true) for the above program. Make sure you consider all aspects of the program carefully. 42 | 43 | 2. Write the program. Be sure that your program works correctly in all cases. 44 | -------------------------------------------------------------------------------- /lab_24.md: -------------------------------------------------------------------------------- 1 | # Lab 2.4 - Guessing Game <----Formerly 3.1----> 2 | 3 | In this lab, you will use conditional statements and variables to build a simple number guessing game. 4 | _(Adapted from BJC: )_ 5 | 6 | ## Section 1 - I'm Thinking of a Number... 7 | 8 | You will write a SNAP program to choose a random number between 1 and 10 and then ask the user to guess a number. If the user's guess matches the random number, the user wins. If not, the user loses. In either case, the user should be shown a message indicating whether he won or lost and the secret random number should be revealed. 9 | 10 | 1. Fill out a [Planning Worksheet]() for the above program. 11 | 12 | 2. Write the simple version of the guessing game program described above. 13 | 14 | 3. Modify the program to keep asking the user for guesses until the correct number is given. Be sure to give a message after each guess, but only reveal the secret number when the user has guessed correctly and the game is over. 15 | 16 | 4. Add code to ask the player their name at the start of the game. Then, personalize the message for an incorrect guess by adding the player's name. For example, if Sarah is playing the game, then the message should say "Sorry, Sarah, that guess is not correct" instead of just "Sorry" when Sarah guesses incorrectly. 17 | 18 | ## Section 2 - Game Upgrades 19 | 20 | 1. Modify your guessing game so that the player can decide the range of possible numbers from which the secret number can be chosen. After asking the player's name, ask what he or she wants the highest possible number to be. Then, instead of choosing a random number between 1 and 10, choose a random number between 1 and the number the player requested. 21 | 22 | 2. Add code to keep track of how many guesses the player has made. After the player guesses correctly, inform him or her how many tries it took before the correct number was guessed. 23 | 24 | 3. Increase the player's chances by telling him or her whether the guessed number is too high or too low instead of just that it is incorrect. 25 | -------------------------------------------------------------------------------- /lab_25.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 2.5 - Triangles of All Kinds 3 | 4 | In this lab, you will use Boolean operators to determine what sort of triangle a user is describing. 5 | 6 | ## Is that even possible!? 7 | 8 | 1. Write a SNAP program that asks the user for the lengths of all three sides of a triangle. Store each length in a variable. Then say the perimeter of the triangle with those three side lengths 9 | 10 | 2. Add code to your program to check whether or not the three side lengths can form a real triangle. Remember that, in any real triangle, the sum of the lengths of any two sides is greater than the length of the third side. So, if the triangle has side lengths $$a$$, $$b$$, and $$c$$, then all of the following must be true: 11 |
12 | $$ 13 | \begin{align*} 14 | a + b &> c\\ 15 | a + c &> b\\ 16 | b + c &> a 17 | \end{align*} 18 | $$ 19 | 20 | If the sides given cannot make a real triangle, say so instead of saying the perimeter. 21 | 22 | ## What kind of triangle? 23 | 24 | 1. Add code to your program to determine and say whether or not the triangle described is a right triangle. If the triangle has side lengths $$a$$, $$b$$, and $$c$$, then the triangle is a right triangle if the following is true: 25 |
26 | $$ 27 | \begin{align*} 28 | a ^ 2 + b ^ 2 = c ^ 2 29 | \end{align*} 30 | $$ 31 | 32 | 2. Add code to your program to determine which type of triangle has the side lengths given. A triangle can be one of the following three types: 33 | 34 | | Triangle type | Description | 35 | | ------------- | ------------------------------------- | 36 | | Equilateral | All three side lengths equal | 37 | | Isosceles | Two side lengths equal, one different | 38 | | Scalene | All three side lengths different | 39 | -------------------------------------------------------------------------------- /lab_26.md: -------------------------------------------------------------------------------- 1 | # Lab 2.6 - What Goes Up... 2 | 3 | In this lab, you will use everything you've learned about loops and conditionals to construct a simple model for gravity. 4 | 5 | ## Channeling Newton 6 | 7 | 1. Create a SNAP program with a background that looks like an outside scene. Add a single sprite that looks like an object of your choice (a brick or a ball would work well) and place it so it is touching the "ground." 8 | 9 | 2. Write code for your sprite so that, when the green flag is clicked, the object moves to the top of the stage and "falls" towards the bottom at a constant speed. 10 | 11 | 3. What happens in your program when the object hits the "ground"? Is that an accurate model of how gravity works on Earth? 12 |
13 |
14 |
15 |
16 |
17 |
18 | 19 | 4. Modify your program so that the problem you identified in part 1.3 is fixed. Make your object do something appropriate when it hits the "ground." (Making sure the ground is a unique color and making use of that color will be helpful.) 20 | 21 | ## ...Must Come Down 22 | 23 | 1. Add a second sprite that looks like something that might already be on the ground when your first object is falling (like a house, a picnic table, a person, etc.). Put this new object directly below where the first object falls so that the falling object will hit it. 24 | 25 | 2. What should happen when the following object hits the object on the ground? Will that happen with the model we currently have? Why or why not? 26 |
27 |
28 |
29 |
30 |
31 |
32 | 33 | 3. Modify your code so that you fix the problem you identified in part 2.2. Make your falling object do something appropriate if it hits the object on the ground. Once you've made that work, move the falling object and make sure you didn't break the situation when the falling object doesn't hit something on the way down. 34 | 35 | 4. Add code so that both objects move to a random x coordinate every time the green flag is clicked. The falling object should be at the top of the stage, and the other object at the bottom. Verify that the falling object does the right thing no matter where the two objects end up relative to each other. 36 | 37 | 5. Add a hill to your outdoor scene and make sure that your falling object does something appropriate when it hits the hill. 38 | -------------------------------------------------------------------------------- /lab_32.md: -------------------------------------------------------------------------------- 1 | # Lab 3.2 - Drawing Shapes (Again) 2 | 3 | In this lab, you will write code to draw regular polygons. But this time, you will write custom blocks and abstraction to write more efficient code. 4 | 5 | ## Simple Shapes 6 | 7 | 1. Write a SNAP script (or find one you've already written) to draw a square. 8 | 9 | 2. Write a SNAP script (or find one you've already written) to draw an equilateral triangle. 10 | 11 | 3. Write a SNAP script (or find one you've already written) to draw a regular pentagon. 12 | 13 | 4. Write a SNAP script (or find one you've already written) to draw a regular octagon. 14 | 15 | 5. Look over the four programs from above. Do you notice sections that are very similar? What sections might be able to be abstracted into a separate block? 16 |
17 |
18 |
19 |
20 |
21 | 22 | ## If You've Seen One... 23 | 24 | 1. Take your script from above that draws a square and turn it into a custom block. 25 | 26 | 2. Modify your custom block to use a variable for the number of sides instead of the number 4. Set that variable's value to be 4 so that you still draw a square. 27 | 28 | 3. Now, see if you can modify your block so that it will work correctly for any number of sides greater than 2. Look closely at the angles in your four scripts section 1 and see if you can spot a pattern. 29 | 30 | 4. Use your custom block in a program that asks the user for a number and then draws a regular polygon with that many sides. If the number given is less than 3, give an error message and do not draw anything. 31 | 32 | ## Bonus: Sizing Things Up 33 | 34 | 1. Modify your custom block and program from the previous section so that the user can specify both the number of sides and the size of each side. Be sure to utilize generalization and detail removal to make your program and block as clear and concise as possible. 35 | -------------------------------------------------------------------------------- /lab_33.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 3.3 - Let Me Check My Calendar 3 | 4 | In this lab, you will write some custom blocks that take arguments and are useful for calculations involving dates and calendars. 5 | 6 | ## Basics 7 | 8 | 1. Write a custom SNAP block called "month name" that takes a number between 1 and 12 as an argument and says the name of the corresponding month. 9 | 10 | 2. Write a custom SNAP block called "day name" that takes a number between 1 and 7 as an argument and says the name of the corresponding day. For our purposes, the week begins on Sunday. 11 | 12 | 3. Write a custom SNAP block called "days in " that takes a month name as an argument and says how many days are in that month. Assume a non-leap year. 13 | 14 | ## Going Farther 15 | 16 | 1. Write a custom SNAP block called "is a leap year" that takes a year number as an argument and says whether or not that year is a leap year. 17 | 18 | - A year is a leap year if the year is a multiple of 4 that is not a multiple of 100 (e.g. 1984), or if it is a multiple of 400 (e.g. 2000). Years that are mutiples of 100 but not mutiples of 400 are NOT leap years (e.g. 1800). See [Wikipedia](https://en.wikipedia.org/wiki/Leap_year#Algorithm) for more detail. 19 | 20 | 2. Write a custom SNAP block called "is a valid date" that takes a month name and a date as arguments and says whether or not that date exists in that month. For example, the 31st is a valid date in January, but not in June. The 5th is a valid date in every month, and the 40th is not a valid date in any month. 21 | 22 | 3. Write a custom SNAP block called "day in year" that takes a year number and a number between 1 and 366 and says the date that corresponds to that numbered day of the specified year. For example, in non-leap years day #1 is January 1, day #32 is February 1, day #365 is December 31, and day #185 is July 4. Give an error message if the number is 366 and a non-leap year is specified. 23 | 24 | 4. BONUS: Write a custom SNAP block called "day of week" that takes a month name, date, and year as arguments and says the day of week on which that date falls in that year. See for information on finding the day of the week from a date. 25 | -------------------------------------------------------------------------------- /lab_34.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 3.4 - If My Calculations Are Correct... 3 | 4 | In this lab, you will write custom reporter blocks to perform a number of useful calculations and computations. 5 | 6 | ## Simple Computations 7 | 8 | 1. Write a custom SNAP reporter block called "min" that determines which of two numbers is smaller and reports that value. If the two numbers are equal, report either one. 9 | 10 | 2. Write a custom SNAP reporter block called "max" that determines which of two numbers is larger and reports that value. If the two numbers are equal, report either one. 11 | 12 | 3. Write a custom SNAP predicate block called "between" that determines if a number is between two other numbers. If the first number is equal to either of the other two numbers or is between them, the block should report "true". 13 | 14 | 4. Write a custom SNAP predicate called "at least as long as" that determines whether or not word has at least a specified number of letters. 15 | 16 | ## Stepping Things Up 17 | 18 | 1. Write a custom SNAP reporter block called "distance to" that computes and reports the distance from a sprite's position to another point. Use the "x position" and "y position" blocks to determine the sprite's position. Remember that the formula for the distance between points $$(x_1, y_1)$$ and $$(x_2, y_2)$$ is $$\sqrt{((y_2-y_1)^2+(x_2-x_1)^2 )}$$ . 19 | 20 | 2. Write a custom SNAP predicate block called "contains letter" that determines whether or not a word contains a particular letter. You can consider upper-case and lower-case letters to be different for the purposes of matching. 21 | -------------------------------------------------------------------------------- /lab_42.md: -------------------------------------------------------------------------------- 1 | # You Talkin' to Me? 2 | 3 | In this lab, you will create a simple sentence generator using lists. (Adapted from BJC: ) 4 | 5 | ## Let's Talk 6 | 7 | 1. Create a variable for each part of speech below, and set each variable to hold a list of words that fit that part of speech. Some examples are given, but feel free to use your own. 8 | 9 | | Part of Speech | Example words | 10 | | -------------- | ------------------------------------------------ | 11 | | noun | giraffe, monkey, boy, girl, elephant, ... | 12 | | verb | jumps, runs, sleeps, sits, dances, ... | 13 | | adjective | big, small, loud, silly, young, old, sleepy, ... | 14 | | adverb | quickly, excitedly, angrily, happily, sadly, ... | 15 | | article | a, the | 16 | | preposition | under, over, around, near, beside, ... | 17 | 18 | 1. Write a custom reporter block called "noun phrase" that reports a noun phrase where each word is chosen randomly from the lists you created. A noun phrase consists of an article, an adjective, and a noun in that order. 19 | 20 | 2. Write custom reporter blocks like "noun phrase" for each of the phrase types listed below. 21 | 22 | | Phrase type | Construction | 23 | | -------------------- | -------------------------------- | 24 | | prepositional phrase | preposition, noun phrase | 25 | | verb phrase | adverb, verb, preposition phrase | 26 | | sentence | noun phrase, verb phrase | 27 | 28 | 1. Write code so that when you press the space bar, a random sentence is generated and a sprite says the resulting sentence. 29 | 30 | 2. BONUS: Modify your code so that a noun phrase can either be the construction from part 1.2 or a single proper noun (e.g. a person's name). Your code should randomly decide which version of a noun phrase to use. 31 | 32 | 3. BONUS: Modify your code so that a verb phrase can sometimes leave out the prepositional phrase. Your code should randomly decide to include the prepositional phrase or not. 33 | 34 | ## Changing Our Vocabulary 35 | 36 | 1. Write a script so that when the 'n' key is pressed, the user is prompted for a new noun and that noun is added to list of nouns. After that point, the new noun entered by the user should be able to appear in sentences. 37 | 38 | 2. Write scripts like the one you wrote in part 2.1 to add words to the other lists. Use the keys listed below. 39 | 40 | | Key | Part of speech | 41 | | --- | -------------- | 42 | | v | verb | 43 | | j | adjective | 44 | | d | adverb | 45 | | a | article | 46 | | p | preposition | 47 | 48 | 1. Write a script so that when the 'x' key is pressed, the user is asked for one of the parts of speech and then for a number (n). Your script should remove the nth item from the list of words for the specified part of speech. For example, if the user types in "verb" and "3" then you should remove the 3rd word from the list of verbs. The removed word should no longer appear in sentences. 49 | -------------------------------------------------------------------------------- /lab_43.md: -------------------------------------------------------------------------------- 1 | 2 | # Lab 4.3 - Guess Who 3 | 4 | In this lab, you will create a list of names and then look through the list pulling out different subsets of the names. (Adapted from Jeff Tyson: and ) 5 | 6 | ## Role Call 7 | 8 | 1. Create a list of names with at least six different names. Try to vary the names as much as you can. 9 | 10 | 2. Write a SNAP script to welcome each person to the program by name, one at a time. (For example, "Welcome, John." "Welcome, Mary." "Welcome, Scott.") Make sure not to modify the list of names when you run the script—you'll want the list again later. Also make sure your script still works even if the list of names changes. 11 | 12 | 3. Write a new SNAP script that welcomes all the players at once. So, for example instead of saying "Welcome, John," "Welcome, Mary," and "Welcome, Scott." separately, you're new script should say "Welcome John, Mary, and Scott." Start by writing a script that can say all the names on one line, then try to add the commas and "and". Make sure your script works correctly no matter how many names are in the list. 13 | 14 | 4. BONUS: Modify your code so that instead of using a pre-determined list of names, the user can enter the names to be included in the list one at a time. You'll need to decide how to determine when the user has entered all the names. 15 | 16 | ## I'm Looking For... 17 | 18 | 1. Write a script that says every other name in a list one at a time when the space bar is pressed. Use the same list of names from above. For example, if the list is [Eric, Sally, Michelle, John, Sam, Caleb], the names Eric, Michelle, and Sam would be said. 19 | 20 | 2. Write a script that says the names in the list one at a time in reverse order when the '0' key is pressed. For example, if the list is [Eric, Sally, Michelle, John, Sam, Caleb], the names Caleb, Sam, John, Michelle, Sally, and Eric would be said. 21 | 22 | 3. Write scripts so that when each of the following keys is pressed, the corresponding subset of names from the list is said one at a time. 23 | 24 | | When this key is pressed... | Say the names in the list that... | For example... | 25 | | --------------------------- | --------------------------------------------------- | --------------------- | 26 | | 1 | Have more than four letters | Sally, Michelle | 27 | | 2 | Start with the letter 'c' | Caleb | 28 | | 3 | End with the letter 'y' | Sally | 29 | | 4 | Are not the first two or last two names in the list | Michelle, John | 30 | | 5 (optional) | Contain the letter 'e' | Eric, Michelle, Caleb | 31 | -------------------------------------------------------------------------------- /lab_44.md: -------------------------------------------------------------------------------- 1 | # Number Cruncher 2 | 3 | In this lab, you will continue practicing processing lists, this time using lists of numbers instead of words. 4 | 5 | ## Summarizing Numbers 6 | 7 | 1. Write a custom SNAP reporter block called "sum" that takes a list as an argument and reports the sum of all the numbers in the list. You can assume that all items in the list passed as the argument will be numbers, though you should not assume anything else. 8 | 9 | 2. Write a custom SNAP reporter block called "average" that takes a list as an argument and reports the average of all the numbers in the list. As above, you can assume that all items in the list passed as the argument will be numbers, but you should not assume anything else. 10 | 11 | 3. Write a custom SNAP predicate block called "includes negative" that takes a list as an argument and reports true if the list contains at least one negative number, and false if all numbers are non-negative. 12 | 13 | 4. Write a custom SNAP predicate block called "increasing?" that takes a list of numbers as an argument and reports true if each value in the list is greater than or equal to the one before it. 14 | 15 | 5. Write a custom SNAP reporter block called "maximum" that takes a list as an argument and reports the largest number in the list. 16 | 17 | ## Transforming Lists 18 | 19 | 1. Write a custom SNAP reporter block called "make all positive" that takes a list of numbers as an argument and reports a new list that is the same as the argument, except all negative numbers have been replaced by their absolute value. 20 | 21 | 2. Write a custom SNAP reporter block called "only evens" that takes a list of integers as an argument and reports a new list that contains only the even numbers from the argument list. The result list should have its values in the same order as the original list, but with the odd integers removed. (Remember that "mod" block can be useful in determining whether or not a number is even.) 22 | 23 | 3. BONUS: Write a custom SNAP reporter block called "add all" that takes two list of numbers as arguments and returns a new list that contains the sum of the corresponding values in each argument list. For example, if the arguments to "add all" are (1, 4, 6) and (2, 2, 3), the result should be (3, 6, 9). You can assume the two lists will be the same size. 24 | -------------------------------------------------------------------------------- /lab_45.md: -------------------------------------------------------------------------------- 1 | # It's Around Here Somewhere 2 | 3 | In this lab, you will implement several custom blocks performing variants of sequential search. 4 | 5 | ## You There? 6 | 7 | 1. Write your own version of the SNAP "contains" block, which takes a list and a value as arguments and reports true if the value is anywhere in the list and reports false otherwise. You should NOT use the existing "contains" block in your implementation. 8 | 9 | ## Where? 10 | 11 | 1. Write a custom block called "index of" that takes a list and a value as arguments and reports the index at which the value is found in the list, if it is there. If the value is not present anywhere in the list, report -1. So, for example, if the list is (2, 3, 5, 7, 11) and the value is 5, "index of" should report 3. If the list is (2, 3, 5, 7, 11) and the value is 4, "index of" should report -1. 12 | 13 | ## Tell Me More 14 | 15 | 1. Write a custom block called "first e-word" that takes a list as an argument and reports the first word in the list that starts with the letter 'e'. If no such word exists, report a blank (nothing). 16 | 17 | 2. BONUS: Write a custom block called "first word that starts with" that takes a list and a letter as arguments, and reports the first word in the list that starts with the given letter. If no such word exists, report a blank (nothing). 18 | -------------------------------------------------------------------------------- /lab_51.md: -------------------------------------------------------------------------------- 1 | # Lab 5.1 - Connect the Dots 2 | In this lab, you will follow sets of instructions to investigate how clones work. 3 | 4 | ## Part 1 - All Together Now 5 | 1. Each of the six students in your group should follow these instructions. Each student should then follow his or her instructions, completing each corresponding step together. (For example, everybody should complete their step ii. at the same time.) Everyone should work on the same grid. 6 | 1. Put your pen on the first dot in the bottom row of the grid below. 7 | 2. Draw a line to the dot to the right. 8 | 3. Draw a line to the dot to the left. 9 | 4. Draw a line to the dot above. 10 | 5. Draw a line to the dot above. 11 | 6. Draw a line to the dot to the right. 12 | 7. Lift your pen. 13 | ![](dots.PNG) 14 | 15 | 2. What was the result of the group following the instructions? Were there any difficulties you encountered? Does it seem like the result was intended? 16 | 17 | ## Part 2 - To Each His Own 18 | 1. Give each member of the group one of the sets of instructions below. Each student should then follow his or her instructions, completing each corresponding step together. (For example, everybody should complete their step ii. at the same time.) Everyone should work on the same grid. 19 | 1. Person #1 20 | 1. Put your pen on the first dot in the bottom row of the grid below. 21 | 2. Draw a line to the dot to the right. 22 | 3. Draw a line to the dot to the left. 23 | 4. Draw a line to the dot above. 24 | 5. Draw a line to the dot above. 25 | 6. Draw a line to the dot to the right. 26 | 7. Lift your pen. 27 | 1. Person #2 28 | 1. Put your pen on the third dot in the bottom row of the grid below. 29 | 2. Draw a line to the dot to the right. 30 | 3. Draw a line to the dot to the left. 31 | 4. Draw a line to the dot above. 32 | 5. Draw a line to the dot above. 33 | 6. Draw a line to the dot to the right. 34 | 7. Lift your pen. 35 | 1. Person #3 36 | 1. Put your pen on the fifth dot in the bottom row of the grid below. 37 | 2. Draw a line to the dot to the right. 38 | 3. Draw a line to the dot to the left. 39 | 4. Draw a line to the dot above. 40 | 5. Draw a line to the dot above. 41 | 6. Draw a line to the dot to the right. 42 | 7. Lift your pen. 43 | 1. Person #4 44 | 1. Put your pen on the seventh dot in the bottom row of the grid below. 45 | 2. Draw a line to the dot to the right. 46 | 3. Draw a line to the dot to the left. 47 | 4. Draw a line to the dot above. 48 | 5. Draw a line to the dot above. 49 | 6. Draw a line to the dot to the right. 50 | 7. Lift your pen. 51 | 1. Person #5 52 | 1. Put your pen on the ninth dot in the bottom row of the grid below. 53 | 2. Draw a line to the dot to the right. 54 | 3. Draw a line to the dot to the left. 55 | 4. Draw a line to the dot above. 56 | 5. Draw a line to the dot above. 57 | 6. Draw a line to the dot to the right. 58 | 7. Lift your pen. 59 | 1. Person #6 60 | 1. Put your pen on the eleventh dot in the bottom row of the grid below. 61 | 2. Draw a line to the dot to the right. 62 | 3. Draw a line to the dot to the left. 63 | 4. Draw a line to the dot above. 64 | 5. Draw a line to the dot above. 65 | 6. Draw a line to the dot to the right. 66 | 7. Lift your pen. 67 | ![](dots.PNG) 68 | 69 | 2. What was the result of following the instructions? Does this seem like the most efficient way to achieve this goal? What would happen if the shape needed to be changed? What problems could that cause? 70 | 71 | 3. What might be a better or more efficient way to accomplish the goal of these instructions? 72 | 73 | 74 | ## Part 3 - The Same But Different 75 | 1. Assign each member of your group a different number from 1 to 6. Each of the six students in your group should then follow these instructions. Each student should then follow his or her instructions, completing each corresponding step together. (For example, everybody should complete their step ii. at the same time.) Everyone should work on the same grid. 76 | 1. If you are person #1, put your pen on the first dot in the bottom row of the grid below. 77 | 2. If you are person #2, put your pen on the third dot in the bottom row of the grid below. 78 | 3. If you are person #3, put your pen on the fifth dot in the bottom row of the grid below. 79 | 4. If you are person #4, put your pen on the seventh dot in the bottom row of the grid below. 80 | 5. If you are person #5, put your pen on the ninth dot in the bottom row of the grid below. 81 | 6. If you are person #6, put your pen on the eleventh dot in the bottom row of the grid below. 82 | 7. Draw a line to the dot to the right. 83 | 8. Draw a line to the dot to the left. 84 | 9. Draw a line to the dot above. 85 | 10. Draw a line to the dot above. 86 | 11. Draw a line to the dot to the right. 87 | 12. Lift your pen. 88 | ![](dots.PNG) 89 | 90 | 2. Was the result of these instructions any different than in part 2? Do you think this process was more or less effective than the process from part 2? Why? -------------------------------------------------------------------------------- /lab_52.md: -------------------------------------------------------------------------------- 1 | # Lab 5.2 - Lots of Balls 2 | In this lab, you will use cloning to create many identical sprites without having to reprogram each one individually. 3 | 4 | ## Part 1 - Follow the bouncing ball 5 | 1. Create a SNAP program that contains a single sprite. When the green flag is clicked, the sprite should go to the center of the stage, pick a random direction, and start moving in the chosen direction. If the sprite hits a wall, it should bounce off and keep moving. 6 | 7 | 2. Modify the program to be controlled by the stage rather than by the sprite itself. When the spacebar is pressed, the stage should broadcast a message that triggers the sprite's movement. Pressing the spacebar again should restart the sprite's movement, including a new speed and new direction. 8 | 9 | 3. What would you need to do to add a second bouncing ball (that behaved in the same way) to the program? What about 10 balls? 100 balls? What would happen if you wanted to change the speed of all the balls in the program after you had created 100? 10 | 11 | ## Part 2 - Clones! 12 | 1. Modify your program so that, instead of a single sprite restarting each time the spacebar is pressed, a new clone of that sprite is created. You'll want to use the ![](createACloneOf.png) and ![](whenIStartAsAClone.png) blocks in place of ![](broadcast.png) and ![](whenIReceive.png). 13 | 14 | 2. What happens to the original ("master") sprite each time the spacebar is pressed? Does that seem useful? What role should the original sprite play now that we're cloning? 15 | 16 | 3. Modify the program so that the original ("master") sprite hides at the beginning of the program and each new sprite appears when it is created. 17 | 18 | 4. BONUS: Assign each clone a different value for some properties, such as speed, color, or size. Try controlling these values from the master sprite rather than having each clone choose its own. 19 | -------------------------------------------------------------------------------- /lab_53.md: -------------------------------------------------------------------------------- 1 | # Lab 5.3 - Fewer Balls 2 | In this lab, you will build on what you created in lab 5.2 to enable better management of the number of sprites in the program. 3 | 4 | ## Part 1 - Getting Out of Hand 5 | 1. Open up your SNAP program from [Lab 5.2](lab_52.md). Modify your program so that, when the 'd' key is pressed, all bouncing balls are deleted. DO NOT delete the prototype-- you should be able to create new bouncing balls after you have removed the old clones. Use the ![](deleteThisClone.png) block and a message. 6 | 7 | 2. What if you wanted to remove only a few clones? Or only specific clones? What would be needed in order to accomplish that? 8 | 9 | 10 | ## Part 2 - Better Control 11 | 1. Add a **global** variable to your program called `g_nextID` and give it a value of 1 when the green flag is clicked. 12 | 13 | 2. In your master ball sprite, create a **sprite** variable called `s_ID`. Modify your program so that each time a new clone is created, the clone's `s_ID` variable gets the value currently in `g_nextID` and `g_nextID` is incremented by 1. 14 | 15 | 3. Change your program so that when the 'd' key is pressed, the _newest_ bouncing ball gets deleted. Think about the right way to use the variables you created in the previous steps to know which sprite to delete. (_Hint: in order for this to work right, you should reuse old IDs once the clones are deleted. So, for example, if the most recently created clone was number 6, and you hit 'd', clone number 6 should be deleted. Then, if a new clone is created, it should be a new clone number 6._) Try to do this without requiring a lot of special cases in your code-- every clone should operate in the same way to determine if it should be deleted. 16 | 17 | 4. BONUS: Add code so that if the 'x' key is pressed the program asks for an ID number and deletes that numbered clone. All clones with higher numbers should be renumbered so that ID numbers remain contiguous. (For instance, if clone number 5 is deleted, then clone numbers 6, 7, and 8 should be renumbered as clone numbers 5, 6, and 7 respectively. Then, the next clone created should be a new clone number 8.) This is tricky and will require you to think very carefully about how to use the variables. -------------------------------------------------------------------------------- /lab_day_lesson.md: -------------------------------------------------------------------------------- 1 | # Standard Lab Day Lesson 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Describe difficulties they were having with the assignment on previous days 8 | - Explain the requirements of the project on which they are working 9 | - List questions they have about the current project 10 | 11 | ## Materials/Preparation 12 | 13 | - Current project specification 14 | - Examples of necessary concepts or techniques 15 | 16 | - Prior to each lab day, have a sense of students' difficulties with the current project so you will know what to address in the review portion of the lesson 17 | - Observe student progress throughout lab time and note common issues or misconceptions 18 | - Be aware of students who are more behind than most of the class 19 | - The exit ticket (see below) will help with gathering this information 20 | 21 | ## Pacing Guide 22 | 23 | | Duration | Description | 24 | | ------------- | ------------------------------------------------------- | 25 | | 5 minutes | Welcome, attendance, bell work, announcements | 26 | | 10-15 minutes | Review of trouble spots, concepts, misconceptions, etc. | 27 | | 30-35 minutes | In-class lab time | 28 | | 5 minutes | Exit ticket | 29 | 30 | ## Instructor's Notes 31 | 32 | 1. Review 33 | 34 | - Discuss and review areas in which a number of students are having trouble (or are expected to have trouble) with the current project 35 | - Using previous days exit tickets, questions from students, instructor awareness of trouble points in the project, and/or any other resources to determine what needs covering 36 | - Avoid lecturing or directly giving solutions; instead, present the problem and ask leading questions to help guide students to the solution 37 | - e.g. (from [Project 1](project_1.md): "It looks like a lot of us are having difficulty making all our sprites move at the same time that the words change. Is there something we learned about that can trigger scripts in a bunch of sprites all at once?" 38 | - If some students appear to be further along, utilize them to help explain the tricky concepts to their classmates 39 | - Use this time as an opportunity to remind students of upcoming checkpoints, recent labs or activities that may be applicable to the project, and/or how far along they should be by the end of the day 40 | 41 | 2. Lab time 42 | 43 | - Allow students to work on the current project at their own pace 44 | - Provide a mechanism for students to ask questions of course staff as needed 45 | - Simply having students raise hands often does not work well, as it can be hard to keep track of in what order hands were raised; consider a queue of some kind where students write their names when they have a question 46 | - When there are no current questions, circulate and observe progress, stepping in if students appear stuck but are not asking for help 47 | - Be sure to meerkat and not spend more than a minute or two with any single student at a time 48 | 49 | 3. Exit ticket 50 | - Before students leave, have them answer the following questions on a small piece of paper: 51 | 1. What was the last thing you accomplished on the project today? 52 | 2. What is the first thing you will work on tomorrow? 53 | 3. Do you have any questions about the project you would like answered? If so, what are they? 54 | 4. Are there any topics or concepts that would help with the project that you would like reviewed? If so, what are they? 55 | - These answers will help you plan your review time for the next lab day 56 | 57 | ## Accommodations/Differentiation 58 | 59 | - Students who are consistently ahead and finish early can be encouraged to add extra features to their project for possible extra credit. 60 | - Beware of students who claim to be ahead or finished but are actually trying to avoid work. When in doubt, ask a student to demonstrate their project. 61 | - Students who are consistently behind should get extra attention during lab time. If they continue to be behind, try to find a before- or after-school opportunity to provide extra assistance. 62 | - Students who are struggling significantly can be offered late turn-in, reduced requirements, or other "deals." **All students should submit work for ALL projects, even if it has to be simplifed or late.** 63 | -------------------------------------------------------------------------------- /lessThan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/lessThan.png -------------------------------------------------------------------------------- /lesson_01.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 0.1: The First Day of School 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Identify the class they are taking 9 | - List the high-level goals of the course 10 | - Describe classroom procedures, rules, and norms 11 | 12 | ## Materials/Preparation 13 | 14 | - Class list 15 | - [Optional] Seating chart 16 | - Bell schedule and classroom location 17 | 18 | ## Pacing Guide 19 | 20 | | Duration | Description | 21 | | ---------- | ------------------------------------------- | 22 | | 5 minutes | Welcome, attendance | 23 | | 10 minutes | Course staff introductions | 24 | | 10 minutes | Icebreakers | 25 | | 10 minutes | Course outline | 26 | | 15 minutes | Course norms, procedures, and administrivia | 27 | 28 | ## Instructor's Notes 29 | 30 | - Utilize the plan developed with your teaching team for the first day of school. 31 | - The pacing guide above is a very broad suggestion. You should adapt (or ignore) as necessary to fit your team's plan. 32 | - Suggested topics to cover: 33 | - Names and backgrounds of TEALS team members 34 | - Brief background on TEALS program (i.e. "Why are there so many adults here?") 35 | - Classroom rules, behavior expectations, grading guidelines, late work policies, etc. 36 | - Academic Integrity/Cheating policy 37 | - Introductions/Icebreakers with students 38 | - High-level learning objectives for course 39 | 40 | 41 | ## BJC Lecture Suggestions 42 | 43 | ####Good for Classroom Instruction-Previewing Suggested due to Social Media Examples. 44 | 45 | (This could be used for a Social Media Safety/Awareness lesson) 46 | * [BJC Lecture 11:Social Implications II Dr. Gerald Friedland](https://www.youtube.com/watch?v=RNN19b61oRg) 47 | - Dr. Gerald Friedland Sr. Research Scientist at International Computer Science Institute (ICSI) on Sharing Multimedia and the Impact on Online Privacy) 0:00-1:45 48 | - Introduction to Social Media: The Price of Social Media Use-Stephen Colbert 1:50-6:25 49 | - Observations on Sharing Data and Ineffective Privacy Protection 6:30-7:50 50 | - Social Cause: Collection of Data Across Sites 7:50-10:30 51 | - Multimedia in Internet is Growing 10:35-12:05 52 | - CS Problem: Higher Demand for Retrieval and Organization of Data 12:07-13:05 53 | - Manual Tagging & Geo Tagging 13:05-17:30 54 | - Issue of Tracking & Dangers of Oversharing 17:30-18:31 55 | - [Berkeley Multimedia Location Estomation Project]( http://multimedia.icsi.berkeley.edu/multimodal-location-estimation/ ) 56 | 18:31-28:14 57 | - ICSI’s Evaluation Results 19:49 58 | - YouTube Cybercasing 20:47 59 | - Privacy Implication of Internet and Data 22: 30 60 | - Person Linking Using Internet Videos 25:45-26:45 61 | - Solutions for Privacy that Don’t Work: Think Before You Post! 26:45-28:14 62 | 63 | 64 | ####Background Information for Instructors 65 | - BJC Video Suggestion: [BJC Lecture 1: Abstraction](https://www.youtube.com/watch?v=Dxw9cIbzaLk) 66 | - Basic concepts of the course: 0:00-7:00 67 | - Introduction of Piazza: 7:00-8:25 68 | - Abstraction: 11:40-15:40 69 | - Generalization: 15:50-20:00 70 | - Summary: 20:05-25:10 71 | 72 | 73 | * BJC Video Suggestion: [BJC Lecture 2: 3D Graphics](https://www.youtube.com/watch?v=q2UMQaoW30U) 74 | - SOPA & PIPA: 0:00-1:00 75 | - 3D Computer Graphics Explanation: 1:00-5:24 76 | - 3D Graphics steps outlined: 5:25-5:50 77 | - Modelling (Useful for Lab 2.5): 5:50-11:40 78 | - Animation (Uncanny Valley Explanation): 11:40-16:55 79 | - Procedural Based Motion (Lab 1.1): 16:56-20:00 80 | - Genetic Algorithms: 20:05-25:25 81 | - Lighting and Shading: 25:25-27:10 82 | - Rendering: 27:10- 30:55 83 | - Global Illumination: 30:55-34:21 84 | 85 | 86 | 87 | ## Accommodation/Differentiation 88 | 89 | - In some school's the first day of schools is an altered or shortened schedule. Find this out ahead of time and plan for however much time you have available. 90 | - If necessary, split these topics across multiple days. 91 | -------------------------------------------------------------------------------- /lesson_04.md: -------------------------------------------------------------------------------- 1 | # Lesson 0.4: SNAP Self-Portrait 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Create a simple "program" in SNAP to describe themselves 6 | 7 | ## Materials/Preparation 8 | * [Lab 0.4 handout](lab_04.md) (Getting to Know You) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%200/Lab%200.4.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%200/Lab%200.4.pdf)) 9 | 10 | 11 | ## Pacing Guide 12 | 13 | | Duration | Description | 14 | | ---------- | --------------------------------------------- | 15 | | 5 minutes | Welcome, attendance, bell work, announcements | 16 | | 5 minutes | Introduce Activity | 17 | | 35 minutes | Getting to Know You lab | 18 | | 10 minutes | Debrief and wrap-up | 19 | 20 | 21 | ## Instructor's Notes 22 | 23 | 1. Introduce Activity 24 | * Tell students that today they will explore SNAP and use it to create a "self-portrait" program. 25 | * Emphasize that the goal of today's lesson is **_not_** for students to develop a deep understanding of any of the features in SNAP. Later lessons will teach them everything they need to know. For now, they should just explore, figure out what they can, and put it to use however they see fit. 26 | * Spend just a couple minutes demonstrating how to open SNAP, create sprites and scripts, and run programs. 27 | * **DO NOT** go into detail-- the specifics of SNAP will be covered in much more depth in unit 1. The goal here is simply to give students enough of a starting point to be able to explore and try things out on their own. 28 | * Show students the [lab handout](lab_04.md) and read through the instructions. 29 | * Point out the places to write answers to the written questions in parts 1.2 and 1.3. 30 | * Draw special attention to the list of requirements for the self-portrait program in part 1.4. 31 | * This is an excellent opportunity to tell students that all labs in this course will look similar to this, and that they should get used to reading instructions carefully. 32 | 2. Activity 33 | * Instruct students to complete the ["Getting to Know You"](lab_04.md) lab. 34 | * For part 1.3, you can either assign pairs or allow students to pair up on their own. If students are allowed to choose their own partners, take care to ensure that no one is excluded. 35 | * If the class has an odd number, form a single group of three. 36 | 3. Debrief 37 | * Ask each student to identify and describe _one_ feature they discovered in SNAP. Keep a running list on the whiteboard or projector. 38 | * If the students build a pretty comprehensive list, you can use this as a chance to go over a brief roadmap for the course. 39 | * Ask students what they enjoyed about working with SNAP and what they disliked. 40 | 41 | ## BJC Lecture Suggestions 42 | ####Good for Classroom Instruction 43 | 44 | 45 | 46 | * BJC Video Suggestion: [BJC Lecture 4: Functions ](http://www.youtube.com/watch?v=_uKCBmQEf5w&t=18m15s) 47 | - [Types of Blocks]( http://www.youtube.com/watch?v=_uKCBmQEf5w&t=18m15s) 18:15-19:45 48 | 49 | ## Accommodation/Differentiation 50 | * Allow students to use whatever resources they need, including instructors, peers, and web searches if necessary, to create their programs. The goal of this lesson is exploration and exposure, not mastery. 51 | * For students that are hesitant or unwilling to engage, point out some simple, useful features (like basic drawing and the ![](say.png) block) to get them started. Remind them that complexity or "coolness" are not important for this lab. 52 | * If you wish, you can add a second day to this lesson for students to share out their programs. Work with your classroom teacher and/or school IT staff to determine the best way for students to be able to present. 53 | * One simple option is to have all students share their projects with you, and then show each one in turn on the teacher computer/projector. 54 | * Have a plan for collecting or accumulating the students' programs, which you can then use to get to know your class! 55 | -------------------------------------------------------------------------------- /lesson_12.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 1.2: Building Blocks 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Name the categories of blocks in SNAP and describe what the blocks in each category do 9 | - Describe the function of several common SNAP blocks (see [lab](lab_12.md) for specific blocks) 10 | - Be able to use common blocks to build simple SNAP programs (see [lab](lab_12.md) for specific blocks) 11 | 12 | ## Materials/Preparation 13 | 14 | - [Lab 1.2](lab_12.md) handout (SNAP Scavenger Hunt) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20Word/Lab%201.2%20SNAP%20Scavenger%20Hunt.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20PDF/Lab%201.2%20SNAP%20Scavenger%20Hunt.pdf)) 15 | - Read through the handout so that you are familiar with the requirements and can assist students 16 | 17 | ## Pacing Guide 18 | 19 | | Duration | Description | 20 | | ---------- | --------------------------------------------- | 21 | | 5 minutes | Welcome, attendance, bell work, announcements | 22 | | 10 minutes | Introductory discussion | 23 | | 25 minutes | "SNAP Scavenger Hunt" Lab activity | 24 | | 15 minutes | Debrief and wrap-up | 25 | 26 | ## Instructor's Notes 27 | 28 | 1. Introductory discussion 29 | 30 | - Review the basics of SNAP from the previous lesson 31 | - Ensure that students can: 32 | - Define "block" and "script" 33 | - Describe how to build a script (snapping blocks together) 34 | - Explain how scripts are executed (one block at a time in order) 35 | - Introduce the concept of block categories 36 | - Ask students to consider why categories are helpful as opposed to having a simple list of blocks 37 | 38 | 2. Activity 39 | 40 | - Individually or in pairs, have students work through the ["SNAP Scavenger Hunt"](lab_12.md) activity 41 | - Students should turn in answers to all questions and SNAP programs for the final problems 42 | 43 | 3. Debrief 44 | - Go through each question or prompt in parts 1 and 2 and ask students to share their answer 45 | - Cold calling works well for this lab due to the large number of questions 46 | - Point out the color coding for each category 47 | - Emphasize important details in some of the blocks listed in part 2, such as: 48 | - the ![](think.png) block will leave the bubble on the stage until something else is thought 49 | - the ![](gotox-y.png) and ![](glide.png) blocks require explicit x- and y-coordinates 50 | - Solicit a few student responses for each category in part 2.2 before commenting yourself 51 | - Try to guide the students to discuss with each other and settle on a description for each category with minimal instructor intervention 52 | - Discuss one or two student solutions to each of the SNAP programming problems 53 | - Either solicit volunteers or cold call 54 | - Point out differences between student solutions and call attention to the fact that there is more than one way to solve a problem 55 | 56 | ## Accommodations/Differentiation 57 | 58 | - Colorblind students may not be able to identify the block colors, but can still recognize the organization of categories. Be sensitive to this, but no modifications are likely required. 59 | - Students that are struggling with the lab can be paired up and/or receive individual instructor attention to help them through the activity. 60 | - The bonus assignment (3.4) should be used for students who finish quickly, and can be a setup for the [Animation Project](project_1.md). 61 | -------------------------------------------------------------------------------- /lesson_13.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 1.3: Drawing Shapes 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Construct simple algorithms to draw shapes 9 | - Convert algorithms into SNAP programs 10 | 11 | ## Materials/Preparation 12 | 13 | - [Lab 1.3 handout](lab_13.md) (Squares and Triangles and Stars, Oh My!) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20Word/Lab%201.3%20Squares%20Triangles.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20PDF/Lab%201.3%20Squares%20Triangles.pdf)) 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 10 minutes | Review and introduce activity | 21 | | 25 minutes | Shape drawing activity | 22 | | 15 minutes | Debrief and wrap-up | 23 | 24 | ## Instructor's Notes 25 | 26 | 1. Review 27 | - Review the categories of blocks and what each is for. 28 | - Put particular emphasis on Motion and Drawing, as those will be used for this assignment 29 | - Remind students about the iterative process of programming 30 | - Students may get frustrated throughout this activity; remind them that requiring multiple attempts to find the right solution is normal. 31 | 2. Activity 32 | - Students should complete the ["Triangles, Squares, and Stars, Oh My!"](lab_13.md) activity individually. 33 | - Point out that the shapes in part 2.1 are not necessarily listed from easiest to hardest, and that the scripts need not be written in the given order. 34 | - When students finish, have them turn in their project using whatever procedures you have set up. 35 | 3. Debrief 36 | - Have students switch seats with a nearby classmate and review each other's work 37 | - If one in a pair student was able to complete a program and the other was not, have the student who was successful walk his/her partner through 38 | - If neither student in a pair was able to complete a program, encourage them to work together to figure out what they were missing 39 | - Make sure course staff is available to help pairs who cannot figure out a given problem 40 | - Ask students to share what they learned from looking at their partner's programs 41 | - Point out the fact that there is more than one way to solve a problem and two programs that are both correct might not look the same 42 | 43 | ## Accommodations/Differentiation 44 | 45 | - Advanced students can attempt the five-pointed star. If students finish that shape, encourage them to try more advanced shapes. 46 | - Examples: Kite, smiley face, student's initials 47 | - Struggling students can either be paired or allowed to not complete certain shapes. 48 | - Students who have not yet taken geometry may have difficulty determining the correct angles. Point out to them that geometric understanding is not necessary—the angles can be determined using trial and error. 49 | - If students need more scaffolding, they can be pointed to an online resource such as 50 | - If most students are not equipped to figure out the angles on their own, provide diagrams like the one of a square in part 1.1 to assist. 51 | -------------------------------------------------------------------------------- /lesson_14.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 1.4: Animation 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Animate SNAP sprites using costume changes and movement 9 | - Trigger action in other sprites using broadcasts 10 | 11 | ## Materials/Preparation 12 | 13 | - [Lab 1.4 handout](lab_14.md) (Sprites in Action) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20Word/Lab%201.4%20Sprites%20in%20Action.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%201%20PDF/Lab%201.4%20Sprites%20in%20Action.pdf)) 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 10 minutes | Lecture and introduce activity | 21 | | 30 minutes | Animation activity | 22 | | 10 minutes | Debrief and wrap-up | 23 | 24 | ## Instructor's Notes 25 | 26 | 1. Lecture 27 | - _Note: The [Lesson 1.4](http://snap.berkeley.edu/snapsource/snap.html#present:Username=brettwo&ProjectName=Lesson%201.4) project has examples of all the concepts covered in this lesson._ 28 | 1. Introduce students to the "Costumes" tab and show them how to import costumes to a sprite. 29 | - Point out that, while a sprite's costumes can be anything, most often the different costumes of a single sprite will be somehow related. 30 | 2. Demonstrate how to use the "next costume" and "switch to costume" blocks to change the appearance of a sprite. 31 | - Emphasize that costumes will cycle and that switching to the costume a sprite is already "wearing" is OK. 32 | - Combine costume switching with movement and other actions to show that blocks of different categories can be combined in the same script. 33 | 2. Introduce the "broadcast" and "when I receive" blocks and show how they can be used to coordinate action between sprites 34 | - Point out that all sprites "hear" a broadcast and any sprite with a corresponding "when I receive" will react. 35 | - Discuss the difference between "broadcast" and "broadcast and wait" and ask students to come up with ideas for when each would be useful. 36 | 3. It's worthwhile to introduce the rotate buttons located at the top left of the SNAP interface. These buttons allow you to snap (puns!) your rotation, allowing you to lock rotation, allow free rotation, or allow only left/right rotation. 37 | 38 | ![rotate buttons](rotateButton.PNG) 39 | 40 | 41 | 2. Activity 42 | - Students should complete the ["Sprites in Action"](lab_14.md) lab individually. 43 | - Ensure that students create two different sprites for parts 1 and 2 so they do not get the costumes mixed up. 44 | - Students can submit the assignment using your turn-in procedures or you can check off the work as students complete it. 45 | 3. Debrief 46 | - Ask a student to show their solution to each part. Call on a different student (either a volunteer or via cold calling) for part 1 and part 2. 47 | - Note any places in which there may be multiple possible approaches. Ask for volunteers to describe differences in their code. 48 | 49 | ## Accommodations/Differentiation 50 | 51 | - Students that finish quickly can be encouraged to add more detail to their animations, such as sounds, "say" blocks, and/or more costumes. 52 | - Especially advanced students can be encouraged to create their own costumes for a new animation that does not use any built-in sprites. 53 | - With struggling students, re-emphasize the fact that each sprite can have different costumes and that changing costumes is very much like changing position by moving. Get students to be able to change costumes on a key press before moving on to the animation aspect. 54 | -------------------------------------------------------------------------------- /lesson_22.md: -------------------------------------------------------------------------------- 1 | # Lesson 2.2: Nested Loops 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Use nested loops to solve programming problems 8 | 9 | ## Materials/Preparation 10 | 11 | - Lab 2.2 handout - [Another Brick in the Wall](lab_22.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20Word/Lab%202.2%20Another%20Brick%20in%20the%20Wall.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20PDF/Lab%202.2%20Another Brick%20in%20the%20Wall.pdf)) 12 | 13 | ## Pacing Guide 14 | 15 | | Duration | Description | 16 | | ---------- | --------------------------------------------- | 17 | | 5 minutes | Welcome, attendance, bell work, announcements | 18 | | 15 minutes | Review, lecture, and examples | 19 | | 25 minutes | Activity - Another Brick in the Wall | 20 | | 10 minutes | Debrief and wrap-up | 21 | 22 | ## Instructor's Notes 23 | 24 | 1. Review 25 | - Ask to students to restate the definition of "loop" 26 | - _A type of block that causes other code to run multiple times in succession_ 27 | - Ask students to explain why loops are useful in programming 28 | - To reduce code redundancy and increase readability when dealing with repetitive tasks 29 | - Solicit examples of problems that can be solved with loops 30 | - Drawing polygons, repeating an action, etc. 31 | - Ask students how their scripts to draw shapes improved when they introduced loops 32 | - Code became shorter and more readable 33 | - Small changes, such as altering the size of the shape, became simpler 34 | 35 | 2. Lecture 36 | 1. Ask students to consider the problem of drawing two squares next to each other 37 | 38 | - Work through writing a script to do this. The likely result will duplicate the code to draw a single square: 39 | 40 | ![]() 41 | 42 | - Remind students to remember what they previously learned and use loops 43 | - Once the script is complete, ask students if there are ways they could improve the code 44 | 45 | 2. Discuss what would happen if you needed to draw 10 squares, or 100, or an unknown number. 46 | - If students seem capable, you can allude to user input for the unknown number example, but do not get into details at this point 47 | - Ask if loops can somehow be applied to reduce redundancy even further in the script to draw two squares 48 | 3. Introduce the concept of nested loops 49 | - Define "nested loop" - _a loop used inside the body of another loop_ 50 | - Point out that there is nothing particularly special happening here-- the body of a loop can contain any code, including another loop 51 | - Emphasize that the inner loop will run all its iterations _each time_ the outer loop runs. 52 | 4. Walk through rewriting the script to draw multiple squares to use nested loops: 53 | 54 | ![]() 55 | 56 | * Ask how many total times the sprite will move 50 steps 57 | * The sprite will move 50 steps 8 times (4 * 2) 58 | * Show that the number of squares drawn can be easily changed by simply changing the number of times the outer loop iterates 59 | 60 | 3. Activity 61 | 62 | - Direct students to complete the ["Another Brick in the Wall"](lab_22.md) activity individually or in pairs 63 | - Remind students to continue using the principles learned with basic loops 64 | - Encourage students to write scripts that are as short and succinct as possible while still being functional and readable 65 | 66 | 4. Debrief 67 | - Show a student's solution 68 | - Either request a volunteer or cold call 69 | - Point out uses of nested loops 70 | - Ask students to describe how loops, specifically nested loops, made the assignment easier 71 | - Each brick, or at least each row, would have needed to be coded separately creating much longer scripts 72 | - Ask students to think about what code would need to change to alter the size of each brick or the size of the wall and how that was made easier with loops 73 | - Size of wall: number of iterations in one or both loops 74 | - Size of brick: one or both move blocks **and** number of iterations in one or both loops 75 | - Without loops, the change would have been needed in many different places 76 | 77 | ## Accommodation/Differentiation 78 | 79 | - Not all students will recognize all the possible places to use nested loops in the final program. Encourage students to find as many places to use a nested loop as possible, but allow struggling students to focus on just one or two uses. 80 | - Advanced students can be encouraged to change the size of the bricks, which will require not only altering the number of steps moved but also the number if iterations in the loops 81 | 82 | [Lab 2.2 Solution](http://snap.berkeley.edu/snapsource/snap.html#present:Username=kenneychan&ProjectName=Lab%202.2) 83 | -------------------------------------------------------------------------------- /lesson_24.md: -------------------------------------------------------------------------------- 1 | # Lesson 2.4: Variables <---- Formerly 3.1 ----> 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Use variables to track values throughout a program 8 | 9 | ## Materials/Preparation 10 | 11 | - Lab 2.4 handout - [Guessing Game](lab_24.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20Word/Lab%202.4%20Guessing%20Game.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20PDF/Lab%202.4%20Guessing%20Game.pdf)) 12 | 13 | ## Pacing Guide 14 | 15 | | Duration | Description | 16 | | ---------- | --------------------------------------------- | 17 | | 5 minutes | Welcome, attendance, bell work, announcements | 18 | | 15 minutes | Lecture and introduce activity | 19 | | 25 minutes | Activity - Guessing Game | 20 | | 10 minutes | Debrief and wrap-up | 21 | 22 | ## Instructor's Notes 23 | 24 | 1. Lecture 25 | 26 | 1. Review user input, specifically the ![](answer.png) block 27 | - Ask students to speculate about how the ![](answer.png) block works 28 | - Students should recognize that the block must be storing a value somehow and remembering it for later 29 | - Ask students whether that type of functionality might be useful in other cases 30 | 2. Introduce variables 31 | - Define and explain the concept of a variable 32 | - _a "place" to store a value for retrieval and use later_ 33 | - Demonstrate creating, assigning, and accessing a variable in SNAP 34 | - Ignore global vs. this sprite only for now 35 | - Point out that a variable can only hold one value at a time 36 | - When a new value is assigned, the old value is lost and cannot be recovered 37 | - Emphasize the importance of descriptive, readable names for variables 38 | - Show that variables are independent 39 | - One variable's value can be assigned to another, as in ![](setVar1ToVar2.png), but changing the value of `var2` later will not update the value of `var1` 40 | 41 | 2. Activity 42 | 43 | - Briefly demonstrate the ![](random.png) block, which will be used in the lab 44 | - Direct students to complete [Guessing Game](lab_31.md) individually or in pairs 45 | 46 | 3. Debrief 47 | 48 | - Discuss and demonstrate one or more students' submissions 49 | - Ask students for commentary on usage and naming of variables throughout program 50 | 51 | ## Accommodation/Differentiation 52 | 53 | - Advanced students can be encouraged to implement statistics (best score, average guesses/game, number of time each secret number chosen, etc.) 54 | - Struggling students can be given code that completes part 1.1, and possibly also part 1.2, to get them started 55 | - Students who are particularly overwhelmed should focus only on parts 1.2 and 2.2 56 | -------------------------------------------------------------------------------- /lesson_25.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 2.5: Boole in the House 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Define and identify Boolean expressions and operators 9 | - Evaluate Boolean expressions 10 | - Utilize Boolean operators (and/or/not) to create compound conditions 11 | 12 | ## Materials/Preparation 13 | 14 | - [Lab 2.5 handout (Triangles of All Kinds)](lab_25.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20Word/Lab%202.5%20Triangles%20of%20All%20Kinds.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20PDF/Lab%202.5%20Triangles%20of%20All%20Kinds.pdf)) 15 | 16 | ## Pacing Guide 17 | 18 | | Duration | Description | 19 | | ---------- | --------------------------------------------- | 20 | | 5 minutes | Welcome, attendance, bell work, announcements | 21 | | 20 minutes | Review and lecture | 22 | | 20 minutes | Triangles activity | 23 | | 10 minutes | Debrief and wrap-up | 24 | 25 | ## Instructor's Notes 26 | 27 | 1. Review 28 | - Remind students about conditional statements, and ask what the blocks that can go in the holes in if blocks have in common 29 | - Blocks are "pointy" and all are "yes/no" or "true/false" questions 30 | 2. Lecture 31 | - Introduce and define "Boolean expressions" as expressions that evaluate to true or false 32 | - If desired, explain that the term "Boolean" is derived from [George Boole](https://en.wikipedia.org/wiki/George_Boole) 33 | - In SNAP, all Boolean expressions are pointy six-sided blocks 34 | - Present the three Boolean operators: and, or and not 35 | - Define the operators and describe when each will return true 36 | - Show the truth tables for each operator and explain how to read them 37 | - Describe that truth tables are read much like multiplication tables: find the two operands on the two edges, then find where the row and column meet to see the result 38 | - Truth tables are simply one way of expressing how the Boolean operators work; if students are struggling, other depictions (such as an exhaustive list of all possible results) can be substituted 39 | - Emphasize that since Boolean operators are themselves Boolean expressions, they can be nested 40 | - Practice evaluating Boolean expressions, starting simple and moving to more complex nested operations 41 | - Start with simple expressions: e.g. `5 < 7 AND 4 > 2` 42 | - Introduce variables: e.g. `x = 7; x < 5 OR x > 10` 43 | - Nest operations: e.g. `(x = 4; y = -3; x == y OR (x > 0 AND y < 0))` 44 | - Discuss short-circuiting in evaluation of Boolean expressions 45 | - Discuss situations in which the Boolean operators might be needed 46 | - The lack of <= and >= operators in SNAP makes for a great example 47 | 3. Activity 48 | - Students should complete the ["Triangles of All Kinds"](lab_25.md) activity individually or in pairs 49 | - A number of geometric concepts (Triangle Inequality Theorem, Pythagorean Theorem, etc.) are used in this lab, but students need not have a deep understanding of them. The necessary points are explained in the lab. 50 | - Encourage students to think about whether an "and" or an "or" is appropriate in each case. Draw out truth tables if necessary. 51 | 4. Debrief 52 | - Walk through a student's response 53 | - Point out uses of Boolean operators 54 | - Discuss how nested or chained if blocks could potentially be used to obtain the same behavior, but would result in longer, less-readable code 55 | 56 | ## BJC Lecture Suggestions 57 | ####Good for Classroom Instruction 58 | * BJC Video Suggestion: [BJC Lecture 2: 3D Graphics](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=5m50s) 59 | - [Modelling](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=5m50s) 5:50-10:57 60 | 61 | ## Accommodations/Differentiation 62 | 63 | - Students that have not taken Geometry made be intimidated by some of the concepts in the lab. Deep understanding of the theorems is not necessary; encourage the students to simply focus on the equations and inequalities presented. 64 | - If the students continue to struggle, help them build the necessary expressions, but encourage them to assemble them into the full condition on their own. 65 | - Advanced students, especially those who have taken higher levels of math, can be encouraged to add additional functionality, such as using [Heron's formula](https://en.wikipedia.org/wiki/Heron%27s_formula) to calculate the triangles area or using trigonometry to attempt to draw the triangle. 66 | - Drawing the triangle is very challenging. 67 | -------------------------------------------------------------------------------- /lesson_26.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 2.6: Combining Variables 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Combine loops with conditionals to create models with repeated but conditional behavior 9 | 10 | ## Materials/Preparation 11 | 12 | - [Lab 2.6 handout (What Goes Up...)](lab_26.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20Word/Lab%202.6%20What%20Goes%20Up.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%202%20PDF/Lab%202.6%20What%20Goes%20Up.pdf)) 13 | 14 | ## Pacing Guide 15 | 16 | | Duration | Description | 17 | | ---------- | --------------------------------------------- | 18 | | 5 minutes | Welcome, attendance, bell work, announcements | 19 | | 10 minutes | Review, lecture and introduce activity | 20 | | 30 minutes | Gravity activity | 21 | | 10 minutes | Review and wrap-up | 22 | 23 | ## Instructor's Notes 24 | 25 | 1. Review and lecture 26 | 1. Review loops and conditionals 27 | - Ask students what loops do, when they are useful, and what loops exist in SNAP 28 | - loops cause code to execute multiple times 29 | - loops can help reduce redundancy and increase readability 30 | - SNAP contains three loops: repeat, forever, and repeat until 31 | - Ask students what conditionals are for and when they are useful 32 | - conditionals are used to execute a block of code only under certain circumstances 33 | - Encourage discussion about previous activities 34 | - Fill in understanding gaps when necessary 35 | 2. Demonstrate combining loops and conditionals 36 | - Present ![]() and ![](foreverIf.png) 37 | - Ask students to suggest when these constructs might be useful 38 | - "repeat until" is useful when a loop needs to run not for a set number of iterations, but until some situation occurs 39 | - "forever if" is useful when code should execute _any time_ a condition is true, for the duration of the program 40 | - Point out that the condition in "repeat until" is a termination condition, while in "forever-if" it is a continuation condition 41 | 3. Introduce the concept of modeling 42 | - _modeling: building a system to simulate the behavior of a real-life phenomenon by simplifying or ignoring certain details_ 43 | - Ask students to suggest systems or concepts that might need to be modeled 44 | - Discuss important considerations when designing and implementing a model 45 | - Lead students to realize that most sacrifice some amount of accuracy or realism for simplicity 46 | 2. Activity 47 | - Students should complete "What Goes Up..." lab individually 48 | - Mention that the code written in this lab will be helpful for the Platform Game project 49 | 3. Debrief 50 | 51 | ## BJC Lecture Suggestions 52 | ####Good for Classroom Instruction 53 | 54 | 55 | * [ BJC Lecture 3: Video Games](https://www.youtube.com/watch?v=hdSFuhyGTIg) 56 | - [History of Video Games Overview] (http://www.youtube.com/watch?v=hdSFuhyGTIg&t=2m30s) (Platform Game Prep) 2:30-7:55 57 | - [Casual Video Game World ](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=8m0s)(light weight) 8:00-10:40 58 | - [Core Video Game](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=10m45s) (heavy weight) 10:45-13:05 59 | - [Motion Capture ](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=15m25s)(Hero Movement for Platform Game Lab 2.6) 15:25-17:30 60 | - Artificial Intelligence (Enemy Logic for Lab 2.6) 17:30-19:40 61 | - [Video Games w/purpose](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=19m40s) (social benefits) 19:40-24:36 62 | - [Negative Aspects of Video Games ](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=19m40s)(RSI, addition, violence) 24:40-28:00 63 | - [Glenn Sugden-Game Developer ](http://www.youtube.com/watch?v=hdSFuhyGTIg&t=28m03s)(History of VG Development & Industry) 28:03-40:53 *Good for Classroom Instruction 64 | 65 | ####Background Information for Instructors 66 | 67 | 68 | * [ BJC Lecture 3: Video Games](https://www.youtube.com/watch?v=hdSFuhyGTIg) 69 | - Demystification Lecture-Novel Interaction techniques(emotive systems) 00:00-2:30 70 | 71 | 72 | ## Accommodations/Differentiation 73 | 74 | - Take care to ensure that all students have functional code by the end of the lab to avoid putting some students at a disadvantage starting the project 75 | - If many students struggle, consider releasing your own solution after the lab has been completed in class 76 | - Utilize TAs and advanced students to assist struggling students—it is vital that all students complete this lab in advance of starting the project 77 | - Advanced students can consider increasing the realism of their gravity model by adding acceleration and/or beginning to implement jumping 78 | -------------------------------------------------------------------------------- /lesson_32.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 3.2: Procedures 3 | 4 | ## Student Objectives 5 | 6 | Students will be able to... 7 | 8 | - Build custom command blocks in SNAP 9 | - Utilize detail removal and generalization to construct blocks that practice abstraction 10 | 11 | 12 | ## Materials/Preparation 13 | 14 | - Lab 3.2 handout - [Drawing Shapes Again](lab_32.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20Word/Lab%203.2%20Drawing%20Shapes%20Again.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20PDF/Lab%203.2%20Drawing%20Shapes%20Again.pdf)) 15 | 16 | 17 | ## Pacing Guide 18 | 19 | | Duration | Description | 20 | | ---------- | ----------------------------------------------- | 21 | | 5 minutes | Welcome, attendance, bell work, announcements | 22 | | 10 minutes | Lecture, demo, and introduce activity | 23 | | 20 minutes | Drawing Shapes activity | 24 | | 15 minutes | Review and wrap-up | 25 | 26 | ## Instructor's Notes 27 | 28 | 29 | 1. Lecture and Demonstration 30 | - Review with students the concepts of abstraction, generalization, and detail removal 31 | - Ask students to provide definitions and examples of each 32 | - Discuss when abstraction can be used to help simplify code 33 | - Guide students to realization that much code is used in many similar circumstances and shouldn’t be rewritten 34 | - Emphasize potential for errors when changes are made in addition to inconvenience when code is redundant 35 | - Demonstrate constructing a custom command block 36 | - Use a simple example, such as jumping (from the platform game) 37 | - If needed, use part 2.1 (drawing a square) as a further example 38 | 2. Activity 39 | - Students should complete the “Drawing Shapes (Again)” activity individually or in pairs 40 | - Work with students to be certain that they are using custom blocks and variables as described by the activity 41 | - Point out places where code can be abstracted and generalized 42 | - Emphasize conciseness and clarity in code 43 | 3. Review 44 | - Discuss one or two student submissions 45 | - Point out differences between different students’ solutions 46 | - Point out missed opportunities for abstraction (if any) 47 | - Discuss how this custom block can be useful 48 | 49 | ##BJC Lecture Suggestion 50 | ####Good for Classroom Instruction 51 | * [BJC Video Suggestion: BJC Lecture 4: Functions ](https://www.youtube.com/watch?v=_uKCBmQEf5w) 52 | - [MIT Scratch --> BYOB Snap](http://www.youtube.com/watch?v=_uKCBmQEf5w&t=10m0s) (Development of SNAP, Demo) 10:00-11:30 53 | - [BYOB-Custom Blocks ](http://www.youtube.com/watch?v=_uKCBmQEf5w&t=10m0s) (Explains functions with examples) 11:30-14:50 54 | 55 | 56 | ## Accommodation/Differentiation 57 | - In addition to attempting the bonus in the lab, advanced students can be encouraged to write a new custom block that draws a specified number of the given shape (for example, 2 squares or 5 hexagons). The number of shapes should be taken as user input. 58 | - Struggling students can be given solution code for all of section 1. Work with these students to answer the questions in part 1.5 so that they are prepared to attempt the custom block authoring. 59 | 60 | -------------------------------------------------------------------------------- /lesson_33.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 3.3: Customization I 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Build custom SNAP blocks that take arguments 9 | 10 | ## Materials/Preparation 11 | 12 | - [Lab 3.3 handout](lab_33.md) (Let Me Check My Calendar) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20Word/Lab%203.3%20Let%20Me%20Check%20My%20Calendar.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20PDF/Lab%203.3%20Let%20Me%20Check%20My%20Calendar.pdf)) 13 | 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 15 minutes | Lecture and introduce activity | 21 | | 20 minutes | Custom block argument activity | 22 | | 15 minutes | Debrief and wrap-up | 23 | 24 | ## Instructor's Notes 25 | 26 | 1. Lecture 27 | 1. Introduce block arguments 28 | - Ask students to speculate on risks of relying on variables instead of arguments 29 | - Variables could be changed by code other than the custom block, variable names could be changed causing errors, etc. 30 | - Emphasize importance of custom blocks being self-contained 31 | - Custom blocks should continue to function correctly independent of any other changes in the program 32 | - Custom blocks should work correctly anywhere in the program and not require specific setup or cleanup 33 | - Point out how frustrating code would be if blocks like ![](move.png) required setting a variable with a specific name to work 34 | 2. Demonstrate declaration and usage of arguments 35 | - Point out that arguments are very similar to script variables, except their values come outside the block 36 | - Explain argument types 37 | - Only discuss text, numbers, and Booleans 38 | - Other types can be mentioned, but won't be used in the course 39 | - Ask students to describe why restricting types is important 40 | - Point out that arguments are passed by value 41 | - Specifically, changing the value of an argument inside a custom block will typically NOT change the value at the call site 42 | - [Arguments example](http://snap.berkeley.edu/snapsource/snap.html#present:Username=brettwo&ProjectName=Lesson%203.3) 43 | - Basic argument in pen category 44 | - Pass by value example in "Variables" category 45 | 2. Activity 46 | - Students should complete the ["Let Me Check My Calendar"](lab_33.md) activity individually or in pairs 47 | - This lab consists of a series of independent custom blocks. The blocks need not necessarily be completed in the order given, but are roughly in order of difficulty. 48 | - The bonus (part 2.4) requires implementing a fairly complex formula. 49 | 3. Debrief 50 | - Ask a different student to provide their solution to each part. 51 | - If time allows, discuss multiple solutions to each part. 52 | - Emphasize differences and encourage discussion about advantages and disadvantages. 53 | - Point out corner cases and cases where typed arguments are particularly helpful. 54 | - For example, avoiding try to find out whether "bubblegum" is a leap year 55 | 56 | ## Accommodations/Differentiation 57 | 58 | - Part 2.4 is a fairly complex formula and should be a challenge for advanced students. 59 | - Struggling students should focus on section 1. The problems in section 2 represent more complex algorithms, but not necessarily any more difficult usage of arguments. 60 | 61 | -------------------------------------------------------------------------------- /lesson_34.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 3.4: Customization II 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Build custom reporter and predicate blocks in SNAP 9 | 10 | ## Materials/Preparation 11 | 12 | - [Lab 3.4 handout](lab_34.md) (If My Calculations Are Correct...) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20Word/Lab%203.4%20If%20My%20Calculations%20Are%20Correct.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%203%20PDF/Lab%203.4%20If%20My%20Calculations%20Are%20Correct.pdf)) 13 | 14 | ## Pacing Guide 15 | 16 | | Duration | Description | 17 | | ---------- | --------------------------------------------- | 18 | | 5 minutes | Welcome, attendance, bell work, announcements | 19 | | 10 minutes | Lecture and introduce activity | 20 | | 25 minutes | Custom reporter activity | 21 | | 15 minutes | Debrief and wrap-up | 22 | 23 | ## Instructor's Notes 24 | 25 | 1. Lecture 26 | 1. Introduce reporter blocks 27 | - Ask students to find blocks with the reporter shape (round) and speculate as to what they do 28 | - Point out familiar examples, such as ![](xposition.png), ![](answer.png), ![](pickrandom.png), etc. 29 | - Explain the concept of reporting (returning) a value, and how reporter blocks are used to provide values to commands 30 | - Emphasize that reporters do not (and should not) perform any action—they are used to compute values which are in turn used by commands 31 | 2. Introduce predicate blocks as a special case of reporter blocks 32 | - Emphasize that predicates must return true or false 33 | - Be aware, but don't necessarily tell students, that SNAP does not enforce this 34 | - Point out examples, such as ![](touching.png), ![](lessThan.png), ![](and.png) 35 | - Ask students why it might be useful to differentiate predicates from other reporters 36 | - Only predicates can be used in a conditional 37 | 2. Activity 38 | - Students should complete the ["If My Calculations Are Correct..."](lab_34.md) activity individually. 39 | - This lab consists of a series of independent custom blocks. The blocks need not necessarily be completed in the order given. 40 | - Work with students to ensure they are testing their blocks properly and reporting correct values. 41 | - Part 2.2 is challenging and requires traversing a String. 42 | 3. Debrief 43 | - Ask a different student to provide their solution to each part. If time permits, go over multiple students' work for each part. 44 | - Point out differences and discuss advantages and disadvantages to different approaches. 45 | - Emphasize that custom blocks do not have to be long and complicated to be useful. 46 | 47 | ## Accommodations/Differentiation 48 | 49 | - Struggling students should focus on just the first 2 or 3 parts of the lab. Even if they cannot move on to the more difficult problems, getting used to defining custom reporters is helpful and important. 50 | - Advanced students who finish quickly can be utilized to assist other students. 51 | - Students who struggle in math may not be familiar with the distance formula used in part 2.1. Help students to translate the math into SNAP code, but understanding the formula and its applications is not necessary for the activity. 52 | - If most students are not equipped to handle this math, a simpler computation, such as area of a triangle or average of three numbers, can be substituted. 53 | -------------------------------------------------------------------------------- /lesson_41.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.1: Intro to Lists 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Explain the concept of a "list" in a programming context 8 | - Identify scenarios in which lists are useful 9 | 10 | ## Materials/Preparation 11 | 12 | - Paper/writing implements for each group of students 13 | - Large poster paper and markers will allow for display of the algorithms, but standard paper will work fine 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 10 minutes | Introductory discussion | 21 | | 10 minutes | Students write Solar System algorithm | 22 | | 10 minutes | Debrief | 23 | | 10 minutes | Translate algorithms into SNAP pseudocode | 24 | | 10 minutes | Debrief and wrap-up | 25 | 26 | ## Instructor's Notes 27 | 28 | - Introductory discussion 29 | - Shortly describe the Solar System - Sun, planets, etc, and hook your students in with a way (in programming) to collect and store new information and discoveries. 30 | 31 | - Activity 32 | - In small groups, students will write an algorithm for adding new Solar System discoveries to a collection of older ones. As with the PB&J activity, the process should be complete and detailed so that a person can unambiguously follow the steps. 33 | - The process itself will seem relatively simple. Ensure students think not only about the steps to be taken but the necessary materials and resources. 34 | - Ensure that the algorithm would work for any discovery of any name size and does not make assumptions. e.g SUPER MEGA COOL ASTEROID, etc. 35 | - Pay particular attention to when the various materials are needed. 36 | - The key here is that the student will need to constantly be referencing this same pool of discoveries e.g. Pool, Pool + 1 discovery, Pool + 1 discovery + another etc. etc. 37 | - Once discussion of the algorithm is complete, instruct students to think about how they would write a SNAP program to complete this task. They need not write actual code, but should write pseudocode to attempt to solve the problem. 38 | - After groups have finished, explain to them that usually scientists organize their discoveries alphabetically not by recently discovered. Challenge them to create an algorithm that organizes their new discoveries with their old discoveries alphabetically. After this is done, challenge them to create it in SNAP. 39 | - The ultimate conclusion should be that they need a way to store the entire collection of discoveries, and operate on individual parts of the collection. 40 | - Debrief 41 | - In attempting to write pseudocode, students should realize that they need variables to store the discoveries, but do not know ahead of time how many variables will be necessary. 42 | - Clever students may want to simply store the message in a single variable using the "join" block. This approach can work if they choose an unambiguous delimiter (space won't work if there are multi-word sections of the message), and is effectively the same as using a list. 43 | - Point out that, thus far, they have not seen a way to store an arbitrary number of data values—they have needed a separate variable for each value, which must be created ahead of time. 44 | - Briefly introduce the concept of a list as a means of storing multiple values in a single location. Lists in SNAP have the useful property of not having a static size, so any number of values can be added at any time. 45 | 46 | ## Accommodations/Differentiation 47 | 48 | - As in the PB&J activity, discourage stronger students from dominating the conversation and instead ask them to take on a leadership role and help other group members find issues. 49 | - Struggling students can be given permission to use a higher level of abstraction, ignoring certain details that other students will attend to. 50 | -------------------------------------------------------------------------------- /lesson_42.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.2: Static Lists 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Create static lists in SNAP 8 | - Access elements of a list 9 | - Add and remove elements from a list 10 | 11 | ## Materials/Preparation 12 | 13 | - [Lab 4.2 handout (You Talkin' to Me?)](lab_42.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20Word/Lab%204.2%20You%20Talkin%20To%20Me.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20PDF/Lab%204.2%20You%20Talkin%20To%20Me.pdf)) 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 15 minutes | Lecture and introduce activity | 21 | | 25 minutes | Grammar Activity | 22 | | 10 minutes | Debrief and wrap-up | 23 | 24 | ## Instructor's Notes 25 | 26 | - Lecture 27 | - Review the concept of a list from the previous lesson 28 | - Ask students to brainstorm examples of when lists could be useful 29 | - To store an unknown number of values (e.g. a bunch of student test scores) 30 | - To store a collection of related values as one entity (e.g. the number of absent students each day over a week) 31 | - Demonstrate creating lists in SNAP 32 | - Use the variadic (taking a variable number of arguments) "list" block to create a simple list 33 | - Point out the format in which lists are displayed (gray box with red elements) 34 | - Show that lists can be assigned to variables like other values 35 | - Emphasize that the list is considered a single value, even though it consists of multiple values 36 | - Point out and explain basic list operations blocks 37 | - The "item," "add," and "delete" blocks will be most important. The "length" block will be useful as well. 38 | - Point out that these blocks all take a list as an argument. 39 | - Activity 40 | - Students should complete the "You Talkin' to Me?" activity individually or in pairs 41 | - Encourage students to be creative with their word lists 42 | - Don't allow students to fixate on the exact grammatical correctness of generated phrases and sentences 43 | - If this is a major concern, choose words for the lists such that generated phrases will always be grammatically correct 44 | - Debrief 45 | - Ask a student to present and discuss their solution to each step 46 | - Emphasizes uses of lists and encourage students to discuss and think about why lists were necessary 47 | - Ask students to consider if the tasks would have been doable without lists 48 | 49 | ## Accommodations/Differentiation 50 | 51 | - In addition to the bonuses in the lab, advanced students can attempt further extensions of the grammar, including conjunctions, non-transitive verb phrases, and/or recursive rules (e.g. multiple adjectives). 52 | - A more complex context-free grammar for English sentences can be found here: . 53 | - Struggling students should focus on generating a noun phrase from only a few words. The other parts of speech and phrase types can be omitted without losing the key learning objectives. 54 | - Non-native English speakers or those with low literacy may struggle with the grammatical concepts here. Since the grammar is not the key objective, feel free to scaffold liberally and/or substitute a different type of grammar. 55 | - Other grammar examples, including arithmetic expressions (which are a good simple substitute) can be found here: . 56 | -------------------------------------------------------------------------------- /lesson_43.md: -------------------------------------------------------------------------------- 1 | 2 | # Lesson 4.3: List Practice I 3 | 4 | ## Learning Objectives 5 | 6 | Students will be able to... 7 | 8 | - Traverse a list, accessing each element one at a time 9 | - Perform operations combining all elements in a list 10 | - Select defined subsets of elements in a list 11 | 12 | ## Materials/Preparation 13 | 14 | - [Lab 4.3 handout (Guess Who)](lab_43.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20Word/Lab%204.3%20Guess%20Who.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20PDF/Lab%204.3%20Guess%20Who.pdf)) 15 | 16 | ## Pacing Guide 17 | 18 | | Duration | Description | 19 | | ---------- | --------------------------------------------- | 20 | | 5 minutes | Welcome, attendance, bell work, announcements | 21 | | 15 minutes | Lecture and demonstration | 22 | | 30 minutes | Guess Who Activity | 23 | | 5 minutes | Wrap-up | 24 | 25 | ## Instructor's Notes 26 | 27 | 1. Lecture 28 | 29 | 1. In small groups, ask students to consider how to count the number of students with July birthdays in the room 30 | - Provide only a few minutes to work through this-- students need not write full, formal algorithms, but simply desribe an approach 31 | - Have groups share with each other and work together to come up with a single approach, hopefully settling on asking each student if s/he has a July birthday and counting the number of yeses (or something similar). 32 | 2. Define "traversal" as _the process of accessing each element of a list in order and performing some operation_ 33 | - Call out that the operation can be anything, and may not actually be performed on every element 34 | - Provide a few examples of possible operations (say each person's name, count the number of females, add up the total number of siblings, find the average GPA, etc.) 35 | - Explain that traversing is how many problems involving lists are solved. 36 | 3. As a group, develop sample code for a simple list traversal, such as the following:
37 | ![](simpleListTraversal.png) 38 | - Ask leading questions to help students write each line of code, one a time, then gradually put the pieces together ("build up" approach) 39 | - Point out that the "say" block can be replaced by any code (including larger blocks of code for more complex operations), but that the rest of the script will typically be the same 40 | - Emphasize that the "index" variable is keeping track of where we currently are in the list, and can be used in the traversal operation if wanted, as in:
41 | ![](useIndexInLoop.png) 42 | 43 | 2. Activity 44 | - Students should complete the "Guess Who" activity individually or in pairs 45 | - Students will be performing several traversal operations, some of which simulate mapping, filtering, or reducing/folding the list. You can discuss these operations if you feel the class can handle it. 46 | - Part 1.3 requires use of the "join" block—be sure that the students are comfortable using this block. 47 | 3. Wrap-up 48 | - Ask students to briefly describe how the various parts of the lab were similar or different 49 | - Hopefully the students find that the scripts were quite similar for each part. 50 | - Ask students to describe something they found challenging about the lab 51 | - You will go over the correct solutions to the lab in the next lesson 52 | 53 | ##BJC Lecture Suggestion 54 | ####Background Information for Instructors 55 | * BJC Video Suggestion :[BJC Lecture 9: Recusion](https://www.youtube.com/watch?v=JKn3nsfzBdA) 56 | - Movie “Inception” as an example of recursion 0:00-0:50 57 | - Recursion 0:50-1:40 58 | - Recursion Demo in Snap 1:40-17:00 59 | - Overview 17:00-21:00 60 | - Definition of Recursion 21:00-24:30 61 | - Examples of Recursion (You Already Know It!) 24:30-26:20 62 | - Trust the Recursion 26:22-29:40 63 | - Summary of Recursion 29:40-End 64 | 65 | 66 | 67 | ## Accommodations/Differentiation 68 | 69 | - Advanced students can attempt more complex filters in part 2.3 (such as finding all names that contain at least two vowels) and/or more advanced maps in part 1.3 (such as greeting each person by first initial). 70 | - Struggling students should focus on parts 1.2, 2.1, and select items from part 2.3. Partial code can be provided. 71 | -------------------------------------------------------------------------------- /lesson_44.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.4: List Practice II 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Traverse a list, accessing each element one at a time 8 | - Perform operations combining all elements in a list 9 | - Select defined subsets of elements in a list 10 | 11 | ## Materials/Preparation 12 | 13 | - [Lab 4.4 handout (Number Cruncher)](lab_44.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20Word/Lab%204.4%20Number%20Cruncher.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20PDF/Lab%204.4%20Number%20Cruncher.pdf)) 14 | 15 | ## Pacing Guide 16 | 17 | | Duration | Description | 18 | | ---------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 10 minutes | Review and debrief lab 4.3 | 21 | | 25 minutes | Activity | 22 | | 15 minutes | Debrief and wrap-up | 23 | 24 | ## Instructor's Notes 25 | 26 | - Review 27 | - Ask students to define "traversal" and outline the basic code pattern 28 | - You need not write actual code here, but have students mention the key points (index variable, use index to access each item, repeat length of list, etc.) 29 | - Review solutions to lab 4.3 30 | - Ask a student to provide their solution to each part 31 | - Discuss errors or flaws in each solution 32 | - Point out similarities between each part, emphasizing that the basic code pattern is the same each time with only the operation performed on each item changing 33 | - If you feel students can handle it, you can further classify various traversals (maps, filters, folds) 34 | - If necessary, provide the basic code pattern for a traversal again: 35 | 36 | ![simple list traversal](simpleListTraversal.png) 37 | - Activity 38 | - Students should complete the "Number Cruncher" lab individually 39 | - The operations in this lab are fairly similar to those in lab 4.3, but work with lists of numbers instead of names. As a result, students should progress more quickly. 40 | - As in lab 4.3, help students realize that the basic code pattern in each part will be the same. 41 | - Debrief 42 | - Ask one or two students to share their solution to each part of the lab 43 | - If all students seem to grasp the concept, not all parts need to be reviewed 44 | - If skipping some parts, be sure to review at least parts 1.1 (a fold), 2.1 (a map) and 2.2 (a filter) 45 | - Point out that the solutions from labs 4.3 and 4.4 will look quite similar, even though in lab 4.3 the lists contained names in in lab 4.4 they contained numbers 46 | - The traversal code pattern is the same regardless of the type of elements in the list 47 | 48 | ## Accommodations/Differentiation 49 | 50 | - Advanced students should complete both bonus parts of the lab (1.5 and 2.3) and then assist struggling students. 51 | - Students who need more assistance should focus on parts 1.3, 2.1, and 2.2. Ensure that all students are able to complete at least these three parts before concluding the lesson. 52 | -------------------------------------------------------------------------------- /lesson_45.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.5: Sequential Search 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Explain the sequential search algorithm 8 | - Implement several variations of sequential search 9 | 10 | ## Materials/Preparation 11 | 12 | - [Lab 4.5 handout (It's Around Here Somewhere)](lab_45.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20Word/Lab%204.5%20Its%20Around%20Here%20Somewhere.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%204%20PDF/Lab%204.5%20Its%20Around%20Here%20Somewhere.pdf)) 13 | 14 | ## Pacing Guide 15 | 16 | | Duration | Description | 17 | | ---------- | --------------------------------------------- | 18 | | 5 minutes | Welcome, attendance, bell work, announcements | 19 | | 15 minutes | Lecture and demonstration | 20 | | 25 minutes | It's Around Here Somewhere Activity | 21 | | 10 minutes | Debrief and wrap-up | 22 | 23 | ## Instructor's Notes 24 | 25 | - Lecture 26 | - Ask students to consider how to determine if a particular person is in the room or not 27 | - At first, you will likely get answers like "call out the person's name" or "look around." Press the students to come up with a method that will always work, including when the person is not present. If necessary, ask them to pretend they are a computer. 28 | - Point out that solutions like "look around" are too high-level, and in reality, there is a lot more going on (such as looking at each person individually). 29 | - Guide students to the process of checking if each person is the one they are seeking, in some deterministic order, until they have either found the person or checked everyone. Emphasize that the absence of the person is only confirmed when everyone has been checked, but that the presence is known as soon as the person is found. 30 | - Get students to recognize that this process is a traversal of the people in the room. 31 | - Explain that the process of traversing a list looking for a particular item is known as a "sequential search." 32 | - Ask students to think about the efficiency of this algorithm. Emphasize best, worst, and average cases (both what those cases are and how long they take). 33 | - You need not get into specific runtimes or big-O notation, but students should have a basic understanding of the fact that the speed of the search is dependent on the size of the list. 34 | - If students seem prepared, ask them to speculate under what circumstances you might be able to do better (eventually leading to binary search). 35 | - Show the code for a basic sequential search:
36 | ![basic sequential search](basicSequentialSearch.jpg) 37 | - Point out that this code is another variation of a traversal. 38 | - Emphasize that this is only one variant of sequential search. The specifics of what to report can vary (true/false, index in list, item itself, etc.). 39 | - Activity 40 | - Students should complete the "It's Around Here Somewhere" activity individually or in pairs. 41 | - Each part asks students to write a slightly different sequential search. In all cases, make sure students are clear on what they should be reporting, both when the desired item is found and when it is not. 42 | - Debrief 43 | - Ask one or two students to provide their solutions to each part 44 | - Point out the similarities in each solution, emphasizing that the algorithm remains constant and only the value that is reported changes. 45 | 46 | ## Accommodations/Differentiation 47 | 48 | - Advanced students can be encouraged to explore more efficient searching algorithms (specifically binary search). 49 | - Struggling students should focus on just parts 1.1 and/or 2.1 of the lab. Remind these students that they are starting with a traversal and simply changing what happens to each item. 50 | -------------------------------------------------------------------------------- /lesson_46.md: -------------------------------------------------------------------------------- 1 | # Lesson 4.6: Hangman Project 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Use lists to implement a complete version of "Hangman" 8 | - Exercise good programming practices to produce code that is not only functional but also elegant and well-written 9 | 10 | ## Materials/Preparation 11 | 12 | - [Project 4 - Hangman](project_4.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Projects/Projects%20Word/Project%204%20Hangman.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Projects/Projects%20PDF/Project%204%20Hangman.pdf)) 13 | 14 | - [Project 4 Alternative - Snowman](project_4.md) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Projects/Projects%20Word/Project%204%20Snowman.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Projects/Projects%20PDF/Project%204%20Snowman.pdf)) 15 | 16 | - [Optional] Printouts of the specification 17 | - Link to an online version of Hangman, such as 18 | - A word list from which words can be selected for the game, such as 19 | 20 | ## Pacing Guide 21 | 22 | | Duration | Description | 23 | | ---------- | --------------------------------------------- | 24 | | 5 minutes | Welcome, attendance, bell work, announcements | 25 | | 15 minutes | Review and introduce project | 26 | | As needed | Lab time for Hangman project | 27 | 28 | ## Instructor's Notes 29 | 30 | - Review/Introduction 31 | - Review the various skills and concepts have been learned so far in the unit. 32 | - Put particular emphasis on the maintenance of lists and traversals 33 | - Remind students that their solutions to previous assignments are an excellent resource when trying to accomplish similar tasks. 34 | - Walk students through the project specification, pointing out important details, potential pitfalls, and requirements. 35 | - Focus students' attention on the checkpoints to help them avoid becoming overwhelmed. 36 | - Help students import the word list into a SNAP list, either by right-clicking on the list view and selecting "import" or by parsing the online list directly using the "http://" block. This is not one of the objectives of the project, so feel free to provide starter code if you prefer. 37 | - Emphasize that generating the "word pattern" or "blanks" and keeping that sequence up-to-date with each guess is the hardest part of the assignment, and should not be overlooked. 38 | - Remind students that it will be important to keep straight what each variable and list in the program is used for. Each variable or list should have a single purpose, and those purposes should never be conflated. 39 | - Project 40 | - This is a summative assessment project. Students should be given at least a few days in class to work on the project. The exact schedule should be determined by your teaching team based on overall class capability and other factors. 41 | - If most students have the ability to work at home, you can consider reducing the amount of in-class time provided and requiring students to spend time working at home. 42 | - Provide a means for students to ask questions throughout the project and provide assistance as needed. 43 | 44 | ## Accommodations/Differentiation 45 | 46 | - The concept of a "hangman" may be troubling to some students, especially in parts of the country with a history of lynching or other similar types of violence. If you believe that to be the case, feel free to rename the game (e.g. "Wheel of Fortune") and choose a different image or theme for tracking incorrect guesses (such as popping balloons). 47 | - If any students do not have the ability to work at home, ensure enough in-class time is provided to complete the assignment, offering extensions if necessary. 48 | - Advanced students can be encouraged to add extensions such as: 49 | - Enabling guessing of the entire word 50 | - Allowing the user to specify the length of the word to be guessed 51 | - Keeping statistics (win-loss record, fewest guesses, etc.) across games 52 | - _Very_ advanced students can attempt Evil Hangman: 53 | - Struggling students can be given starter code or exempted from certain features 54 | - Though it is the most difficult part of the assignment, tracking the "blanks" is the best practice working with lists and should be preserved. 55 | - The requirements to display a graphical hangman, track repeated guesses, and specifically recognize a win can be removed for students in need of significant simplification. 56 | -------------------------------------------------------------------------------- /lesson_51.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # Lesson 5.1: Intro to Cloning 4 | 5 | ## Learning Objectives 6 | 7 | Students will be able to... 8 | 9 | - Explain why prototyping and clones can be useful 10 | - Describe how complex goals can be accomplished using cloning 11 | 12 | ## Materials/Preparation 13 | - [Lab 5.1 Handout](lab_51.md) (Connect the Dots) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20Word/Lab%205.1%20Connect%20the%20Dots.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20PDF/Lab%205.1%20Connect%20the%20Dots.pdf)) 14 | - If possible, create large poster-sized versions of the dot grids (each grid is 12 x 3). 15 | 16 | ## Pacing Guide 17 | | Duration | Description | 18 | | --------- | --------------------------------------------- | 19 | | 5 minutes | Welcome, attendance, bell work, announcements | 20 | | 10 minutes | Introduce activity | 21 | | 25 minutes | Activity | 22 | | 15 minutes | Debrief and wrap-up| 23 | 24 | ## Instructor's Notes 25 | 26 | 1. Introduce activity 27 | * Inform students that they will be drawing some figures by following specific instructions 28 | * Emphasize that students must follow all instructions in the lab carefully 29 | * Throughout the activity, ask students to think about other ways they could accomplish the same goals and the advantages and disadvantages of each approach. 30 | 2. Activity 31 | * Split students into groups of at least six. If the number of students is not an exact multiple of six, create a few groups of seven and have students take turns being "active." 32 | * Students should follow the steps in the lab, being careful to act as a group. 33 | * In each part, the group will draw the letter 'C' six times, using slightly different instructions. 34 | * Students should, hopefully, notice that in part 3, they are able to achieve similar but not exactly the same results by all following the same instructions. (Though each student draws a 'C', they are not all in the same location.) In each part, they were able to improve the efficiency and clarity of the instructions. 35 | 3. Debrief 36 | * Ask each group to share their answers to the questions at the end of each part. 37 | * Discuss how this approach could be applied to coding. 38 | * Introduce the terms "prototyping" and "cloning" as (mostly) synonyms: 39 | * _prototyping: creating a single "master" entity that defines the behavior for a group of objects, then creating many copies of the prototype to duplicate the behavior_ 40 | 41 | ##BJC Lecture Suggestions 42 | 43 | #### Good for Classroom Instruction 44 | - [Fibonacci and Fibonacci Series Video](http://www.youtube.com/watch?v=w2d_snYBLeY&t=7m45s) 7:45-11:45 45 | ####Background Information for Instructors 46 | 47 | * [BJC Lecture 11:Recursion II Alijia Yan](https://www.youtube.com/watch?v=w2d_snYBLeY&index=11&list=PLA4F0F0CA4A3EE7F4) 48 | - Mobile World Congress 0:00-2:15 49 | - Recursion:Factorials (Factorial (n)+ n! 2:30-7:40 50 | - [Fibonacci and Fibonacci Series Video](http://www.youtube.com/watch?v=w2d_snYBLeY&t=7m45s) 7:45-11:45 51 | - Fibonacci Ex: fin(n) Math and SNAP blocks 11:50-13:15 52 | - Example of Recursion: Counting Change 13:20-17:30 53 | - Call Tree for “Counting Change” with SNAP example 17:35-22:50 54 | - Summary of Recursion 25:40-26:21 55 | 56 | 57 | ## Accommodations/Differentiation 58 | -------------------------------------------------------------------------------- /lesson_52.md: -------------------------------------------------------------------------------- 1 | # Lesson 5.2: Cloning Sprites 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Demonstrate the difference between sprite and global variables 8 | - Explain how cloning and prototyping simplify working with numerous similar sprites in the same program 9 | - Create prototype sprites and clones of the prototype sprite 10 | - Explain the difference between a "master" sprite and a "clone" sprite 11 | 12 | ## Materials/Preparation 13 | 14 | - [Lab 5.2 handout](lab_52.md) (Lots of Balls) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20Word/Lab%205.2%20Lots%20of%20Balls.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20PDF/Lab%205.2%20Lots%20of%20Balls.pdf)) 15 | - Test out the lab on student machines before class-- cloning in SNAP! can bring the web browser to a crawl on some machines 16 | 17 | ## Pacing Guide 18 | 19 | | Duration | Description | 20 | | ---------- | --------------------------------------------- | 21 | | 5 minutes | Welcome, attendance, bell work, announcements | 22 | | 15 minutes | Introductory discussion | 23 | | 30 minutes | Lots of Balls lab | 24 | | 15 minutes | Debrief and wrap-up | 25 | 26 | ## Instructor's Notes 27 | 28 | 1. Introductory discussion 29 | - Show students a brief video demonstrating space invaders () 30 | - Ask students to think about how we create all the “invaders”? 31 | - Answer with current knowledge: make one invader sprite, and copy it many times while adjusting the copies as necessary 32 | - Ask what might go wrong or be bad about this approach 33 | - If anything in an invader changes, it will need to be changed many times 34 | - Lots of sprites clogging up the program that are all basically doing the same thing 35 | - Introduce cloning as the automated way of doing the manual copying 36 | - Demonstrate how to create a clone using ![](createACloneOf.png) 37 | - Point out that clones inherit all aspects of the "master" or "prototype" sprite, including scripts 38 | - Emphasize the importance of using ![](whenIStartAsAClone.png) to ensure clones don't duplicate out of control 39 | 2. Activity 40 | * Students should complete the ["Lots of Balls"](lab_52.md) lab 41 | * This lab will largely duplicate the code shown in the lecture part of the lesson-- that's OK 42 | * Students should focus on ensuring they are differentiating between "master" sprites and "clone" sprites, and that the stage is serving as the main "driver" for the program 43 | 44 | ## Accommodations/Differentiation 45 | * Advanced students can attempt to assign properties to clones (color, size, etc.) so that not all clones look alike. To do this, they will need to use a global variable to temporary hold the value that can be "claimed" by the clone. 46 | * Struggling students should focus on just creating a single clone from the prototype and not worry about creating multiple clones. 47 | -------------------------------------------------------------------------------- /lesson_53.md: -------------------------------------------------------------------------------- 1 | # Lesson 5.3: Communicating with Clones 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | - Pass information from the master to individual clones 7 | - [Optional] Describe a race condition that might occur due using global variables and clones 8 | - Delete clones when they are no longer needed 9 | 10 | ## Materials/Preparation 11 | - [Lab 5.3 Handout](lab_53.md) (Fewer Balls) ([Download in Word](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20Word/Lab%205.3%20Fewer%20Balls.docx)) ([Link to PDF](https://teals-introcs.gitbooks.io/introduction-to-computer-science-principles/content/Unit%205%20PDF/Lab%205.3%20Fewer%20Balls.pdf)) 12 | * Test out the lab on student machines before class to ensure the machines can handle the number of clones 13 | 14 | ## Pacing Guide 15 | 16 | | Duration | Description | 17 | | ---------- | --------------------------------------------- | 18 | | 5 minutes | Welcome, attendance, bell work, announcements | 19 | | 10 minutes | Introductory discussion | 20 | | 30 minutes | Fewer Balls lab | 21 | | 15 minutes | Debrief and wrap-up | 22 | 23 | ## Instructor's Notes 24 | 25 | 1. Introductory discussion 26 | - Review the lab from yesterday again, focusing on the identical nature of the clones 27 | - Ask students to describe how (or if) the prototype communicates to the clones 28 | - Ask students how they might remove balls if they decide there too many 29 | - Students should ultimately realize that there is no way to destroy only some clones 30 | - Introduce the distinction between "global variables" and "sprite variables" 31 | - Global variables ("for all sprites") are visible to and usable by all sprites in the program 32 | - Sprite variables ("for this sprite only") are only visible to and usable by a single sprite 33 | - Emphasize that, when cloning is used, each clone gets its own copy of any sprite variables inherited from the prototype 34 | - Ask students to brainstorm situations in which each type of variable is appropriate 35 | - Global variables are best for application-level data, such as sprite counts, game level number, score, etc. 36 | - Sprite variables are best for properties that may be specific to each sprite, such as speed, id #, etc. 37 | 2. Activity 38 | - Students should complete the [Fewer Balls](lab_53.md) lab. 39 | - Students will likely have difficulty isolating the uses for each variable. Remind them that each variable serves a specific purpose, and that they should focus on keeping straight what variable does what. 40 | - Currently, the lab is written to use global variable "id" to talk to one sprite at a time. If not used carefully, this design pattern has the potential for race conditions. If you believe students are capable, you can have a discussion about race conditions and concurrency and the problems that can arise. 41 | 3. Debrief 42 | - Have students pair up and review each other's code. Encourage students to discuss differences in their approaches and try to understand why each wrote the code as they did. 43 | - Ask a few students to share difficulties they or their partner had and/or different approaches they took the problems. 44 | 45 | ## Accommodations/Differentiation 46 | 47 | - For faster students, explaining and demonstrating race conditions would be valuable. Instructors could also give out project with a "simple race condition" (if such a thing exists) and ask the students to fix it 48 | - Advanced students can also try to implement features giving them additional control over clones, such as changing a specific clone's speed or direction. 49 | - Struggling students can ignore the requirement to be able to create new sprites after some have been deleted and justfocus on deleting clones one at a time. 50 | -------------------------------------------------------------------------------- /lesson_54.md: -------------------------------------------------------------------------------- 1 | # Lesson 5.4: Space Invaders Project 2 | 3 | ## Learning Objectives 4 | 5 | Students will be able to... 6 | 7 | - Use cloning to implement a complete version of "Space Invaders" 8 | - Exercise good programming practices to produce code that is not only functional but also elegant and well-written 9 | 10 | ## Materials/Preparation 11 | 12 | - [Project 5 - Space Invaders](project_5.md) ([Download in Word](Projects/Projects Word/Project 5 Space Invaders.docx)) ([Link to PDF](https://teals.sharepoint.com/curriculum/_layouts/15/guestaccess.aspx?guestaccesstoken=%2fWvUoinE6f6mYjTSnt9Dt9HD%2bmiwwHs9M0LBJf0%2fo5w%3d&docid=04b51971fcc9e4368970c042ca39d8e2e)) 13 | - [Optional] Printouts of the specification 14 | - Link to an online version of Space Invaders, such as 15 | 16 | ## Pacing Guide 17 | 18 | | Duration | Description | 19 | | ------------- | --------------------------------------------- | 20 | | _Day 1_ | | 21 | | 5 minutes | Welcome, attendance, bell work, announcements | 22 | | 30 minutes | Review unit concepts | 23 | | 20 minutes | Introduce project | 24 | | _Days 2-12_ | | 25 | | 5 minutes | Welcome, attendance, bell work, announcements | 26 | | 10-15 minutes | Review | 27 | | 30-35 minutes | Lab time | 28 | | 5 minutes | Exit ticket | 29 | 30 | ## Instructor's Notes 31 | 32 | 1. Review/Introduction 33 | - Play a review game (such as [GrudgeBall](http://toengagethemall.blogspot.com/2013/02/grudgeball-review-game-where-kids-attack.html)) to remind students of the skills and concepts have been learned in this unit. 34 | - Definition of "prototyping" 35 | - Creating clones 36 | - Using a master sprite 37 | - Modifying clone behavior 38 | - Passing information from the master to clones 39 | - Deleting clones 40 | - Remind students that their solutions to previous assignments are an excellent resource when trying to accomplish similar tasks. 41 | 2. Introduce project 42 | - Walk students through the project specification, pointing out important details, potential pitfalls, and requirements. 43 | - If students are unfamiliar with Space Invaders, spend a couple minutes demonstrating one for the class. If you have a SNAP or Scratch version, that works best, but an online game (such as ) will work as well. 44 | - Remind students that their version of the game does not need to exactly mimic the classic version. In particular, they need not have quite as many invaders, create barriers for the player to hide behind, or duplicate invader movement or firing patterns exactly. 45 | 3. Project 46 | 47 | - This project is a summative assessment for the unit. Students should be demonstrating mastery of all the skills covered. 48 | - Most students will require roughly 10-15 hours of total work time to complete the project 49 | - Assess the progress of your students regularly using such techniques as asking them to demonstrate their incomplete programs, tracking questions asked during lab time, and/or utilizing peer reviews. 50 | - Adjust the amount of time allowed for the project to fit the needs of your students 51 | - It is vital that nearly all students complete the project before moving on 52 | - If most students have the ability to work on SNAP assignments at home, the amount of in-class time provided can be reduced if necessary. 53 | - If this approach is taken, be sure to make accommodations for students who are _not_ able to work at home, such as after school lab hours 54 | - Ensure that students are able to ask questions in class throughout the project 55 | - See the standard [Lab Day Lesson](lab_day_lesson.md) for detailed plans for lab days. 56 | 57 | - [Sample initial project solution](http://snap.berkeley.edu/snapsource/snap.html#present:Username=nathanielgranor&ProjectName=space%20invaders%20demo) 58 | 59 | ## Accommodations/Differentiation 60 | 61 | - If any students do not have the ability to work at home, ensure enough in-class time is provided to complete the assignment, offering extensions if necessary. 62 | - Advanced students can be encouraged to add different types of invaders that behave differently, implement a Galaga-style "swoop" behavior from the invaders, add player power-ups (such as advanced weapons), or any other extension. 63 | - Struggling students can be exempted from certain features (such as levels or invader firing) or given starter code 64 | - If students need significant assistance, focus them on the invaders. Getting a set of invaders created and moving properly will best target the vital objectives from this unit-- namely cloning. 65 | -------------------------------------------------------------------------------- /lesson_61.md: -------------------------------------------------------------------------------- 1 | # Lesson 6.1 - Design Basics 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Identify the key considerations when designing a piece of software 6 | * Describe methods for prioritizing features, use cases, and/or scenarios 7 | * Explain why design and planning are necessary steps in the software engineering process 8 | 9 | 10 | ## Materials/Preparation 11 | 12 | 13 | ## Pacing Guide 14 | | Duration | Description | 15 | | --------- | --------------------------------------------- | 16 | | 5 minutes | Welcome, attendance, bell work, announcements | 17 | | 15 minutes | Introduce final project, demo examples | 18 | | 25 minutes | Sample Design activity | 19 | | 10 minutes | Debrief and wrap-up| 20 | 21 | ## Instructor's Notes 22 | 1. Introduce project 23 | 1. Talk about how far students have come this semester 24 | * Ask students to think back to the start of the semester and remember how little they knew about programming. 25 | * Briefly list a bunch of the things they've learned (drawing, animation, variables, loops, conditionals, loops, etc.) 26 | * Maybe show a lab or assignment from early on and remind them that, not that long ago, this was challenging, whereas it now seems nearly trival (hopefully). 27 | 2. Explain that, for their final project, the students will get to design and build a program of their own choosing. 28 | * Point out that this will involve more than just writing code-- there will be planning, design, scheduling, and other project management tasks 29 | * Emphasize that students will be graded on not only the program they produce, but the process they used to design, plan, and implement it 30 | 3. Demonstrate a few example projects (with as much variety as possible). 31 | * Try to hit a bunch of different types of programs. Many students will gravitate towards games, but other options include simulations, productivity tools, musical projects, animations, and more. 32 | * TEALS can provide a few samples if needed. 33 | 4. Distribute the project rubric and point out key aspects of the requirements 34 | * Point out the steps in the process and that each one is equally important 35 | * Specifically mention the large number of points for things _not_ related to coding 36 | * Remind students that, as they are now SNAP experts, there are high expectations for the depth, complexity, and completeness of their projects 37 | 2. Sample design activity 38 | 1. Tell students that, as a class, they will now practice some of the design and planning tasks for the project on a well-known app 39 | * Pick an app that both you and most of your students have a deep familiarity with, but that is not too complex. Twitter, Instagram, Pinterest, or other relatively small-scope social media apps work well here. 40 | * If necessary, scope down the app by focusing on only the core features (e.g. only consider public, text-only Tweets to start) 41 | 2. Walk through each of the design steps in the project rubric for the chosen app: 42 | 1. Pitch - describe the basic functionality of the app in one paragraph of less 43 | 2. Define - List the features/scenarios the app will support 44 | 3. Sketch - Draw a very basic wireframe sketch of the main "screens" of the app 45 | * In this step, try to keep students from fixating on making their app look _exactly_ like the existing app 46 | 4. Expand - Build a spec using the [Final Project Plan Organizer](Final Project Plan Organizer.docx). 47 | * In this step, emphasize completeness and detail. Leaving out steps or requirements will make it difficult to plan effectively and will likely force major changes or cuts later. 48 | 5. Plan - Based on the feature list and spec, create a full development plan using the [Final Project Development Plan](Final Project Development Plan.docx). 49 | * As tasks and costs are listed, remind students to keep an eye on the total amount of time required and to include buffer for things going wrong. Be sure to prioritize tasks so that cuts can be made if necessary. 50 | 3. Debrief 51 | * Once all documents have been created, ask students what the next steps should be. 52 | * Get more detail than "start coding." Students should be focused on the highest-priority tasks and should understand the plan for evaluating progress throughout the project. 53 | * Preserve the documents created in the activity to give to students as examples when planning their own projects. 54 | * Emphasize that both the spec and the plan are "living documents" and should be updated as the project progresses (when new features are thought of, tasks are cut for time or complexity, priorities are reorganized, etc.) 55 | 56 | 57 | ## Accommodation/Differentiation 58 | * This lesson could easily take two or even three days depending on the class. Take as long as is necessary to ensure students have a complete understanding of the steps necessary to create their final project, but try not to get too bogged down in the details of the sample app. 59 | * For classes with a large number of self-sufficient students, consider having students complete this activity in small groups rather than as a full class. Along the way, have groups share their progress and provide feedback to each other. 60 | -------------------------------------------------------------------------------- /lesson_62.md: -------------------------------------------------------------------------------- 1 | # Lesson 6.2 - Brainstorming and Evaluating 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Identify factors to use when choosing between project ideas 6 | * Rank a group of proposed project ideas using the identified factors 7 | 8 | ## Materials/Preparation 9 | 10 | 11 | ## Pacing Guide 12 | | Duration | Description | 13 | | --------- | --------------------------------------------- | 14 | | 5 minutes | Welcome, attendance, bell work, announcements | 15 | | 10 minutes | Review process and identify first steps | 16 | | 5 minutes | Brainstorming | 17 | | 10 minutes | Pitch writing | 18 | | 20 minutes | Peer review | 19 | | 5 minutes | Debrief and wrap-up| 20 | 21 | ## Instructor's Notes 22 | 1. Review 23 | * Ask students to identify the steps in the design and planning process as discussed in [Lesson 6.1](lesson_61.md). 24 | * Remind students that all steps are vital, and that thorough and thoughtful planning and design can make the coding phase much easier. 25 | * Inform students that today they will take the first steps in designing their final project. 26 | 2. Brainstorming 27 | * Give students 3-4 minutes to brainstorm and write down as many project ideas as they can. This should be done mostly in silence. 28 | * At this point, there should be minimal detail, no evaluation or rejection of ideas, and no discussion. In particular, students should not think about the difficulty or "coolness" of the project yet. Just write down ideas. 29 | * If desired, have each student share one idea. Do not allow discussion, criticism, or explanation-- each idea should be summarized in only a few words or a single sentence. 30 | 3. Pitch writing 31 | * Have students look at their list of ideas and spend a few minutes thinking about them. Then, each student should pick their **3** favorite ideas and write a "pitch" for the project. A pitch should be no more than a short paragraph and should describe the basic, high-level features of the project. The pitch should _not_ include any implementation details (scripts, sprites, etc.). 32 | * Pitches should include a moderate level of specificity-- enough for someone to imagine how the app will work, but not so much to get bogged down. Enforce the "one short paragraph" restriction. 33 | * If a student is having difficulty developing a pitch for an idea, that might be a sign that the idea is not fully-formed enough to be a final project. 34 | * If a student is having trouble keeping the pitch short, the project may be too complex to complete in the available time. 35 | 4. Peer review 36 | * Pair students up and have students take turns reading one of their pitches to their partner and asking for feedback. Partners should ask questions to help identify both the best and worst parts of each pitch. 37 | * Remind students to keep all feedback constructive, respectful, and professional. Students should not criticize each other's ideas, but can point out potential concerns. 38 | * Students should take notes during their conversations and refine their pitches based on their partner's feedback and their own realizations. 39 | * If time allows (or over the course of multiple days), repeat this process with new partners. 40 | 5. Debrief 41 | * At this points, students should have between one and three pitches that are well-defined and reasonably well fleshed-out. Overnight, students should consider their pitches and rank them in order or which they would most like to pursue as their final project. 42 | * Make sure students don't just pick the "coolest" sounding idea, but also consider the technical challenges, amount of time available, and their own interest in and willingness to see the project through to completion. 43 | 44 | 45 | ## Accommodation/Differentiation 46 | * If students are having difficulty coming up with project ideas, encourage them to think about existing software. While simply recreating an existing app should be a last resort, thinking about apps they already know can help students come up with functionality they might like to include. 47 | * If your class is fairly self-sufficient and mature, you can consider allowing students to "borrow" an idea from a classmate if they find one they like better than any of their own. Make sure the person who had the idea is OK with it being borrowed, and emphasize that the students must each build their own version. 48 | * This can be a bit dangerous, as it puts the student somewhat behind in the process right from the start, since they won't have as much context having not written the pitch themself. Consider carefully whether this is a good idea. 49 | * Encourage each student to pick a project that fits his or her level of technical skill. Make sure students are not overcommitting and choosing projects they do not have the skills to complete. Also try to discourage stronger students from choosing simpler projects in an effort to do less work. -------------------------------------------------------------------------------- /lesson_63.md: -------------------------------------------------------------------------------- 1 | # Lesson 6.3 - Defining Requirements 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Define key scenarios for a project and the features required to implement each scenario 6 | * Explain the importance of wireframing when designing an application 7 | 8 | 9 | ## Materials/Preparation 10 | * [Final Project Plan Organizer](Final Project Plan Organizer.docx) handout 11 | 12 | ## Pacing Guide 13 | | Duration | Description | 14 | | --------- | --------------------------------------------- | 15 | | 5 minutes | Welcome, attendance, bell work, announcements | 16 | | 10 minutes | Review pitches | 17 | | 20 minutes | Scenario definition | 18 | | 15 minutes | Wireframing | 19 | | 5 minutes | Debrief and wrap-up| 20 | 21 | ## Instructor's Notes 22 | 1. Review pitches 23 | * Have students look at their revised pitches from yesterday. Tell them that they will be choosing **one** to pursue as their final project. 24 | * If desired, give students a few minutes to rework their pitches or get more feedback from a classmate or instructor. 25 | * Ask students to choose which idea they want to pursue, and write it down on the top of their [Final Project Plan Organizer](Final Project Plan Organizer.docx). 26 | 2. Defining Scenarios 27 | * Defining the term "scenario" for students: 28 | * _scenario: a description of a set of interactions and/or tasks that describe a start-to-finish example of how a user might want to use the application_ 29 | * Explain that defining scenarios helps a programmer focus on what features are actually necessary to enable the key user interactions for their application 30 | * Instruct students to write down at least **3** scenarios for their project describing, from start to finish, interactions a user might have with their program to accomplish a specific goal 31 | * The scenarios should have a moderate level of detail in the description of the user interaction (e.g. "push a button," "type in their name," etc.) but should not include any design or implementation details. 32 | * Once students have written their scenarios, they should review them and develop a list of the necessary features to enable each scenario 33 | * Again, there should be minimal technical detail in these descriptions, instead focusing on details of the user experience. The feature lists should should be more about _requirements_ than implementation. 34 | 3. Wireframing 35 | * Define the term "wireframe" for students: 36 | * _wireframe: a high-level sketch of an application's user interface intended to help visualize layout, interactions, and transitions_ 37 | * Explain that wireframes do not include any details (such as specific graphics or text), but instead provide a broad impression of what an application will look like to aid in design and planning 38 | * Students will complete page 1 of the organizer by sketching or wireframing the important screens for their project. 39 | * If you have one available, a wireframing tool such as [Balsamiq](https://balsamiq.com/) can be used instead of sketching by hand. 40 | * As with all wireframing, students should not focus on the specific details of the sprites, images, etc. that will appear, but instead design the basic layout and main components of each screen. 41 | * Encourage students to reference their feature lists to ensure they include _all_ necessary screens for their project, including simple things like a splash screen, help screen, or exit ("game over") screen. 42 | 4. Debrief 43 | * As class ends, ensure students retain their work as they will use it to construct a detailed specification and implementation plan tomorrow. 44 | 45 | ## Accommodation/Differentiation 46 | -------------------------------------------------------------------------------- /lesson_64.md: -------------------------------------------------------------------------------- 1 | # Lesson 6.4 - Building a Plan 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Identify the main components of a functional project specification and explain the purpose of each section 6 | * Develop a project idea into a full, detailed specification 7 | 8 | 9 | ## Materials/Preparation 10 | 11 | 12 | ## Pacing Guide 13 | | Duration | Description | 14 | | --------- | --------------------------------------------- | 15 | | 5 minutes | Welcome, attendance, bell work, announcements | 16 | | 10 minutes | Review feature lists and wireframes | 17 | | 20 minutes | Spec writing | 18 | | 15 minutes | Building implementation plan| 19 | | 5 minutes | Debrief and wrap-up| 20 | 21 | ## Instructor's Notes 22 | 1. Review 23 | * Ask students to take out their feature lists and wireframes from [Lesson 6.3](lesson_63.md). They will be using these to develop a more detailed specification and plan for their project today. 24 | * If time allows, ask one or two students to share their feature list and/or wireframe and discuss with the class. 25 | * Ensure that students have an understanding of the proper level of detail at this point. 26 | 2. Spec writing 27 | * Using the details from their pitch, their feature lists, their wireframes, and the feedback they've received, students should fill out the rest of the [plan organizer](Final Project Plan Organizer.docx). 28 | * It is **VITAL** at this stage that students be as detailed and thorough as they can. Any missing information will complicate the process later when they realize what was left out. Encourage students to take their time and make sure they hit everything. 29 | * While this process is happening, instructors should circulate through the class and check-in with student. Verify that they have a complete, well-thought out idea that is feasible to complete in the available time. 30 | * If you have concerns about a student's ability to complete the proposed project, help them scope down by removing or simplifying features. 31 | 3. Implementation plan 32 | * Students should use the details built in their plan organizer to list the tasks necessary on their [Final Project Development Plan](Final Project Development Plan.docx). 33 | * Emphasize to students that tasks should be at a very low level of granularity (hence the time requirement being specified in minutes). If a single task has a time estimate of more than a few hours, the student should try to break the task into smaller pieces. 34 | * Ensure that students do not skip "trivial" or "simple" tasks (such as building a script they have written before) or non-coding tasks (such as developing graphics) in their pla. 35 | 4. Debrief 36 | * As class ends, remind students that their spec and implementation plan will be their guides throughout the process. They should update them each day and keep them with them at all times. 37 | * Ideally, anytime there is a question about the requirements or scope of the project, the spec should have the answer. If not, it's a new idea and the spec needs to be updated acordingly. 38 | 39 | ## Accommodation/Differentiation 40 | -------------------------------------------------------------------------------- /lesson_65.md: -------------------------------------------------------------------------------- 1 | # Lesson 6.5 - Project Implementation 2 | 3 | ## Learning Objectives 4 | Students will be able to... 5 | * Use the skills developed throughout the course to implement a medium- to large-scale software project 6 | * Realistically evaluate progress during software development and identify when cuts are necessary 7 | * Prioritize features and scenarios and choose which should be eliminated or modified if/when resources and/or time become limited 8 | 9 | 10 | ## Materials/Preparation 11 | * Students should each have their [Final Project Plan Organizer](https://github.com/TEALS-IntroCS/introduction-to-computer-science-principles/raw/master/Final%20Project%20Plan%20Organizer.docx) and [Final Project Development Plan](https://github.com/TEALS-IntroCS/introduction-to-computer-science-principles/raw/master/Final%20Project%20Development%20Plan.docx) 12 | 13 | ## Pacing Guide 14 | 15 | | Duration | Description | 16 | | ------------- | --------------------------------------------- | 17 | | _Days 1-15_ | | 18 | | 5 minutes | Welcome, attendance, bell work, announcements | 19 | | 10 minutes | Check-in | 20 | | 30 minutes | Lab time | 21 | | 10 minutes | Exit ticket | 22 | 23 | 24 | 25 | ## Instructor's Notes 26 | 1. Check-in 27 | - Remind students daily to keep their planning documents up-to-date and make edits as necessary. 28 | - Point out how many days remain and have students check their implementation plan to ensure they do not have more work than time remaining. 29 | - If they do, they will need to create a tenatative cut list in case they don't catch up. 30 | - Using previous days exit tickets, questions from students, instructor awareness of trouble points in the project, and/or any other resources to determine what needs covering 31 | - Use this time as an opportunity to remind students of previous labs or activities that may be applicable to their project, and/or how far along they should be by the end of the day 32 | 33 | 2. Lab time 34 | - Allow students to work on their project at their own pace 35 | - Provide a mechanism for students to ask questions of course staff as needed 36 | - Simply having students raise hands often does not work well, as it can be hard to keep track of in what order hands were raised; consider a queue of some kind where students write their names when they have a question 37 | - When there are no current questions, circulate and observe progress, stepping in if students appear stuck but are not asking for help 38 | - Be sure to meerkat and not spend more than a minute or two with any single student at a time 39 | 40 | 3. Exit ticket 41 | - Before students leave, have them answer the following questions on a small piece of paper: 42 | 1. What was the last thing you accomplished on the project today? 43 | 2. What is the first thing you will work on tomorrow? 44 | 3. Are you currently ahead, behind, or on track with your schedule? If you are behind, what tasks will you cut to get back on track? If you are ahead, what are some extra features you can add? 45 | 4. What is the riskiest remaining task for your project? 46 | - These answers will help you determine which students to visit first the next day. 47 | - Any student who indicates they are behind should get a consult with an instructor the next day to help get them back on track. 48 | - Encourage students to save each day's version of their planning documents with a new name (possibly using the suffix "_mmdd") so they can track progress and recover cut tasks if they make up time. 49 | 50 | 51 | ## Accommodation/Differentiation 52 | -------------------------------------------------------------------------------- /menucostumes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/menucostumes.png -------------------------------------------------------------------------------- /mouseX.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/mouseX.png -------------------------------------------------------------------------------- /mousex.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/mousex.png -------------------------------------------------------------------------------- /mousey.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/mousey.png -------------------------------------------------------------------------------- /move.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/move.png -------------------------------------------------------------------------------- /moveDragged.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/moveDragged.png -------------------------------------------------------------------------------- /offset bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/offset bricks.png -------------------------------------------------------------------------------- /pendown.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/pendown.png -------------------------------------------------------------------------------- /penup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/penup.png -------------------------------------------------------------------------------- /pickrandom.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/pickrandom.png -------------------------------------------------------------------------------- /playNote.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/playNote.png -------------------------------------------------------------------------------- /playnotes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/playnotes.png -------------------------------------------------------------------------------- /pointInDirection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/pointInDirection.png -------------------------------------------------------------------------------- /pointindirection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/pointindirection.png -------------------------------------------------------------------------------- /pointtowards.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/pointtowards.png -------------------------------------------------------------------------------- /random.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/random.png -------------------------------------------------------------------------------- /repeat until.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/repeat until.png -------------------------------------------------------------------------------- /repeat.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/repeat.png -------------------------------------------------------------------------------- /restforbeats.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/restforbeats.png -------------------------------------------------------------------------------- /rotateButton.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/rotateButton.PNG -------------------------------------------------------------------------------- /save as.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/save as.png -------------------------------------------------------------------------------- /say.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/say.png -------------------------------------------------------------------------------- /scriptwithhighlightedborder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/scriptwithhighlightedborder.png -------------------------------------------------------------------------------- /scriptwithmoveandsayblocks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/scriptwithmoveandsayblocks.png -------------------------------------------------------------------------------- /setVar1ToVar2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/setVar1ToVar2.png -------------------------------------------------------------------------------- /seteffect.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/seteffect.png -------------------------------------------------------------------------------- /setpencolor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/setpencolor.png -------------------------------------------------------------------------------- /setsize.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/setsize.png -------------------------------------------------------------------------------- /signin page.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/signin page.png -------------------------------------------------------------------------------- /simpleListTraversal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/simpleListTraversal.png -------------------------------------------------------------------------------- /simpleProgram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/simpleProgram.png -------------------------------------------------------------------------------- /snap window.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/snap window.png -------------------------------------------------------------------------------- /snapOverview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/snapOverview.png -------------------------------------------------------------------------------- /squarediagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/squarediagram.png -------------------------------------------------------------------------------- /stop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/stop.png -------------------------------------------------------------------------------- /stopAllSounds.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/stopAllSounds.png -------------------------------------------------------------------------------- /stopall.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/stopall.png -------------------------------------------------------------------------------- /stopbutton.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/stopbutton.png -------------------------------------------------------------------------------- /styles/pdf.css: -------------------------------------------------------------------------------- 1 | /* CSS for pdf */ 2 | -------------------------------------------------------------------------------- /styles/website.css: -------------------------------------------------------------------------------- 1 | /* CSS for website */ 2 | .summary .chapter a b{ 3 | display: none; 4 | } 5 | .summary > .chapter > a{ 6 | font-weight: bold !important; 7 | } -------------------------------------------------------------------------------- /subtraction.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/subtraction.png -------------------------------------------------------------------------------- /think.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/think.png -------------------------------------------------------------------------------- /touching.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/touching.png -------------------------------------------------------------------------------- /turn15degrees.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/turn15degrees.png -------------------------------------------------------------------------------- /two bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/two bricks.png -------------------------------------------------------------------------------- /twoblocksabouttosnaptogether.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/twoblocksabouttosnaptogether.png -------------------------------------------------------------------------------- /twosquares.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/twosquares.png -------------------------------------------------------------------------------- /twosquaresnested.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/twosquaresnested.png -------------------------------------------------------------------------------- /unit_0.md: -------------------------------------------------------------------------------- 1 | # Unit 0 2 | -------------------------------------------------------------------------------- /unit_1.md: -------------------------------------------------------------------------------- 1 | # Unit 1 2 | -------------------------------------------------------------------------------- /unit_2.md: -------------------------------------------------------------------------------- 1 | # Unit 2 2 | -------------------------------------------------------------------------------- /unit_3.md: -------------------------------------------------------------------------------- 1 | # Unit 3 2 | -------------------------------------------------------------------------------- /unit_4.md: -------------------------------------------------------------------------------- 1 | # Unit 4 2 | -------------------------------------------------------------------------------- /unit_5.md: -------------------------------------------------------------------------------- 1 | # Unit 5 2 | -------------------------------------------------------------------------------- /unit_6.md: -------------------------------------------------------------------------------- 1 | # Unit 6 -------------------------------------------------------------------------------- /useIndexInLoop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/useIndexInLoop.png -------------------------------------------------------------------------------- /whenIReceive.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/whenIReceive.png -------------------------------------------------------------------------------- /whenIStartAsAClone.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/whenIStartAsAClone.png -------------------------------------------------------------------------------- /xposition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/xposition.png -------------------------------------------------------------------------------- /xpositioncheckbox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/xpositioncheckbox.png -------------------------------------------------------------------------------- /xpositionreporting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/xpositionreporting.png -------------------------------------------------------------------------------- /xpositionwatcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/xpositionwatcher.png -------------------------------------------------------------------------------- /xygrid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/xygrid.png -------------------------------------------------------------------------------- /yposition.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/TEALS-IntroCS/introduction-to-computer-science-principles/80f89d5d3077f85d42a289fc2f538576348e2949/yposition.png --------------------------------------------------------------------------------