CMS 101

COURSE LEVEL: 9

COURSE NUMBER/TITLE: CMS 101 Introduction to Computer Science and Programming

INSTRUCTOR: Khalid Mohammed, (309) 648-9972, mohammedk@dupeoria.org

PREREQUISITES: none 

Confluence Link (doc): https://dupeoria.atlassian.net/wiki/external/MDlhNzQyNWJhODA0NDhkNDgyNjMxOGVhNDdlYWNmNmM

Course overview

Grade 9 Computer Science introduces how computers, data, the Internet, algorithms, and programs work while developing practical skills for school, work, and everyday life.

• Explore how computing shapes people and society, including digital citizenship, cybersecurity, networks, and data representation.

• Build computational-thinking skills through problem decomposition, algorithms, programming, testing, debugging, and revision.

• Develop confidence with hands-on Python programming, from core routines and digital-data concepts to a documented capstone.

• Complete Edgenuity lessons

• Learn through trying, testing, explaining, revising, presenting, and documenting work—not by memorizing code.

Essential questions

• How can computational thinking help us solve problems beyond the computer?

• How do algorithms, data, and programming languages represent ideas and automate tasks?

• How do the internet and networks move information, and how can systems be made safer?

• Who benefits from computing, who may be harmed, and how can we design more equitably?

• How do we communicate, collaborate, and persist as computer scientists?

Course goals

• By the end of Grade 9, students will be able to:

• Use computer hardware, operating-system tools, files, browsers, accounts, and accessibility features safely and efficiently.

• Explain how computers represent and process text, numbers, images, sound, and other digital data.

• Describe how networks and the Internet use devices, protocols, requests, distributed systems, and fault tolerance to move information.

• Plan solutions with decomposition, abstraction, algorithms, pseudocode, and flowcharts.

• Write, run, read, and explain basic Python programs using variables, input/output, data types, conditionals, loops, lists, and functions.

• Test programs with normal, boundary, and unexpected inputs; identify and fix syntax, runtime, and logic errors.

• Compare algorithms, trace their steps, discuss efficiency, and reuse procedures or functions to manage complexity.

• Design, document, test, present, and improve a Python capstone that solves a defined problem.

• Typical course emphasis: Computational thinking, programming, data, the internet, cybersecurity, impacts of computing, and a student-designed project.

• Common pathways afterward: Web design, programming, AP Computer Science Principles, AP Computer Science A, cybersecurity, data science, or robotics etc

Materials and Software

• Student device Windows or Mac

• Python or JavaScript environment; optional HTML/CSS editor; spreadsheet and data-visualization tools.

• Edgenuity Course: 2025 – AP Computer Science Principles A

Learning outcomes and standards-aligned skills

The Digital World (Edgenuity: THE DIGITAL WORLD)

Device care, hardware, operating system, keyboarding, files/folders, browser basics

Explore binary, number and text representation, pixels, compression, and data.

• How Have Computers Changed Your Life?

• What Language Do Computers Talk?

• Strings You Cannot Tie

• When Numbers Do Not Behave

• Data: Music to Your Ears

• Breaking Images into Bits

• Data Compression

• Programming without Words

Computational thinking (Edgenuity: PROGRAMMING)

Decompose problems, recognize patterns, abstract relevant details, and design algorithms. Build programming concepts through: arithmetic, planning, writing and running programs, lists, data abstractions, input, event-driven programs, collaborative and iterative design, and project planning.

• Computer Arithmetic

• Planning Your Program

• Writing a Program

• What Happens When You Run a Program?

• Building Your Application

• Lists: The Everything Container

• Manipulating Lists

• Design as a Collaborative Process

• Data Abstractions —

• Getting Input

• Event-Driven Programs

• Design as an Iterative Process

Algorithms and programming (Edgenuity: CONTROLLING YOUR PROGRAM FLOW)

Use variables, data types, expressions, conditionals, loops, functions, events, testing, and debugging to build programs.

• When Errors Happen

• Testing Programs

• Manipulating Strings

• Relational Operators

• Logical Operators

• Conditionals

• Nested Conditionals

• Iteration

• Nested Loops

• While Loops

Hands-on Python programming

Students write code, run it, observe the results, explain what happened, and revise their programs. Begin with Python basics and concepts—print(), comments, variables, strings, integers, floats, booleans, arithmetic operators, assignment, input/output, type conversion, and indentation—then apply them through short coding tasks.

• Python practice sequence: greeting program, calculator, unit converter, mad-libs program, four-question quiz, and number-guessing game.

• Program flow: use Boolean expressions, comparison and logical operators, if/elif/else, nested conditionals, for loops, while loops, and nested loops.

• Data and organization: create and manipulate lists, use indexing and len(), define functions with parameters and return values, and separate input, processing, and output.

• Testing and debugging: predict output, test normal and edge cases, read syntax/runtime/logic errors, trace variables, fix one error at a time, and record the bug, cause, fix, and retest result.

Hands-on routine: predict → write a small program → run it → change one value → explain the result → test an edge case → save the code and output → reflect on the revision.

• Python basics: What can print() display? Write a program that prints your name, favorite subject, and a three-line message.

• Variables and assignment: How can a variable store information? Create name, age, and school variables and print a sentence using them.

• Strings: How can a program work with text? Ask for a first and last name, then print a greeting.

• Numbers and arithmetic: How can Python calculate an answer? Write a program that asks for two numbers and prints their sum, difference, product, and quotient.

• Booleans and comparisons: How can a program decide whether a statement is true? Ask for a person’s age and print whether they are 13 or older.

• Input and type conversion: Why must input sometimes be converted? Ask for the length and width of a rectangle, convert the answers to numbers, and calculate the area.

• Conditionals: How can a program choose between actions? Ask for a temperature and print whether the day is cold, mild, or hot.

• Nested conditionals: How can one decision depend on another? Create a password checker that first checks whether a password is long enough and then checks whether it matches a sample password.

• for loops: How can a loop repeat a known number of times? Print the numbers 1–10 and then print a multiplication table for a number chosen by the user.

• while loops: How can a program continue until a condition changes? Keep asking for a word until the user types quit.

• Nested loops: How can loops create repeated patterns? Print a 5-by-5 grid of stars or a simple number triangle.

• Lists and indexing: How can a program store many values? Create a list of three favorite foods, print the first item, and display the list length.

• List manipulation: How can a program add, remove, and search for items? Build a class-supplies list that lets the user add an item, remove an item, and check whether an item is present.

• Functions: How can a function organize repeated work? Define a function that converts miles to kilometers or calculates the area of a rectangle, then call it with different values.

• Testing: What inputs should be tested? Make a test table for a calculator or grading program using normal, boundary, and unexpected inputs.

• Debugging: How can an error be found and fixed? Use a program containing one syntax error, one runtime error, and one logic error; identify the error, fix it, and record the result. Finish with a choices program or number-guessing game that combines input, variables, conditionals, loops, lists, and functions.

Algorithms and programming (Edgenuity: CONTROLLING YOUR PROGRAM FLOW)

Algorithm comparison, search traces, list-manipulation code, procedure-call explanations, reusable-function project, and efficiency reflection.

• Comparing Algorithms

• Modifying Existing Algorithms

• List Operations

• Linear Searching

• Binary Search

• Calling Procedures

• Interpreting the Exam Procedure Call

• How Functions/Procedures Manage Complexity

• What's My Procedure?

• Sending Output

Data and analysis (Excel)

Collect, clean, visualize, interpret, and communicate findings from data while identifying bias and limitations.

• Data collection and ethics (Design a school-safe survey)

• Spreadsheets and data cleaning (Tables; formulas; missing data)

• Visualization and communication (Charts; patterns; misleading displays)

• Data investigation (Interpretation; limitations; claims)

Networks and systems (Edgenuity: THE INTERNET)

Explain basic internet protocols, addressing, packets, clients/servers, and reliability. Model networks, protocols, web requests, fault tolerance, distributed computing, and web growth. Create a labeled network diagram, trace a request, and explain a fault-tolerance scenario.

• Network Building Blocks

• Building a Network

• Network Protocols

• Where's My Web?

• Fault Tolerance

• How the Web Grows

• Parallel and Distributed Computing

• What Has Distributed Computing Done for You?

Cybersecurity (Videos)

Apply authentication, privacy, threat-modeling, safe browsing, and responsible security practices.

• Cybersecurity foundations (Threats; vulnerabilities; risk)

• Privacy and authentication (Password managers; MFA; data minimization)

• Defensive security (Phishing awareness; updates; backups)

• Ethics, law, and intellectual property (Copyright; licensing; attribution)

Impacts and digital citizenship

Evaluate accessibility, equity, intellectual property, privacy, automation/AI, and social impacts by covering:

• Digital citizenship and netiquette: Communicate respectfully online, think before posting, and follow the same rules of kindness and responsibility that you use in person.

• Digital footprints and online reputation: Understand that posts, photos, comments, and likes can leave a lasting record. Make choices online that represent you well.

• Media and information literacy: Check who created a claim, when it was published, and what evidence supports it. Learn how misinformation and deepfakes can make false information look real.

• Accessibility and inclusive design: Design technology that many different people can use, including people who use screen readers, captions, keyboard controls, or other assistive tools.

• Equity and the digital divide: Explore why some people have less access to devices, reliable internet, or technology classes, and how technology can be made fairer and more inclusive.

• Data privacy and consent: Learn what personal information is, why apps collect it, and how to make informed choices about sharing information and allowing tracking.

• Security and privacy tradeoffs: Consider how passwords, cameras, location services, and monitoring can improve safety while also affecting personal privacy.

• Copyright and attribution: Use other people’s writing, images, music, and code legally and honestly by checking permissions, giving credit, and avoiding plagiarism.

• Algorithmic bias and fairness: Discover how incomplete or unfair data can cause a computer system to treat some people differently. Ask whether a result is accurate and fair.

• Automation and artificial intelligence: Discuss how computers and AI can help people, change jobs, and make decisions. Learn why people should understand and check important computer-generated results.

• Social impacts of platforms: Examine how social media and games can affect attention, sleep, friendships, cyberbullying, and mental health. Practice setting healthy boundaries online.

• Responsible computing: Use an ethical decision-making process: identify the problem, consider who may be helped or harmed, compare choices, and explain your decision.

• Laws and school policies: Build basic awareness of rules that protect children’s and students’ information, including COPPA and FERPA, without needing to memorize legal details.

Collaboration and communication

• Versioning / change logs: Save versions such as v1 and v2, and note what changed and why.

• Peer feedback: Give and receive specific, kind, helpful comments; use a checklist to review a classmate’s work.

• Documentation: Add clear comments and a README explaining how to run the program, its inputs and outputs, and the sources you used.

• Presentations: Demonstrate the program, explain your design choices, and show a bug fix or test.

• Reflection: Describe what worked, what was difficult, and what you would improve next time.

Capstone

Choose a quiz, calculator, text adventure, data-summary program, or study utility. Plan, decompose, pseudocode, implement, test, debug, document, present, and submit the final code and portfolio.

• Capstone planning - Requirements; scope; milestones (Choose a community or school problem)

• Capstone build 1 - Implementation; collaboration; versioning (Build minimum viable artifact)

• Capstone build 2 - Data or media integration;

• Capstone build 3 - Testing; debugging; security (Test with rubric and revise)

• Capstone documentation

  • Readme; citations; design rationale

  • Prepare portfolio and demonstration

  • Capstone presentation rehearsal

  • Communication; peer critique

  • Demo day rehearsal

  • Capstone showcase

  • Presentation; questions; professional feedback

  • Showcase to class or invited audience

Capstone choices and rubric

• Menu-driven quiz with scoring and feedback.

• Calculator or unit-conversion tool with validation.

• Text adventure using functions, conditions, loops, and dictionaries.

• Data-summary program using a teacher-provided CSV or text file.

• Study or productivity utility using fictional/sample data.

Rubric: Functionality 30%; problem decomposition and code quality 25%; testing and debugging 20%; documentation and responsible data use 15%; presentation and reflection 10%.