IIER / SUP / 01
Java for teens
For finals written in Java.
Open the syllabusOntario · Grades 11 and 12 · Final exam review
Revision pays off most when it is done against a real paper, marked honestly. So we wrote two: a 50-mark ICS3U mock and a 40-mark ICS4U mock, each with every answer and a marking guide that shows where the marks go. Neither is any school’s exam, and neither predicts what yours will contain; your teacher’s outline does that. Both are built on the achievement chart in the Ontario curriculum, so the practice covers all four categories a teacher assesses. We get students ready for the school’s exam, but we do not grant Ontario credits; the exam and the credit belong to the school.
Live online since 2020 · 10,000+ students · Exam practice in Python or Java
What this page gives you
ICS3U and ICS4U exam review for Ontario Grade 11 and 12 computer science: an original 50-mark ICS3U mock exam and a 40-mark ICS4U mock, with answers and a marking guide sorted by the four achievement chart categories. Modern Age Coders runs live online exam practice, for a group or one student, through Ontario Computer Science Companion: ICS3U and ICS4U.
Exam preparation with a teacher
The companion course builds exam practice into its last weeks. The other two strengthen the two areas these mocks test most.

IIER / 01
Timed mocks marked against the school’s own outline, for ICS3U and ICS4U, in Python or Java.
Open the syllabus →
IIER / 02
Tracing, functions and lists until the written questions feel routine.
Open the syllabus →
IIER / 03
Searches, sorts, recursion and classes, the ICS4U half of these mocks.
Open the syllabus →How the mark is built
Before practising, it helps to know what a teacher is looking for. The 2008 Computer Studies curriculum sets the rules every Ontario school follows, and two parts of it matter most at exam time: how the final grade splits, and the four categories on the achievement chart.
Most of the grade, 70 per cent of it, is earned before the final, from work evaluated during the course. The curriculum adds that this part “should reflect the student’s most consistent level of achievement throughout the course, although special consideration should be given to more recent evidence of achievement.”
The remaining 30 per cent comes from a final evaluation near the end of the course, which the document allows to be an examination, a performance, an essay or another method that suits the course. In computer science that is often a written exam, a coding task, a project or a combination; your teacher decides.
The achievement chart ends with a plain rule: “A student whose achievement is below 50% at the end of a course will not obtain a credit for the course.” Each level on the chart has a percentage band: 50 to 59 for level 1, 60 to 69 for level 2, 70 to 79 for level 3 and 80 to 100 for level 4.
Level 3 is called the “provincial standard”, and the document is reassuring about it: “Parents of students achieving at level 3 can be confident that their children will be prepared for work in subsequent courses.”
| Category | The curriculum’s definition | On a computer science exam (ours) |
|---|---|---|
| Knowledge and Understanding | “Subject-specific content acquired in each course (knowledge), and the comprehension of its meaning and significance (understanding)” | Vocabulary, error types, what a line of code does, number systems |
| Thinking | “The use of critical and creative thinking skills and/or processes” | Tracing, finding and fixing a bug, choosing test cases; the chart names “detecting and correcting flaws” |
| Communication | “The conveying of meaning through various forms.” | Explaining a concept in sentences, pseudocode, clear names and comments |
| Application | “The use of knowledge and skills to make connections within and between various contexts.” | Writing working code for a task you have not seen in exactly that form |
The chart describes each level with one qualifier, used the same way in every category: “limited for level 1, some for level 2, considerable for level 3, and a high degree or thorough for level 4”. A level 4 trace is not a longer trace; it is one done with a high degree of effectiveness.
The document also corrects a common belief: level 4 “does not mean that the student has achieved expectations beyond those specified for a particular course”. Top marks come from doing the course’s own work very well, not from extra topics.
The curriculum tells teachers to assess “in a balanced manner with respect to the four categories”. Students tend to revise only Application, which means writing code, and then lose marks on a written explanation or a trace.
So every question in our two mocks is tagged with one category, and the marking guides total the marks by category. A student can see at a glance whether the weak spot is knowing, thinking, explaining or doing.
Source: The Ontario Curriculum, Grades 10 to 12: Computer Studies (2008), sections on the achievement chart and on evaluation and reporting, read 22 October 2026. The percentage bands are paraphrased from the chart’s column headings. No ministry or school board has any part in these mocks.
The two papers at a glance
Both mocks are ours. Each question below is tied to a specific expectation code in the 2008 curriculum, so a student who misses a question knows exactly which part of the course to revisit.
| Q | Topic | ICS3U expectation | Category | Marks |
|---|---|---|---|---|
| 1 | Name three errors | A4.1 | Knowledge and Understanding | 3 |
| 2 | A range that counts down | A2.2 | Knowledge and Understanding | 2 |
| 3 | Integer division and remainder | A1.4 | Knowledge and Understanding | 3 |
| 4 | Binary and hexadecimal | A1.2 | Knowledge and Understanding | 2 |
| 5 | Parameter and return value | A3.2 | Knowledge and Understanding | 2 |
| 6 | Trace a nested loop | A4.4 | Thinking | 4 |
| 7 | Find and fix a logic error | A4.1 | Thinking | 4 |
| 8 | Choose test cases | B4.4 | Thinking | 4 |
| 9 | Write count_vowels | A3.2 | Application | 5 |
| 10 | Average and count above it | A2.3 | Application | 8 |
| 11 | Write a linear search | A2.3 | Application | 5 |
| 12 | Compiler and interpreter | C3.4 | Communication | 4 |
| 13 | Pseudocode before code | B2.4 | Communication | 4 |
| Q | Topic | ICS4U expectation | Category | Marks |
|---|---|---|---|---|
| 1 | Trace a recursive power method | A3.6 | Thinking | 4 |
| 2 | Count the comparisons in selection sort | C2.3 | Knowledge and Understanding | 4 |
| 3 | Trace binary search | A3.2, C2.2 | Thinking | 4 |
| 4 | Write a Clock class | A2.2, C1.2 | Application | 10 |
| 5 | Column totals in a grid | A3.5 | Application | 6 |
| 6 | Three kinds of testing | A4.2 | Communication | 6 |
| 7 | A negative exponent | C2.4, A1.1 | Thinking | 6 |
ICS3U, 50 marks: Knowledge and Understanding 12, Thinking 12, Application 18, Communication 8. ICS4U, 40 marks: Knowledge and Understanding 4, Thinking 14, Application 16, Communication 6.
The ICS4U paper leans on Thinking because Grade 12 adds recursion and algorithm analysis, both of which are reasoning before they are code. Your school’s split may differ; ask the teacher how the final is weighted.
Sit each one in one go, on paper, with no notes and no computer: 75 minutes for ICS3U and 60 for ICS4U. Write code by hand where a question asks for code. Mark it with the guide only after the time is up.
Both papers use Python for most code. Where a question gives Java, read it as Java; where it asks you to write code, use whichever language your class uses.
Mock exam one, ours
Written by our teachers for this page, at the level of a Grade 11 final. It is not taken from any school, board or past exam. Answer every question before opening the marking guide below it.
Section 1: Knowledge and Understanding (12 marks)
print("hello" with the closing bracket missing; (b) a program meant to average four numbers divides their total by 3; (c) a program reads nums[5] from a list of five numbers.for k in range(10, 0, -3):
print(k, end=" ")System.out.println(17 / 5 + " " + 17 % 5 + " " + 17.0 / 5);
Section 2: Thinking (12 marks)
Question 6 (4 marks). Trace the program below and write exactly what it prints.
rows = 4
for r in range(1, rows + 1):
line = ""
for c in range(r):
line = line + str(c + 1)
print(line)Question 7 (4 marks). This Java code should print the average of the three marks, about 81.67, but prints 81.0. Explain why, name the kind of error, and fix it.
int[] marks = {70, 85, 90};
int total = 0;
for (int m : marks) total += m;
double average = total / marks.length;
System.out.println(average);Question 8 (4 marks). Choose four years to test the function below. For each, give the expected result and say what the test checks. Do not run it.
def is_leap_year(year):
if year % 400 == 0:
return True
if year % 100 == 0:
return False
return year % 4 == 0Section 3: Application (18 marks)
Question 9 (5 marks). Write a function count_vowels(word) that returns how many of a, e, i, o, u appear in a word, in upper or lower case.
Question 10 (8 marks). Store these five temperatures in an array or list: -3, 4, 11, -8, 6. Print their average, then print how many are above the average. Do not use a built-in average function.
Question 11 (5 marks). Write linear_search(values, target) that returns the index of the first value equal to target, or -1 if there is none.
Section 4: Communication (8 marks)
Question 12 (4 marks). In three or four sentences, explain the difference between a compiler and an interpreter, and say which one your class language uses.
Question 13 (4 marks). Write the pseudocode you would plan before coding Question 10. Use numbered steps and clear names.
Marking guide, ours
Mark honestly, and give part marks only where the guide does. Every program was run in Python 3.13 or Java 22 to confirm the values.
| Q | Full-mark answer | Where the marks go |
|---|---|---|
| 1 | (a) syntax error; (b) logic error; (c) run-time error | One mark each. Logic means it runs but gives a wrong answer; run-time means it stops while running |
| 2 | 10 7 4 1 | One mark for starting at 10 and stepping by -3, one for stopping before 0 |
| 3 | 3 2 3.4 | One mark per part: int division, the remainder, then decimal division because 17.0 is a double |
| 4 | 45 in decimal, 2D in hexadecimal | 32 + 8 + 4 + 1 = 45; 45 is 2 sixteens and 13, and 13 is D. One mark each |
| 5 | A parameter is a value a function receives when it is called; a return value is the value it sends back | One mark each; an example earns the mark if the sentence is vague |
| 6 | Four lines: 1, 12, 123, 1234 | One mark per correct line. The inner loop runs r times on row r |
| 7 | total / marks.length divides two ints, so 245 / 3 is 81 before it becomes a double. Logic error. Fix: (double) total / marks.length, which prints 81.66666666666667 | One for the cause, one for naming a logic error, two for a working fix |
| 8 | 2024 True (divisible by 4); 2023 False (not divisible by 4); 1900 False (divisible by 100 but not 400); 2000 True (divisible by 400) | One mark per year with its reason. Missing 1900 or 2000 means the century rules were never tested |
| 9 | See the code below. Saskatchewan gives 4 and rhythm gives 0 | Two for the loop, one for the vowel test, one for handling capitals, one for returning rather than printing |
| 10 | Average 2.0, and 3 values above it (4, 11 and 6) | Two for storing the values, two for the total, one for the average, two for the second loop, one for both outputs |
| 11 | See the code below. [4, 9, 2, 9] with target 9 gives 1; target 7 gives -1 | Two for the loop, one for returning the index at the first match, two for returning -1 only after the loop ends |
| 12 | A compiler translates the whole program before it runs; an interpreter translates and runs it line by line. Java is compiled to bytecode first; Python runs through an interpreter | One for each definition, one for a correct example, one for clear sentences |
| 13 | Numbered steps: store the five values; set total to 0; add each value; average is total divided by the count; set above to 0; for each value, if it is greater than the average add 1; print both | Two for the right steps in order, two for clarity a classmate could code from |
def count_vowels(word):
count = 0
for ch in word.lower():
if ch in "aeiou":
count += 1
return count
print(count_vowels("Saskatchewan")) # 4
print(count_vowels("rhythm")) # 0double[] temps = {-3, 4, 11, -8, 6};
double sum = 0;
for (int i = 0; i < temps.length; i++) {
sum += temps[i];
}
double avg = sum / temps.length;
int above = 0;
for (int i = 0; i < temps.length; i++) {
if (temps[i] > avg) {
above++;
}
}
System.out.println(avg + " " + above); // 2.0 3def linear_search(values, target):
for i in range(len(values)):
if values[i] == target:
return i # the first match wins
return -1 # checked everything: not there
print(linear_search([4, 9, 2, 9], 9)) # 1
print(linear_search([4, 9, 2, 9], 7)) # -1A common mistake is an else: return -1 inside the loop. That returns after checking only the first value, so linear_search([4, 9, 2, 9], 9) would wrongly give -1.
Total your marks by section as well as overall. A student with 16 of 18 in Application but 4 of 12 in Thinking needs tracing practice, not more coding, even though the total looks fine.
Questions 7 and 8 are the ones most students drop marks on. Both reward slowing down: working out what a line really does, and choosing tests at the edges rather than in the middle.
Knowledge and Understanding: make flash cards for error types, operators and number systems. Thinking: trace three short programs a day on paper. Application: rewrite questions 9 to 11 from a blank file, then change the task slightly and write them again.
Communication: explain one concept a day out loud in four sentences, then write it down. Pseudocode improves fastest when someone else tries to follow yours.
Mock exam two, ours
Written by our teachers for this page, at the level of a Grade 12 final. Like the first mock, it is ours alone and not drawn from any school’s exam. Questions 1 and 7 use the same recursive method below.
def power(base, exp):
if exp == 0:
return 1
half = power(base, exp // 2)
if exp % 2 == 0:
return half * half
return half * half * basevals = [3, 8, 12, 15, 21, 26, 30, 34, 41, 47, 52, 58, 63, 70, 77] # binary search with lo = 0, hi = 14, mid = (lo + hi) // 2
grid = [[2, 7, 1, 8],
[2, 8, 1, 8],
[4, 5, 9, 0]]Marking guide, ours
The same rules: mark only after the full 60 minutes, and give part marks only as the guide allows. All values were checked by running the code.
| Q | Full-mark answer | Where the marks go |
|---|---|---|
| 1 | It returns 1024, in 5 calls: exponents 10, 5, 2, 1 and 0. Each call halves the exponent, so the number of calls grows with the number of halvings, not with the exponent itself | One for 1024, one for 5 calls, two for the halving explanation |
| 2 | 15 comparisons in both cases. Selection sort always compares every remaining pair: n(n - 1) / 2. Insertion sort needs only n - 1, which is 5 here, on a sorted list | One for 15 sorted, one for 15 shuffled, one for the formula, one for naming insertion sort with its count |
| 3 | For 58: index 7 (34), then index 11 (58), found, returns 11. For 10: index 7 (34), index 3 (15), index 1 (8), index 2 (12), then lo passes hi, returns -1 | Two for each search: one for the sequence of middles, one for the return value |
| 4 | See the code below: private fields, a validating constructor, tick() with the wrap at 60 minutes and 24 hours, and a two-digit HH:MM string. From 23:58, two ticks give 23:59 then 00:00 | Two for private fields, two for validation, three for tick() including both wraps, two for the formatted string, one for a test of the midnight case |
| 5 | [8, 20, 11, 16] | Two for the nested loops, two for adding grid[r][c] into the right column, one for the list, one for the correct output |
| 6 | Unit: test tick() alone, for example 9:05 ticked 60 times gives 10:05. Integration: test Clock inside the program that uses it, such as an alarm that checks the time. Regression: rerun all the old tests after any change to Clock | Two marks for each kind: one for the definition, one for a sensible example |
| 7 | Python raises RecursionError: -1 // 2 is -1, so exp never reaches 0. Java int division rounds toward zero, so -1 / 2 is 0 and the base case is reached, but -1 % 2 is -1, so the odd branch returns 1 * 1 * 2, which is 2, a wrong answer. Fix: reject a negative exponent at the start, or return 1 / power(base, -exp) using a decimal type | Two for the Python behaviour with its reason, two for the Java value with its reason, two for a working fix |
// A 24-hour clock that keeps its own time valid (ours, mock exam answer)
public class Clock {
private int hours; // 0 to 23
private int minutes; // 0 to 59
public Clock(int hours, int minutes) {
if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
throw new IllegalArgumentException("not a valid time");
}
this.hours = hours;
this.minutes = minutes;
}
// Move forward one minute, wrapping past 23:59 to 00:00.
public void tick() {
minutes++;
if (minutes == 60) {
minutes = 0;
hours = (hours + 1) % 24;
}
}
@Override
public String toString() {
return String.format("%02d:%02d", hours, minutes);
}
public static void main(String[] args) {
Clock c = new Clock(23, 58);
c.tick();
System.out.println(c); // 23:59
c.tick();
System.out.println(c); // 00:00
Clock d = new Clock(9, 5);
for (int i = 0; i < 60; i++) {
d.tick();
}
System.out.println(d); // 10:05
}
}class Clock:
"""A 24-hour clock that keeps its own time valid (ours)."""
def __init__(self, hours, minutes):
if not (0 <= hours <= 23 and 0 <= minutes <= 59):
raise ValueError("not a valid time")
self._hours = hours
self._minutes = minutes
def tick(self):
"""Move forward one minute, wrapping past 23:59 to 00:00."""
self._minutes += 1
if self._minutes == 60:
self._minutes = 0
self._hours = (self._hours + 1) % 24
def __str__(self):
return f"{self._hours:02d}:{self._minutes:02d}"
c = Clock(23, 58)
c.tick()
print(c) # 23:59
c.tick()
print(c) # 00:00Both versions print 23:59 and then 00:00. The Java main also checks a full hour: 09:05 ticked 60 times prints 10:05.
Two languages, one method, two different failures. Python’s floor division sends -1 to -1 forever, which is the infinite recursion pitfall the ICS4U curriculum names. Java’s division reaches the base case and returns a confident wrong answer, which is worse, because nothing warns you.
The lesson: a recursive method needs a precondition, here that the exponent is not negative, and the method should check it rather than trust the caller.
On Question 4, most lost marks are the wrap: forgetting that hours must also wrap at 24, or printing 0:0 instead of 00:00. On Question 3, students often check the wrong middle after moving lo or hi by mid instead of mid plus or minus one.
On Question 2, many write that a sorted list makes selection sort faster. It does not; it still compares every pair. Knowing which algorithms care about their input is a classic Grade 12 analysis point.
For the first test of the year
Schools choose their own unit order, so Unit 1 is not the same everywhere. In the classes our students attend, the first test usually covers variables, operators and simple output, so here is a short check on exactly those, with answers. Predict each printed line before you run anything.
print(15 // 4, 15 % 4, 15 / 4)
a = 5
b = 9
a = b
b = a
print(a, b)
print("ha" * 3)
print(3 > 2 and 2 > 3, 3 > 2 or 2 > 3)
c = 25
f = c * 9 / 5 + 32
print(f)Five things are printed. Write all five on paper first.
You are ready for a first unit test on these basics. Spend your remaining time on the habit that matters for the rest of the course: predicting the output of short programs before running them.
Then try Section 1 of the ICS3U mock above. Its questions start at about this level and climb.
Go back to each one you missed and change a single value, then predict again. The swap question in particular trips up students at every level, and it reappears later when sorting arrays.
A teacher who watches you trace one program out loud can usually find the misunderstanding in a few minutes. That is often the fastest fix.
Using the mocks well
A mock is only useful if it changes what you do next. This routine is ours, and it works for these two papers and for your own old tests.
| Mock score | What it suggests | Next step |
|---|---|---|
| 80 per cent or more | Strong on this material | Practise timing and the written explanations; try harder variants |
| 70 to 79 per cent | Solid, with gaps | Fix the lowest category first, then resit |
| 60 to 69 per cent | Uneven | Daily tracing and a full redo of missed questions |
| Under 60 per cent | Important gaps | Rebuild one unit at a time, with help from a teacher |
The bands above follow the achievement chart’s percentage columns on purpose, but a mock score is not a level. Your teacher evaluates your work against the course expectations, across the whole course, and only the school’s own evaluation counts toward the final grade.
Exam help, not the credit
We prepare students for their school’s exam. We do not set it, see it in advance or mark it, and the credit is the school’s alone.
A student brings their course outline, their old tests and the date of the final. We sit a mock together or set one as homework, mark it with them, and spend the session on the lowest category: often tracing for Grade 11 and recursion for Grade 12.
In the last week we switch to short timed sets and explanation practice, because the night before is not the time for new topics.
Only the school, night school, summer school or credit provider that teaches and evaluates ICS3U or ICS4U can grant its credit. Modern Age Coders runs classes beside that course; we do not grant Ontario credits and we never contact a school about a student’s exam.
We will not write any part of a student’s graded work, and we will not help anyone cheat on an exam. Practice papers like the two above exist so that a student can earn the mark themselves.
Exam readiness
Our own stages, from preparing Grade 11 and 12 students for computer science finals.
| Stage | What it looks like |
|---|---|
| 1. Recognises | Understands the answer when shown it, but could not have written it |
| 2. Recalls | Writes standard algorithms from memory, slowly and with notes nearby |
| 3. Performs | Completes a full mock in the time, on paper, at a steady pace |
| 4. Explains | Says why each answer is right, in clear sentences, and catches their own errors |
Most students overestimate their stage, because recognising an answer feels like knowing it. A timed mock is the honest test.
Ask to see the category totals, not just the score. They show what kind of help is needed.
Stage 1 to stage 2 is about rewriting from a blank page. Stage 2 to 3 is about the clock. Stage 3 to 4 is about talking through your work.
Keep the error log. Rereading it the night before is better revision than a new topic.
Further study
Each runs live with a regular teacher, for a batch or one student.
IIER / SUP / 01
For finals written in Java.
Open the syllabusIIER / SUP / 02
Tidy project history before the final project is due.
Open the syllabusIIER / SUP / 03
A third language once the course is done.
Open the syllabusIIER / CON / 01
Timed problem solving, the next level after a final.
Open the syllabusIIER / CON / 02
Harder problems, faster.
Open the syllabusIIER / CON / 03
A weekend build with a team.
Open the syllabusIIER / BYD / 01
Models built and tested from scratch.
Open the syllabusIIER / BYD / 02
A complete web app, front to back.
Open the syllabusIIER / BYD / 03
Real data in Python, from question to chart.
Open the syllabusClass times
Weekdays or weekends, flexible: choose your batch, or for a very personalised plan choose 1-on-1 at your convenience, weekend mornings or weekdays.
Weekdays
Evening sessions for timed sets during exam season.
Weekends
Longer mornings for a full mock and its marking.
1-on-1
Booked close to the exam date for final review.
Sat on paper, under real conditions.
Category by category, honestly.
Kept and reviewed every session.
The language of the class.
Who knows the student’s weak spots.
Fifteen to twenty, or just one.
Student work
Some of what students have built with us once exams were done. The student labs page has more.

AI and ML
An AI nutrition coach that reads what you eat and works you toward a target.

AI and ML
A chatbot that answers mathematics and programming questions, built and deployed by a student.

AI and ML
An assistant that helps a young person recognise unsafe situations online.

Web app
A weather forecasting site with live conditions for any location.
Fees
Your first class costs nothing. Families then pay a monthly fee for eight live classes a month, displayed below in your currency, with no contract beyond the month, so you can stop once the exam is over.
Free first class
Free
no card required
Group batch
$100 USD
a month, eight live classes
One to one
$150 USD
a month, eight live classes
What families say
Families on Google, in their own words.
★★★★★
"The one step solution for my son. Modern Age Coders make learning coding so simple that kids love it. The teachers explain complex concepts clearly with practical exercises and interactive content."
Ria Mukherjee
Parent
★★★★★
"Modern Age Coders has been a game-changer for me. I struggled to grasp IT concepts and coding before joining, but their classes transformed everything. I can now confidently write complex programs with ease."
Samriddha Mondal
Student
★★★★★
"One of the most wonderful education centres out there. Education is not limited to school syllabus but focuses on skill development."
Vansh Agarwal
Student
★★★★★
"My child Dhairya is really enjoying the Modern Age Coders classes. This is his first online class and he eagerly looks forward to it. I can already see his improvement, and the teachers are very cooperative."
Sonam Oswal
Parent of Dhairya
★★★★★
"Modern Age Coders have wonderful teachers who teach in a clear, easy and practical way. The teacher boosts students' confidence and inspires them to learn without hesitation."
Sonu Goyal
Parent
★★★★★
"I highly recommend this computer coding class! The teachers are incredibly knowledgeable and passionate about coding."
Ritu Kedia
Parent
Exam questions from families
Under the 2008 Ontario curriculum, 30 per cent of the final grade comes from a final evaluation near the end of the course, such as an examination, a performance or another suitable method, and 70 per cent from evaluations during the course. Each school decides what its final evaluation contains.
It depends on the school and the teacher. ICS3U covers data types, one-dimensional arrays, control structures, subprograms, debugging and testing, software development, computer systems and topics in computer science, so finals usually draw on those. Ask the teacher what the final evaluation includes.
Again it depends on the school. ICS4U adds modular and object-oriented design, searching and sorting, recursion, algorithm analysis, formal testing and a team project, so Grade 12 finals usually include tracing recursion, comparing algorithms and writing classes.
No. Both mock exams were written by our teachers for this page. They are not taken from any school, board or past exam, and they do not predict what any particular exam will contain.
Teachers use the achievement chart in the 2008 curriculum, which has four categories: Knowledge and Understanding, Thinking, Communication and Application. Our marking guides tag every question with one category so a student can see which one needs work.
The 2008 curriculum says a student whose achievement is below 50 per cent at the end of a course will not obtain a credit for it. Level 3, 70 to 79 per cent, is called the provincial standard.
Sit a timed mock on paper, mark it strictly, total the marks by category, keep an error log, redo missed questions from a blank page two days later, and sit a second paper a week after. Trace short programs by hand every day.
Schools set their own unit order. In our experience a first unit often covers variables, data types, operators and simple input and output. The Unit 1 check on this page tests exactly those, with answers.
No. We prepare students beside the school course and do not grant Ontario credits. Exams, marks and credits come only from the school or credit provider that teaches the course.
Weekdays or weekends, flexible: choose your batch, or for a very personalised plan choose 1-on-1 at your convenience, weekend mornings or weekdays. Times are set in your own Ontario time zone.
The first class is free. After that families pay a monthly fee and can stop at the end of any month, including straight after the exam. The fees section shows the current figure.
Other guides
Course guides and study help for Ontario students.
The Grade 11 course explained, strand by strand.
The core skill behind every tracing question.
Finding the cause of an error instead of guessing.
Before the ICS4U mock, if recursion still feels strange.
Live classes for every age in Ontario.
For students who enjoyed the hardest questions here.
Every Canadian page on this site.
Start here
Tell us the course, the language, the exam date and one topic that worries your teen. The first class is a short mock on that topic, marked together.
To read more first, see the companion course syllabus, which includes its exam weeks, or how we teach.
WhatsApp us · +91 91233 66161 · connect@modernagecoders.com
Lessons are live online with teachers who work from India, so exam practice fits around school without any travel. WhatsApp is the fastest way to reach us from Ontario.
A priority demo is a full class of about 45 to 60 minutes. After the class the mentor sends a written skill report and a personal learning roadmap on WhatsApp. If you enrol, the demo fee is adjusted against your first month's fee. Share your demo Order ID with us on WhatsApp and we take it off.
Book a priority demo