ICS4U enables students to further develop their knowledge and skills in computer science. Students will use modular design principles to create complex and fully documented programs, according to industry standards. Student teams will manage a large software-development project, from planning through to project review. Students will also analyse algorithms for effectiveness, will study emerging issues related to computer science (such as the impact of artificial intelligence and the environmental footprint of computing), and will investigate ethics, privacy, and post-secondary opportunities in computer-related fields.
Recommended Prerequisite: ICS3U Introduction to Computer Science, Grade 11, University Preparation. Students entering directly with strong math (MCR3U) but no prior programming will need a brief Python primer in Unit 1.
2. Big Ideas
Algorithms and abstraction: A computer program is a precise expression of an algorithm; effective programs are organized through layers of abstraction.
Data structures: The choice of data structure (array, dictionary, record, class) shapes which operations are efficient and which are not.
Modularity and reuse: Large programs are built from small, well-tested, well-named pieces; modularity is the foundation of maintainability.
Algorithmic efficiency: Two correct algorithms can differ in running time by orders of magnitude — analysis (Big-O) lets us compare them before measuring.
Software engineering as a discipline: Coding is a small part of software development; testing, debugging, version control, communication, and ethics are equally important.
Computing in society: Software shapes the world — with great capability comes responsibility for privacy, accessibility, equity, and the environment.
3. Fundamental Concepts
Concept
Description
Abstraction
Hiding implementation details behind a clear interface (functions, classes, modules).
Decomposition
Breaking a problem into smaller, independently-solvable subproblems.
Pattern recognition
Recognizing recurring structures (search, sort, accumulator, recursion) and reusing standard solutions.
Algorithm design
Describing a step-by-step process that always terminates with a correct answer.
Data & representation
How information is encoded (binary, types, structures) and the consequences of those choices.
Systems & interactions
Components (hardware, OS, network, user) interact via defined contracts; failures arise at the seams.
4. Strand A — Programming Concepts and Skills
A1. Demonstrate the ability to use different data types and data structures (e.g., one-dimensional arrays/lists, multi-dimensional arrays, records, classes, dictionaries) in computer programs.
A2. Demonstrate the ability to use modular programming concepts and techniques in computer programs (procedures, functions, parameter passing, return values, recursion).
A3. Use proper code-maintenance techniques and conventions (commenting, indentation, naming) when creating computer programs, and design and analyse simple algorithms in terms of correctness and efficiency.
Specific Expectations (selected)
A1.1 Demonstrate the ability to declare, initialize, modify, and access primitive types (integer, real/float, character/string, Boolean) in computer programs.
A1.2 Use one-dimensional arrays/lists in computer programs to store, retrieve, and update structured data.
A1.3 Use multi-dimensional arrays/lists (two-dimensional minimum) to model grid-like data (e.g., a tic-tac-toe board, an image, a seating chart).
A1.4 Use records or classes to represent compound data with named fields (e.g., a Student record with name, id, grades).
A2.1 Use existing language libraries (modules) and write functions/procedures that solve well-defined sub-problems.
A2.2 Use parameters (positional, keyword, default) and return values appropriately, distinguishing pass-by-value from pass-by-reference behavior.
A2.3 Apply recursion to problems that can be expressed in terms of a smaller version of themselves (factorial, Fibonacci, divide-and-conquer search and sort), correctly identifying base and recursive cases.
A3.1 Demonstrate the ability to write code that follows accepted style conventions (PEP 8 for Python; Java conventions where Java is used).
A3.2 Analyse the efficiency of an algorithm by counting basic operations and expressing growth using Big-O notation (O(1), O(log n), O(n), O(n log n), O(n²)).
5. Strand B — Software Development
B1. Use a variety of problem-solving strategies (top-down design, bottom-up implementation, modular design) to solve problems at the design stage of software development.
B2. Apply standard programming techniques and conventions to create computer programs that are readable, maintainable, and efficient.
B3. Apply standard algorithms (linear search, binary search, bubble sort, insertion sort, selection sort, merge sort, quicksort) to solve problems.
B4. Use systematic testing & debugging strategies to verify program correctness and identify the location and cause of errors.
Specific Expectations (selected)
B1.1 Apply top-down design (stepwise refinement) to a problem of moderate complexity, producing a hierarchical structure chart.
B1.3 Use UML-style or comparable notation to describe the relationships between classes/modules in a planned program.
B2.1 Use comments, meaningful variable names, consistent indentation, and helper functions to produce maintainable code.
B2.4 Use a version-control tool (e.g., Git) to track changes and collaborate on a programming project.
B3.1 Implement and trace linear search and binary search; explain the precondition (sorted input) for binary search.
B3.2 Implement and trace bubble, insertion, and selection sort; show their O(n²) behavior on test data.
B3.3 Implement and trace merge sort and quicksort; explain the divide-and-conquer principle and average vs. worst-case complexity.
B4.1 Use a debugger and/or print-statement tracing to locate the cause of a runtime or logic error.
B4.2 Design test cases including normal inputs, boundary inputs, and invalid inputs; document expected vs. actual results.
6. Strand C — Designing Modular Programs
C1. Demonstrate the ability to use modular structure (functions, classes, modules) to plan and code complex programs.
C2. Maintain and extend existing code, including code written by others, using accepted conventions and tools.
C3. Use abstraction (procedural and data) to manage complexity in problem-solving and program design.
Specific Expectations (selected)
C1.1 Decompose a problem into modules with single responsibilities; identify the inputs, outputs, and side-effects of each module.
C1.2 Design a class with appropriate attributes and methods to model a real-world entity; use encapsulation to protect internal state.
C2.1 Read and understand a peer's code (or unfamiliar legacy code) and add a feature or fix a bug without breaking existing behavior (regression testing).
C2.2 Refactor a working program to improve readability or efficiency without changing observable behavior.
C3.1 Choose an appropriate data structure (list, dictionary, class) for a given problem and justify the choice.
C3.2 Use a procedural abstraction (a single function name) to hide a complex multi-step computation from the rest of the program.
7. Strand D — Topics in Computer Science
D1. Describe key emerging areas of computer science (artificial intelligence, machine learning, quantum computing, cloud computing, cybersecurity).
D2. Analyse environmental and ethical issues related to the use of computers (energy footprint of data centres & AI training, e-waste, privacy, algorithmic bias, intellectual property, accessibility).
D3. Describe postsecondary education and career opportunities related to computer studies, including in Ontario and Canada.
D4. Describe key contributions to the history and development of computer science, including contributions by Canadian innovators.
D1.2 Describe what a qubit is and one situation where quantum computing would offer an advantage over classical computing.
D2.1 Estimate the energy footprint of a typical software-related activity (e.g., training a model, streaming a video) and discuss mitigation strategies.
D2.2 Identify a real-world example of algorithmic bias and propose mitigations.
D2.3 Distinguish open-source, free, and proprietary software licensing models, and describe ethical responsibilities of programmers.
D3.1 Identify at least three university programs and three college programs in Ontario related to computer science, and three career roles a graduate may pursue.
D4.1 Identify at least three landmark contributions to computing (e.g., Babbage, Lovelace, Turing, Hopper, von Neumann; Canadian: Stephen Cook, Geoffrey Hinton, Yoshua Bengio, Maurice Wilkes’ collaboration with Calgary, the Avro Arrow's airborne computer).
8. Programming Languages & Environments
The Ontario curriculum is language-agnostic. The most common choices in Ontario boards are Python and Java. This MindView build defaults to Python for accessibility and reading clarity, with Java parallel examples added where appropriate.
Language
Strengths
Trade-offs
Python 3.x (default)
Readable syntax close to pseudocode; rich standard library; excellent for data structures, algorithms, AI demos.
Dynamic typing makes some bugs harder to catch at compile time; slower than compiled languages.
Java
Static typing makes types & interfaces explicit; aligns with university CS1; widely used in industry.
More verbose; setup of main, classes, types adds friction for early learners.
Recommended Tooling
Editor/IDE: VS Code (free, cross-platform), Thonny (beginner-friendly Python), IntelliJ IDEA (Java).
Version control: Git, with a GitHub or GitLab account for student portfolios.
Testing: Python unittest or pytest; Java JUnit.
Browser-only fallback: repl.it, Trinket, or Google Colab for students without local install rights.
# A complete Python program: read a CSV, sort by mark, write top-3 to fileimport csv
with open("roster.csv") as f:
rows = sorted(csv.reader(f), key=lambda r: -int(r[1]))
with open("top3.csv", "w", newline="") as f:
csv.writer(f).writerows(rows[:3])
9. STSE Connections & Career Pathways
Sample STSE Topics (Strand D)
Privacy & surveillance — facial recognition, location tracking, data brokers.
Algorithmic bias in hiring, lending, and criminal-justice tools.
Energy footprint of large-language-model training; environmental cost of cryptocurrency mining.
Accessibility — WCAG-compliant interfaces; assistive technologies for visually-impaired or motor-impaired users.
Open-source ecosystems and the contribution model (Linux, Python, Wikipedia).
Cybersecurity & ethical hacking — the role of disclosure programs.
Career Pathways
Software engineering, data science, machine-learning engineering, cybersecurity analyst, cloud architect, mobile/web developer, embedded systems / robotics, game design, UX/UI design, devops, technical writing, computing teacher, CS researcher (M.Sc./Ph.D.). Adjacent quantitative careers include actuarial science, financial engineering, bioinformatics, and computational science.
Sample Ontario Postsecondary Pathways
Universities: Computer Science, Software Engineering, Computer Engineering — e.g., U of Waterloo, U of Toronto, McMaster, Western, Queens, Carleton, York, Ottawa.
Colleges: Computer Programmer / Programmer-Analyst, Game Development, Cybersecurity, Mobile Development — e.g., Seneca, Centennial, Sheridan, Algonquin, Conestoga.
10. Ontario Achievement Chart for ICS4U
K/U 25%
Thinking 25%
Communication 25%
Application 25%
Category
Description
Examples in ICS4U
Knowledge & Understanding
Recall of facts, terms, definitions; understanding of programming constructs, data structures, and standard algorithms.
Define recursion; identify the precondition for binary search; state the average-case complexity of merge sort.
Thinking & Investigation
Use of critical and creative thinking processes — algorithm design, debugging, problem-solving with constraints.
Design an algorithm given a novel problem; trace and fix a buggy recursive function; choose between two data structures and justify.
Communication
Conveying meaning through code (style, comments, naming) and through written/spoken language about programs.
Well-commented code; clear docstrings; an STSE position paper; technical explanation to a peer.
Application
Use of programming knowledge in familiar and unfamiliar contexts; transfer of skills.
Build a roster manager from scratch; extend legacy code; apply Big-O analysis to estimate the running time of an unknown function.
11. Evaluation Policy (Growing Success, 2010)
Component
Weight
Description
Term Work
70%
Unit tests, programming assignments, code reviews, lab worksheets, quizzes — balanced across the four achievement categories.
Final Evaluation
30%
Cumulative final exam (worth ~20%) and a final culminating capstone software project (~10%). Together capped at 30%.
Assessment Types
ASAssessment AS Learning: self-directed practice quizzes — student uses results to plan study; not graded.
FORAssessment FOR Learning: teacher diagnostics — descriptive feedback only, not graded.
OFAssessment OF Learning: summative unit tests, programming assignments, capstone, and final exam — counted toward final grade.
Levels of Achievement: Level 4 (80–100%, thorough and insightful), Level 3 (70–79%, considerable effectiveness — provincial standard), Level 2 (60–69%), Level 1 (50–59%), R (below 50%, insufficient).
Learning Skills & Work Habits (reported separately)
Responsibility, Organization, Independent Work, Collaboration, Initiative, Self-Regulation — each rated E (Excellent) / G (Good) / S (Satisfactory) / N (Needs Improvement). Collaboration and Self-Regulation are particularly visible in the term-long capstone project.