Skip to content

What does a student learn in ?

This is the year computer use turns into computer building. Students write real programs, break big problems into smaller pieces, and test their code until it works the way they meant it to. They also look at data sets and pull out patterns, and they weigh the ethical side of tech choices like privacy, security, and bias. By spring, students can plan, build, and explain a working program or data project they made themselves.

  • Coding and programs
  • Problem solving
  • Working with data
  • Networks and the internet
  • Ethics in tech
  • Testing and debugging
Source: Pennsylvania Pennsylvania Core Standards
Year at a glance
How the year usually goes. Every school and district set their own curriculum, so treat this as a guide, not official pacing.
  1. 1

    Computers, networks, and safe use

    Students start the year by looking at how computers and the internet actually work. They learn how devices connect, how data moves across a network, and what keeps accounts and private information safe.

  2. 2

    Working with data

    Students gather real data, clean it up, and turn it into charts and tables. They use that work to spot patterns and back up a claim with evidence instead of a guess.

  3. 3

    Writing programs and algorithms

    Students plan and write programs that solve a problem or automate a task. They break big problems into smaller steps, reuse pieces of code, and trace through their logic to see what the computer will do.

  4. 4

    Building and testing a project

    Students take a project from idea to finished version. They sketch a plan, build it in rounds, test it on real users, and use the feedback to fix bugs and make it easier to use.

  5. 5

    Computing and society

    Students look at how technology shapes daily life, from privacy and bias to jobs and access. They weigh the trade-offs of a tool or app and explain their thinking with clear examples.

Mastery Learning Standards
The required skills a student should display by the end of Grade 11.
Concepts
  • Identify, select, and apply hardware, software

    High School

    Students learn to pick the right tools for a job, whether that means choosing software, setting up hardware, or figuring out why something stopped working. The focus is on solving real computing problems, not just knowing what the parts are called.

  • Explain how computer networks and the Internet enable communication…

    High School

    Students learn how data travels across networks and the Internet, including how devices connect, how people communicate and share files, and how security measures protect information in transit.

  • Collect, transform, and represent data

    High School

    Students gather raw data, clean or reshape it, and display it in charts or tables. Then they use software or code to spot patterns and back up a conclusion with numbers.

  • Design, develop, and analyze algorithms and programs to solve problems…

    High School

    Students write and test programs that solve real problems or automate repetitive tasks. They also review their own code to figure out why it works, where it breaks, and how to make it faster.

  • Investigate the social, ethical, legal

    High School

    Students examine how technology shapes everyday life, from privacy and data use to laws and global inequality. They look at real cases where software or algorithms affected people and weigh the tradeoffs involved.

Practices
  • Foster an inclusive computing culture that values diverse perspectives and…

    High School

    Students learn to build teams and projects that welcome people from different backgrounds. The goal is computing work that's stronger because more kinds of thinkers are in the room.

  • Collaborate around computing — divide work, share ideas

    High School

    Students split a project into parts, share ideas with teammates, and fold in feedback to build a working program, app, or other digital product together.

  • Identify and define problems that can be solved with computation and decompose…

    High School

    Students look at a real problem, decide whether a computer can help solve it, and break it into smaller pieces a program can handle one step at a time.

  • Use abstractions to simplify complexity, generalise solutions

    High School

    Students take a complicated program or system and find the repeating patterns inside it, then write rules or reusable pieces that handle many cases at once instead of solving each one separately.

  • Create computational artifacts — programs, simulations, models — by applying…

    High School

    Students build working programs or simulations by writing, testing, and revising their code in repeated cycles until the project does what they intended.

  • Systematically test computational artifacts and refine them based on evidence…

    High School

    Students run planned tests on programs or apps they've built, then fix what doesn't work based on what the tests reveal. The goal is code that does what it's supposed to do and is easy for others to use.

  • Communicate clearly with appropriate vocabulary, visualizations

    High School

    Students explain how a program works or why a tech decision matters, using the right words, charts, or data to back up their point. Clear communication is part of the work, not an afterthought.

Common Questions
  • What should students be able to do in computer science by the end of high school?

    Students should be able to write a working program, pull useful information out of a set of data, and explain how the internet moves and protects that data. They should also be able to talk about the real-world effects of the technology they build and use.

  • My child has never coded before. Are they behind?

    No. Plenty of students start coding for the first time in high school and do fine. Free sites like Code.org or a simple Python tutorial give a good first taste. Thirty minutes a week at home is enough to build confidence before the next assignment.

  • How can families help at home if coding is not their background?

    Ask students to explain what their program is supposed to do, then have them walk through it line by line. Talking it out catches most bugs. Parents do not need to know the language to ask good questions about what the code is doing and why.

  • How should the year be sequenced across the five concept areas?

    A common path starts with hardware and networks for context, then moves into programming basics, then data, and closes with larger projects that pull in ethics and impact. Threading collaboration and testing practices through every unit works better than saving them for the end.

  • Which skills usually need the most reteaching?

    Decomposition and debugging. Students can often write short programs but stall when a problem has more than two or three parts, or when their code runs but gives the wrong answer. Short, repeated practice with reading code and tracing it by hand pays off all year.

  • How much screen time does this subject add at home?

    Most coursework happens in class. Homework is usually finishing a program, writing a short reflection, or reading about a tech topic in the news. If a project runs long, students can sketch logic on paper before getting back on a computer.

  • What does a strong end-of-year project look like?

    A project where students picked a real problem, broke it into parts, built something that works, tested it with other people, and can explain the trade-offs they made. The artifact matters less than the student's ability to walk through their decisions.

  • How is this different from just learning to code?

    Coding is one piece. Students also learn how networks move data, how to work with information sets, how to collaborate on a build, and how to think about who a piece of software helps or harms. The goal is informed users and makers, not only programmers.

  • How do teachers know a student is ready for a college course or a CS pathway?

    Readiness shows up in three places: writing a program from a plain-language problem statement, debugging without giving up, and explaining the work to someone else. Students who can do those things across a few different projects are in good shape for what comes next.