Concept-based Approach to DP Computer Science
This framework emphasizes a gradual deepening of abstraction, moving from user-level experiences to hardware-level computation. It is structured as a concept-based progression, ensuring that students start with intuitive, real-world computing applications and gradually uncover the layers of abstraction down to binary logic, circuits, and computational limits.
By the end of the course, students will transition from "it just works" to "here's exactly how and why it works."
The Big Idea
Students often engage with technology without understanding why or how it works. This approach starts with computing as users perceive it—software interfaces, problem-solving applications, and real-world data—and progressively uncovers the foundational theories that make computing possible.
This framework ensures students develop both technical skills and a computational mindset by transitioning from applied computing to deep theoretical knowledge.
Conceptual Lenses
Each paradigm represents a shift in abstraction, leading students deeper into computing principles. While presented in a sequence, these areas naturally overlap and reinforce prior learning.
| Paradigm | Scope | Description | The Big Questions |
|---|---|---|---|
| Computing as Problem-Solving (CPS) | User-level, applied computing | Students engage in computational problem-solving with real-world programming, focusing on how computing helps solve problems. | How do we design algorithms that solve problems? What makes a solution efficient? |
| Data, Information, and Representation (DIR) | Understanding how computers store and process data | Explores how computers represent numbers, text, images, and structures in binary, moving from user-experienced data to its fundamental storage. | How does a computer "understand" data? What are the trade-offs in encoding and storing information? |
| Systems and Computation (SC) | Operating systems, compilers, memory, and architecture | Students move from software to hardware structures, learning how system components execute computations. | How does software interact with hardware? What happens when we run a program? |
| Logic and Computational Foundations (LCF) | Formal models, Boolean logic, digital circuits | Introduces theoretical computation—the math and logic that define computing. | What is the fundamental nature of computation? How do we design circuits that perform calculations? |
| Computation, Efficiency, and Complexity (CEC) | Theoretical limits of computing | Analyzes computational feasibility, big-O notation, algorithmic efficiency, and the limits of what computers can do. | What can be computed, and what are the limits of computation? How do we optimize performance? |
| Future Frontiers & Ethical Implications (FEI) | AI, cybersecurity, cryptography, and ethics | Explores emerging fields with a focus on theoretical underpinnings and ethical responsibilities in computing. | How do we ensure responsible technological progress? What ethical dilemmas arise in computing? |
Order of Concepts: From Tangible to Abstract
The curriculum moves from user-experience computing to computational theory:
- CPS - Computing as Problem-Solving (Practical programming and algorithmic problem-solving)
- DIR - Data, Information, and Representation (Binary, data encoding, and storage)
- SC - Systems and Computation (Operating systems, memory, hardware interaction)
- LCF - Logic and Computational Foundations (Boolean logic, circuits, computation theory)
- CEC - Computation, Efficiency, and Complexity (Optimization, performance, theoretical limits)
- FEI - Future Frontiers & Ethical Implications (AI, cybersecurity, philosophy of computing)
For Students
Understanding the Big Picture
Computer Science is not just about writing code—it’s about how computers solve problems, how data is stored and processed, how systems operate, and the limits of computation. This course will guide you through six conceptual lenses, each representing a new level of understanding, from hands-on problem-solving to deep computational theory.
Each lens will help you think like a computer scientist, making connections between coding, data, systems, logic, efficiency, and the real-world impact of technology.
Why These Lenses Matter
Each lens builds on the previous one:
- First, you’ll learn how to solve problems with code (CPS).
- Then, you’ll explore how computers store and process data (DIR).
- You’ll dive into how computer systems execute programs (SC).
- You’ll analyze how computation works at its core, using logic and circuits (LCF).
- You’ll study how efficient computation is, and what computers can’t do (CEC).
- Finally, you’ll think critically about computing’s future and its ethical impact (FEI).
This structure gradually deepens your understanding, preparing you for advanced computing topics and real-world applications.
For Teachers
The Pedagogical Approach
This framework provides a structured, inquiry-driven approach to teaching computer science, ensuring students develop both technical skills and computational thinking. The conceptual lenses serve as progressive layers of abstraction, allowing students to move from practical applications to theoretical computing concepts.
This approach is designed to:
- Build abstraction progressively – Students start with coding and problem-solving before moving into deep theoretical topics.
- Encourage interdisciplinary thinking – Connecting computing with ethics, security, AI, and real-world applications.
- Reinforce learning through cycles – Revisiting key concepts in different contexts to solidify understanding.
Mapping to the Two-Year Scope and Sequence
| Conceptual Lens | Year & Semester | Key Topics | Teaching Approach |
|---|---|---|---|
| Computing as Problem-Solving (CPS) | Year 1, Semester 1 | Algorithm design, programming, debugging, decomposition, recursion | Hands-on programming, peer programming, problem-solving challenges |
| Data, Information, and Representation (DIR) | Year 1, Semester 1 & 2 | Binary encoding, compression, encryption, relational databases, SQL | Interactive simulations, database projects, encoding exercises |
| Systems and Computation (SC) | Year 1, Semester 2 | Operating systems, cloud computing, virtualization, compilers | OS simulations, cloud deployments, security exercises |
| Logic and Computational Foundations (LCF) | Year 1, Semester 2 | Boolean logic, truth tables, circuit design, logic gates | Digital circuit building, peer teaching, hands-on logic exercises |
| Computation, Efficiency, and Complexity (CEC) | Year 2, Semester 1 | Big-O notation, algorithm efficiency, Turing machines, theoretical limits | Algorithm analysis, efficiency experiments, complexity scavenger hunts |
| Future Frontiers & Ethical Implications (FEI) | Year 2, Semester 1 & 2 | Machine learning, cryptography, cybersecurity, AI ethics | AI experiments, ethical debates, real-world case studies |
Classroom Strategies
- Concept Spiral: Concepts are revisited multiple times across different levels, reinforcing learning. Example:
- Sorting algorithms appear in CPS (hands-on programming) and again in CEC (efficiency analysis).
- Boolean logic appears in LCF (logic gates) and later in SC (hardware architecture).
- Bridging Activities: Each lens has activities that connect new topics to prior learning. Example:
- After learning binary representation (DIR), students explore how compression and encryption work (FEI).
- After studying Turing machines (CEC), students discuss the ethical implications of AI automation (FEI).
- Interdisciplinary Approach: The Future Frontiers & Ethical Implications (FEI) lens integrates discussions on policy, ethics, and real-world computing impacts.
The Role of the Internal Assessment (IA)
The IA is introduced in Year 1, Semester 2 and completed in Year 2, Semester 1:
- Year 1, Semester 2:
- Students identify a concept they would to explore deeply
- They learn about their topic deeply and begin creating a computational artifact
- Year 2, Semester 1:
- Students implement, test, debug, and refine their projects.
- They finalize their IA submission to IB.
This structured IA approach ensures that students apply computational thinking, programming, and problem-solving to a meaningful, long-term project.