Quick Links
Skip to main content Skip to navigation

Computer Science Discoveries

Working...

Ajax Loading Image

 

CLICK: 2024 Computer Discoveries

 

Syllabus

Course Number:

8867 (OK Promise Approved)

 

Pre-requisite: 

None

 

Career Cluster/Pathway:

STEM/Computer Science

IT/Programming & Software Development

 

Locations:

Various locations around the state

 

Length: 

120 clock hours / 1 Carnegie unit

 

Course Description: 

Computer Science Discoveries is appropriate for 6-10th grade students and can be taught as a semester or yearlong introductory course (3-5 hours per week of instruction for 9+ weeks). The course takes a wide lens on computer science by covering topics such as programming, physical computing, HTML/CSS, and data. Students engage with computer science as a medium for creativity, communication, problem solving, and fun. The course inspires students as they build their own websites, apps, games, and physical computing devices.

 

Specific Learning Competencies - Upon successful completion of this course, the student will be able to:

  • The Problem Solving Process
    • Communicate and collaborate with classmates in order to solve a problem
    • Iteratively improve a solution to a problem
    • Identify different strategies used to solve a problem
    • Identify the four steps of the problem solving process
    • Given a problem, identify individual actions that would fall within each step of the problem solving process
    • Identify useful strategies within each step of the problem solving process
    • Apply the problem solving process to approach a variety of problems
    • Assess how well-defined a problem is and use strategies to define the problem more precisely
  • Computers and Problem Solving
    • Identify a computer as a machine that processes information
    • Provide a high level description of the different parts of the Input - Output - Store - Process model of a computer
    • Identify the inputs and outputs of common computing devices
    • Select the inputs and outputs used to perform common computing tasks
    • Define processing as the work done (possibly by a computer) to turn an input into an output
    • Define an algorithm as the series of commands a computer uses to process information
    • Develop and iteratively improve an algorithm for processing information based on given constraints
    • Describe how information can be processed to solve a particular problem.
    • Identify a possible source of a given input.
    • Determine what information should be stored on a device for later.
    • Identify and define a problem that could be solved using computing
    • Design an app that inputs, outputs, stores, and processes information in order to solve a problem
    • Provide and incorporate targeted peer feedback to improve a computing artifact
  • Web Development
    • Web Content and HTML
      • Identify the reasons someone might visit a given website
      • Identify the reasons someone might create a given website
      • Identify websites as a form of personal expression
      • Explain that HTML allows a programmer to communicate the way content should be structured on a web page
      • Write a simple HTML document that uses opening and closing tags to structure content
      • Understand how to use lesson resources provided in Web Lab
      • Use heading tags to change the appearance of text on a web page.
      • Structure content into headings, subheadings, and paragraphs.
      • Understand and explain reasons that it is difficult to control who sees information published online.
      • Understand and justify guidelines for safely publishing information online.
      • Use the <ol>, <ul>, and <li> tags to create ordered and unordered lists in an HTML page.
      • Create and name a new HTML page.
      • Explain the purpose of copyright.
      • Identify the rights and restrictions granted by various Creative Commons licenses
      • Add an image to a web page
      • Describe why using whitespace, indentation, and comments makes your code easier to maintain.
      • Develop a set of techniques for preventing bugs in HTML code and finding them when they occur
      • Connect multiple web pages into one website using hyperlinks.
    • Styling Text with CSS
      • Use CSS selectors to style HTML text elements.
      • Create and link to an external style sheet.
      • Explain the differences between HTML and CSS in both use and syntax.
      • Use CSS properties to change the size, position, and borders of elements.
      • Create a CSS rule-set for the body element that impacts all elements on the page.
      • Use basic web searching techniques to find relevant information online
      • Identify elements that contribute to a website's trustworthiness or untrustworthiness
      • Group elements using classes in order to create more specific styles on their website.
      • Apply the rgb() color function to add custom colors to their website
      • Apply CSS styles across an entire website
      • Explain the design choices they made on their website to other people
      • Prioritize and implement incremental improvements
  • Animations and Games
    • Images and Animations
      • Identify how computer science is used in a field of entertainment
      • Reason about locations on the Game Lab coordinate grid
      • Communicate how to draw an image in Game Lab, accounting for shape position, color, and order
      • Use the Game Lab IDE to plot different colored shapes on the screen.
      • Sequence code correctly to overlay shapes.
      • Debug code written by others.
      • Use and reason about drawing commands with multiple parameters
      • Generate and use random numbers in a program
      • Identify a variable as a way to label and reference a value in a program
      • Use variables in a program to store a piece of information that is used multiple times
      • Reason about and fix common errors encountered when programming with variables
      • Assign a sprite to a variable
      • Use dot notation to update a sprite's properties
      • Create a static scene combining sprites, shapes, and text
      • Explain what an animation is and how it creates the illusion of smooth motion
      • Explain how the draw loop allows for the creation of animations in Game Lab
      • Use the draw loop in combination with the randomNumber() command, shapes, and sprites to make simple animations
      • Describe the connection between updating a sprite's location properties and sprite movement on the screen.
      • Read and follow the steps of a short program written in pseudocode that manipulates variable values.
      • Use the counter pattern to increment or decrement sprite properties
      • Identify which sprite properties need to be changed, and in what way, to achieve a specific movement
      • Organize objects based on simple and compound boolean statements
      • Describe the properties of an object using boolean statements
      • Predict the output of simple boolean statements
      • Use conditionals to react to changes in variables and sprite properties
      • Use conditionals to react to keyboard input
      • Move sprites in response to keyboard input
      • Use an else statement as the fallback case to an if statement
      • Differentiate between conditions that are true once per interaction, and those that remain true through the duration of an interaction.
      • Use conditionals to react to keyboard input or changes in variables / properties
      • Sequence commands to draw in the proper order
      • Apply an iterator pattern to variables or properties in a loop
    • Building Games
      • Use the velocity and rotationSpeed blocks to create and change sprite movements
      • Describe the advantages of simplifying code by using higher level blocks
      • Use the isTouching block to determine when two sprites are touching
      • Describe how abstractions help to manage the complexity of code
      • Use sprite velocity with the counter pattern to create different types of sprite movement
      • Explain how individual programming constructs can be combined to create more complex behavior
      • Use the `displace`, `collide`, `bounce`, and `bounceOff` blocks to produce sprite interactions
      • Describe how abstractions can be built upon to develop even further abstractions
      • Create and use functions for blocks of code that perform a single high-level task within a program
      • Create and use functions to remove repeated blocks of code from their programs
      • Create and use functions to improve the readability of their programs
      • Explain how abstractions allow programmers to reason about a program at a higher level
      • Identify core programming constructs necessary to build different components of a game
      • Create and use multiframe animations in a program
      • Implement different features of a program by following a structured project guide
      • Independently scope the features of a piece of software
      • Create a plan for building a piece of software by describing its major components
      • Implement a plan for creating a piece of software
  • The Design Process
    • User Centered Design
      • Express opinions respectfully and effectively
      • Critically evaluate an object for how well its design meets a given set of needs
      • Identify empathy for the user as an important component of the design process
      • Distinguish between their own needs and the needs of their users
      • Critique a design through the perspective of a user profile
      • Design improvements to a product based on a user profile (not personal opinions)
      • Empathize with a user's needs to design an object
      • Create meaningful categories from a collection of ideas, specifically in the context of a brainstorm
      • Use a paper prototype to test out an app before programming it
      • Identify the user needs a prototype was designed to address
      • Translate user needs into changes and improvements in the user interface of an app
      • Categorize and prioritize user feedback for an app
      • Create a paper prototype for the screens of an app
      • Interview a peer to learn about their needs
      • Analyze interview notes to develop follow-up questions
      • Brainstorm potential solutions to a specific problem
      • Design the functionality of an app to address the specific needs of a user
      • Identify improvements to an app based on user testing
      • Design the user interface of an app
    • App Prototyping
      • Identify ways in which apps can effect social change
      • Locate apps that address a specific user group or need
      • Identify the user needs being addressed by an app
      • Communicate the design and intended use of program
      • Demonstrate the user flow through an app’s design using a paper prototype
      • Test a prototype with a user, recording the results
      • Analyzing a user test to identify potential issues or improvements
      • Translate a paper prototype into a digital format
      • Select the appropriate input element for a given type of information
      • Write programs that respond to user input
      • Integrate screens designed by others into an app of their own
      • Collaborate with others to develop an interactive prototype
      • Write out a detailed plan for how they will test their low fidelity prototype with other people
      • Run a user test on an app and record what users say about their minimum viable product
      • Analyze the user feedback from the previous lesson and determine a list of bugs (flaws) that need to be fixed and features that could be added to the app
      • Prioritize the bugs and features according to impact and ease of implementation
      • Present technical information clearly to non-technical users
      • Reflect on the development of an ongoing project
  • Data and Society
    • Representing Information
      • Define data as information collected from the world to help make a recommendation or solve a problem.
      • Provide examples of how representing data in different ways can affect its ability to solve different problems.
      • Choose the best way to represent some information based on how it will be used.
      • Describe the necessary features of a system for representing information
      • Create, use, and provide feedback on a system for representing information
      • Iteratively improve upon a system for representing information by testing and responding to feedback
      • Define a binary system as one that uses just two possible states to represent information
      • Define a bit as a single piece of binary information
      • Use the ASCII system to encode and decode text information in binary
      • Create and manipulate binary patterns to represent black and white images
      • Describe common features of systems used to represent information in binary
      • Use a binary system to represent numbers.
      • Extend a representation system based on patterns.
      • Apply a method of encryption to ensure the secure transmission of data.
      • Use both physical and digital security measures to secure data.
      • Use multiple binary systems to decode information.
      • Determine the most appropriate encoding system for a given piece of information.
      • Choose and justify the use of different binary representation systems depending on the information being represented
      • Encode and decode information represented in binary numbers and ASCII text
      • Create a generalized representation system for many instances of a complex type of information
    • Solving Data Problems
      • Use the problem solving process to answer a question using data.
      • Identify and collect relevant data to help solve a problem.
      • Use data to draw conclusions.
      • Give examples of how data is collected from sensors and tracking user behavior.
      • Determine data that would be helpful in solving a problem, and how that data could be collected.
      • Distinguish between data that users intentionally and unintentionally produce.
      • Identify and remove irrelevant data from a data set.
      • Create a bar chart based on a set of data.
      • Explain why a set of data must be cleaned before a computer can use it.
      • Use tables and visualizations summarizing data to support a decision
      • Present and critique interpretations of tables and visualizations
      • Identify additional data that could be collected to improve a decision
      • Visually organize data to highlight relationships and support a claim.
      • Use cross tabulation to find patterns and relationships in data
      • Design an algorithm for making decisions using data as inputs
      • Explain the benefits and drawbacks of using computers for automated decision making
      • Interpret collected data to identify patterns
      • Apply the data problem solving process to a personally relevant topic
      • Determine appropriate sources of data needed to solve a problem
  • Physical Computing
    • Programming with Hardware
      • Identify computing innovations within a given field
      • For a given device, articulate the likely inputs and outputs
      • Suggest improvements to help a device better solve a specific problem
      • Set the properties of UI elements using code
      • Respond to user input using an event handler
      • Write programs that change multiple elements on a single screen instead of changing screens
      • Connect and troubleshoot external devices
      • Turn on and off an LED with code
      • Use code to control a physical device
      • Compare and contrast multiple ways to take input
      • Describe the elements of an event handler
      • Model different methods of taking user input
      • Attach an event handler to a hardware input
      • Choose the appropriate event for a given scenario
      • Develop programs that respond to analog input
      • Scale a range of numbers to meet a specific need
      • Represent a sensor value in a variety of ways
      • Implement different features of a program by following a structured project guide
      • Develop a program that responds to events from a hardware input
      • Create a function that uses parameters to generalize behavior
      • Use event handlers to respond to user interaction
      • Design a piece of software that uses hardware for non-traditional input and output
      • Prototype a program that integrates software and hardware
    • Building Physical Prototypes
      • Access an element in an array using its index
      • Use the color LED array to individually control each color LED
      • Use the color() and intensity() methods to control each color LED
      • Create and modify an array
      • Use an array to produce sound on the buzzer
      • Recognize an array as a list of elements that can be operated on sequentially.
      • Modify the exit condition of a for loop to control how many times it repeats
      • Use a for loop to iterate over an array
      • Recognize the use and need for accelerometer orientation (pitch and roll).
      • Identify and explain the difference between the shake, data and change events.
      • Refer back to and use their past knowledge of the counter pattern.
      • Use parameters to generalize the purpose of a function.
      • Create and debug simple circuits
      • Develop an interactive physical prototype that combines software and hardware
      • Consider the needs of diverse users when designing a product
      • Independently scope the features of a piece of software
      • Prototype a physical computing device
      • Implement a plan for developing a piece of software that integrates hardware inputs and outputs