---
title: "BC Computer Programming 11 and 12, Computer Science 11 Help"
description: "BC Computer Programming 11 and 12 and Computer Science 11 from the curriculum: what each covers, two worked problems in Python, ten practice questions, a plan."
canonical: https://learn.modernagecoders.com/computer-programming-11-and-12-bc
source: src/pages/computer-programming-11-and-12-bc.html
---
> BC Computer Programming 11 and 12 and Computer Science 11 from the curriculum: what each covers, two worked problems in Python, ten practice questions, a plan.

In short

British Columbia teaches senior programming in two subjects: Computer Programming 11 and 12 under Applied Design, Skills, and Technologies, and Computer Science 11 and 12 under Mathematics. Both use variables, decisions, loops and functions; CP leans on design and teamwork, CS on logic and algorithms. Modern Age Coders helps live online, in a batch or one to one, through Python for Teens or Java for Teens.

Learn it with a teacher

## Three courses for a BC senior programming student

Pick the language the school class uses. The third course is for students who want the algorithms side, which Computer Science 11 leans on, in more depth.

[![Python for Teens course thumbnail](/images/python-teens.webp)  COP / 01 Python for teens Ages 13 to 18. The language many BC senior classes use, from input and loops to functions, files and small projects. Open the syllabus →](/courses/python-complete-masterclass-teens)[![Java for Teens course thumbnail](/images/java-teens.webp)  COP / 02 Java for teens Ages 13 to 18. For classes taught in Java: declared types, methods, arrays, then classes and objects for Computer Programming 12. Open the syllabus →](/courses/java-programming-masterclass-for-teens)[![Problem Solving for Teens course thumbnail](/images/problem-solving-teens.webp)  COP / 03 Problem solving for teens Searching, sorting, recursion and the habit of proving an algorithm right before trusting it. Open the syllabus →](/courses/problem-solving-dsa-masterclass-teens)

Two subject areas

## Where programming sits in the BC curriculum

The BC curriculum website files its computing courses in two places. Under Applied Design, Skills, and Technologies, the Information and Communications Technology courses include Computer Studies 10, Web Development 10, Computer Information Systems 11, Computer Programming 11 and Computer Programming 12. Under Mathematics, the course list includes Computer Science 11 and Computer Science 12. Same keyboard, different starting point.

| Course | Subject area | What the page leads with | Our one-line reading |
| --- | --- | --- | --- |
| Computer Studies 10 | ADST | Content includes “distinguishing between syntax, logic, and run-time errors” and “simple programs, including games” | A broad Grade 10 course: hardware, networks and safety, with a first programming unit |
| Computer Programming 11 | ADST | Big idea: personal design choices “require self-exploration, collaboration, and evaluation and refinement of skills” | Programming as a design craft: requirements, pair work, libraries, testing |
| Computer Programming 12 | ADST | Content includes “bug reports and feature requests from users” and code written to be “self-documenting” | Larger projects, real users, debuggers and error handling |
| Computer Science 11 | Mathematics | Big idea: algorithms, “sets of rules or instructions that precisely define a sequence of operations”, “are essential in solving problems computationally.” | Programming as applied mathematics: logic, searching, simulation, number systems |
| Computer Science 12 | Mathematics | Listed on the Mathematics course list | We could not read its content page on the day; see the note below |

### Why the subject area matters

The subject area changes the flavour of the course more than the code does. Computer Programming 11 sits beside Woodwork, Drafting and Media Design, and like them it is organized around the ADST design cycle: understand users, define, ideate, prototype, test, make and share. Its curricular competencies are the same design-thinking headings the other ADST courses carry.

Computer Science 11 sits beside Pre-calculus and Statistics, and its curricular competencies are the mathematics ones: reasoning and modelling, understanding and solving, communicating and representing, connecting and reflecting. The same while loop shows up in both. In CP it serves a product; in CS it serves a proof or a model.

### What a school actually offers

The curriculum lists what may be taught, not what every school runs. Any one school may run the ADST pair, the Mathematics pair, the two together, or none of the four in a particular year. The course planning guide from your teen’s school is the only reliable list.

Names also drift in conversation. Students say “comp sci 11” for either course, and a school might label a section “Computer Science” when the course code behind it is Computer Programming. Before planning help, we ask families which curriculum page the teacher’s outline follows.

Sources: [BC Applied Design, Skills, and Technologies](https://curriculum.gov.bc.ca/curriculum/adst) and [BC Mathematics](https://curriculum.gov.bc.ca/curriculum/mathematics) course lists, and the course pages linked below, in copies fetched raw on 22 October 2026. A second visit that day could not connect to the curriculum site, so the Computer Science 12 content page was never read and nothing on this page describes it. Neither the ministry nor any school district has a connection with Modern Age Coders.

ADST, Grade 11

## Computer Programming 11, in the curriculum’s own words

The Computer Programming 11 page lists its content as short phrases, each with an elaboration that explains it. The elaborations are where the detail lives, so the table quotes them.

| Content item | The curriculum’s elaboration | In a lesson (our reading) |
| --- | --- | --- |
| Problem decomposition | “subdivide a problem into manageable, self-contained tasks” | One function per job, each testable alone |
| Strategies to predict effects of code modification | “hand tracing code, guess and test (experimentation)” | Change one value, predict the output, then run it |
| Pair programming | “two programmers work together at one workstation. One, the driver, writes code while the other, the observer or navigator, reviews each line of code as it is typed in. The two programmers switch roles frequently.” | Roles swapped on a timer, both names on the work |
| Language constructs | “programming language constructs to support input/output, logic, decision structure, and loops” | The core toolkit: input, print, if, while, for |
| Requirements of a problem statement | “a complete set of requirements that will support the rest of the software development cycle without the need to revisit the problem statement in the future” | A written list of what the program must do, agreed before coding |
| Ways to transform requirements into algorithms | “pseudocode, iterative refinement, flowcharts, UML, other design entities” | Plan on paper first; the code follows the plan |
| Pre-built libraries | “external libraries for graphical user interfaces or gaming, sensor libraries for hardware such as coding devices” | Using someone else’s tested code instead of rewriting it |
| Documentation | “interpretation of library documentation/application programming interface (API)” and “inline commenting to document source code” | Reading the docs for a library function before guessing how it works |
| Use of test cases | “running test cases to compare expected versus actual output and printing the value of variables to aid in the debugging process”, “to detect logical or semantic errors” | A test table with the expected column filled in first |

### Computational thinking, defined

The page defines computational thinking as “formulating problems and their solutions so they are represented in a form that can be solved through an algorithmic process.” That is a useful sentence for a student to keep. It says the hard part happens before the code: turning a messy situation into something precise enough for a machine.

Its big ideas say the design cycle “is an ongoing reflective process” and that “Tools and technologies can be adapted for specific purposes.” In practice, a CP 11 student is marked on how they plan, test and improve a program, not only on whether the final version runs.

### Pair programming is assessed work, not a shortcut

Parents sometimes worry when they hear that their teen codes with a partner. The curriculum names pair programming as content, with clear roles: the driver types, the navigator reviews each line as it appears, and they swap often. Done well, it catches mistakes early and makes both students explain their thinking aloud.

We practise it on screen. The student drives while the teacher navigates, then they swap, so the student learns to review code as carefully as they write it. That second skill is the one most teenagers have never been asked to use.

ADST, Grade 12

## What Computer Programming 12 adds

Computer Programming 12 keeps the same big ideas as Grade 11 and raises the scale. Its content reads like the first year of a junior developer’s job: bigger codebases, real users, and tools for finding faults.

| Content item | In the curriculum’s words |
| --- | --- |
| Documentation | “documenting source code with industry standard tools” |
| Self-documenting code | “writing source code in such a way that makes inline comments seem unnecessary” |
| Collaboration tools | “online tools to facilitate pair and collaborative programming” |
| Advanced pair programming | The observer considers the “strategic” direction of the work; the driver focuses on the “tactical” aspects, “using the observer as a safety net and guide” |
| User interface design | “The goal of user interface design is to make the user's interaction as simple and efficient as possible” |
| Error handling | A process of “anticipation, detection and resolution of application errors, programming errors or communication errors” |
| Debugging tools | “use of a debugger that is capable of stepping through code and monitoring variables” |
| Management of complexity | For example, “a project whose scale requires multiple source files or functions” |
| Pre-built data structures | “the data structures that are provided (e.g., from a standard library)” |
| Working with users | “bug reports and feature requests from users” |
| Interpersonal skills | People skills, communication and record keeping “necessary to work effectively within the IT sector” |

### The jump students feel

Grade 11 programs usually fit in one file and one sitting. Grade 12 projects do not. Once a program spreads across several files, a student needs a way to find which file holds the fault, and the curriculum’s answer is a real debugger: step through, watch the variables, find the line where reality parts from the plan.

Many students have never opened one. We teach the debugger in the first weeks of Grade 12 help, on the student’s own project, because a debugger learned on someone else’s toy example rarely sticks.

### Error handling, the CP 12 way

The curriculum breaks error handling into anticipation, detection and resolution. Anticipation means asking what a user could type that would break the program. Detection means the program notices. Resolution means it recovers with a clear message instead of a crash.

Our second worked problem below follows those three steps exactly, on a small program a BC family might actually use: converting a Pacific time into India time, with every bad input caught and named.

Sources: [Computer Programming 11](https://curriculum.gov.bc.ca/curriculum/adst/11/computer-programming) and [Computer Programming 12](https://curriculum.gov.bc.ca/curriculum/adst/12/computer-programming) on curriculum.gov.bc.ca, research copies fetched raw on 22 October 2026. The Grade 12 page repeats the three big ideas of Grade 11 word for word.

Mathematics, Grade 11

## Computer Science 11: programming as mathematics

Computer Science 11 is a Mathematics course, and it reads like one. Its four big ideas are about decomposition, algorithms, computational thinking and problem solving, and its content list mixes programming basics with logic and mathematical modelling.

| Area | In the curriculum’s words |
| --- | --- |
| Big idea: decomposition | Decomposition “helps us solve difficult problems by managing complexity.” |
| Big idea: algorithms | Algorithms “are essential in solving problems computationally.” |
| Big idea: problem solving | Solving problems “is a creative process.” |
| Data types | “strings, integers, characters, floating point”, and “number systems (e.g., binary, hexadecimal)” |
| Basic concepts | “variables, constants, mathematical operations, input/output, generating random numbers” |
| Variable scope | “local versus global” |
| Logic | “logical operators (AND, OR, NOT)”; “logical equivalences (e.g., De Morgan’s laws), simplification of logical statements, truth tables” |
| Control flow | Decision structures and “loops (e.g., for, while, nested loops)” |
| Developing algorithms | “step-wise refinement, pseudocode or flowcharts, translating between pseudocode and code and vice versa” |
| Arrays and lists | Operations “append, remove, insert, delete” and “searching algorithms (e.g., linear and binary searches)” |
| Modularity | “use of methods/functions to reduce complexity, reuse code, and use function parameters” |
| Modelling mathematical problems | Including to “estimate theoretical probability through simulation” and to “compute greatest common factor/least common multiples” |

### Competencies worth reading twice

Two curricular competencies describe the habits a strong CS 11 student shows. One is flexible thinking: “understanding that different algorithms can be used to solve the same problem”. The other asks for “designing algorithms that solve a class of problems rather than a single problem”, which is the difference between a program that works for the example and one that works.

The competencies also name tools: integrated development environments, third-party libraries and “visual code comparison tools to view code differences (e.g., Meld)”, and they point students to code visualization websites. Mistakes are listed too: they “include syntax, semantic, run-time, and logic errors”, treated as opportunities to learn.

### What we could not read: Computer Science 12

Computer Science 12 appears on the BC Mathematics course list, so it exists as a provincial course. Its content page did not load when we went back for it on 22 October 2026: the curriculum site refused the connection. We will not describe its content from memory or from someone else’s summary.

If your teen is in CS 12, bring the teacher’s outline to the first class. We plan from the outline itself, which is the more reliable map in any case, because the curriculum leaves teachers room to choose order and examples.

Source: [Computer Science 11](https://curriculum.gov.bc.ca/curriculum/mathematics/11/computer-science) on curriculum.gov.bc.ca, research copy fetched raw on 22 October 2026. The curly apostrophe in De Morgan’s is the curriculum’s own.

CP or CS

## Computer Programming 11 or Computer Science 11: which one fits

Both are real programming courses, and a student who takes either will write loops, decisions and functions all year. The difference is what the code is for. This comparison is ours, built from the two curriculum pages above.

|   | Computer Programming 11 (ADST) | Computer Science 11 (Mathematics) |
| --- | --- | --- |
| The code serves | A product for a user | A problem, a model or a proof |
| Planning tools named | Pseudocode, iterative refinement, flowcharts, UML | Step-wise refinement, pseudocode or flowcharts |
| Teamwork named | Pair programming, with driver and navigator roles | Partner talks and small-group discussion |
| Testing named | Test cases comparing expected and actual output | Analysing errors: syntax, semantic, run-time, logic |
| Mathematics inside | Light; as the project needs | Logic, number systems, probability by simulation, factors and multiples |
| Outside code named | Pre-built libraries and their API documentation | IDEs, third-party libraries, code comparison tools |
| Suits a student who | Wants to build things people use, and likes design | Likes puzzles, proofs and the math behind the program |

### If your teen can take both

Taking both is not repetition. A student who does CS 11 learns why binary search halves the work and how to prove two logical expressions equal; the same student in CP 11 learns to write requirements, read library documentation and work in a pair.

Order matters less than people think. If the timetable forces a choice, choose the course whose teacher’s outline excites the student. Motivation decides more marks in a project-heavy course than any prerequisite does.

### If the school offers neither

Some BC schools run no senior programming course in a given year. A student can still learn the same material outside school, with the honest understanding that outside lessons do not produce a school credit. If the credit itself matters, the school counsellor is the person to ask about other ways to take the course.

For a student aiming at university computer science, mathematics matters at least as much as a programming credit. The admission section below shows what UBC actually lists for BC applicants to Science.

Worked problem 1, ours

## Estimating a probability by simulation, then checking it exactly

Computer Science 11 lists “estimate theoretical probability through simulation” as content. This problem is ours. It does the simulation and then does something students often skip: it works out the exact answer by counting, so the simulation can be judged against the truth.

**The problem.** Roll two fair six-sided dice. What is the probability that the sum is at least 10? Estimate it by simulating 100, 1,000, 10,000 and 100,000 rolls, then compute the exact value and compare.

1. **Count before you code.** Two dice give 6 × 6 = 36 equally likely ordered pairs. Sums of 10, 11 and 12 come from (4, 6), (5, 5), (6, 4), (5, 6), (6, 5) and (6, 6): six pairs. So the exact probability is 6 out of 36, one sixth, about 0.1667. The program checks this count with a nested loop instead of trusting our list.
2. **Separate the jobs.** One function counts exactly; another simulates. Each can be tested alone, the decomposition the curriculum describes.
3. **Fix the seed.** A random number generator started with the same seed gives the same sequence, so a teacher, a partner and the student all see identical output. Without it, nobody can check anybody else’s run.
4. **Measure the error, not just the estimate.** Print how far each estimate is from the exact answer. The interesting result is in that column.

***Python · dice simulation (ours)**python*

```
# Two dice, sum of at least 10: simulation against the exact answer (ours)
import random

def exact_chance(target):
    """Count the 36 equally likely (die1, die2) pairs whose sum is at least target."""
    hits = 0
    for a in range(1, 7):
        for b in range(1, 7):
            if a + b >= target:
                hits += 1
    return hits, 36

def simulate(trials, target, seed):
    rng = random.Random(seed)      # a fixed seed makes the run repeatable
    hits = 0
    for _ in range(trials):
        if rng.randint(1, 6) + rng.randint(1, 6) >= target:
            hits += 1
    return hits / trials

hits, outcomes = exact_chance(10)
print("Exact:", hits, "of", outcomes, "=", round(hits / outcomes, 4))
for n in [100, 1000, 10000, 100000]:
    est = simulate(n, 10, seed=11)
    print(f"{n:>6} trials: {est:.4f}  (off by {abs(est - hits / outcomes):.4f})")
```

***Output, Python 3.13**text*

```
Exact: 6 of 36 = 0.1667
   100 trials: 0.1200  (off by 0.0467)
  1000 trials: 0.1610  (off by 0.0057)
 10000 trials: 0.1663  (off by 0.0004)
100000 trials: 0.1681  (off by 0.0015)
```

Same seed, same output on any machine running Python 3. Change the seed and the estimates change; the exact line never does.

### What the output teaches

One hundred rolls gave 0.12, a long way from 0.1667. A student who stopped there would believe the chance is about one in eight. A thousand rolls came within 0.006, and ten thousand within 0.0004.

Then the surprise: 100,000 rolls landed 0.0015 away, further than 10,000 did. That is not a bug. A simulation’s error tends to shrink as trials grow, but any single run can wobble. This is the “connection between theoretical and experimental probability” the curriculum’s competencies mention, seen in four lines of output.

### Where students go wrong

The common mistake is `random.randint(2, 12)` for the sum of two dice. It picks each sum from 2 to 12 equally, which is wrong: a 7 can happen six ways and a 12 only one. The simulation then reports about 3 in 11, roughly 0.27, and a student without the exact count never notices.

The second mistake is counting only six of the 36 outcomes by hand and forgetting that (4, 6) and (6, 4) are different rolls. The nested loop removes that risk, which is why it is worth writing even when the answer seems obvious.

Worked problem 2, ours

## A Pacific-to-India clock converter that refuses bad input

This one is in the Computer Programming spirit: a small tool for a real user, with requirements, error handling and a test table. It is ours, and it solves a question BC families ask us: if a class is at 4:30 in the afternoon in Vancouver, what time is it for the teacher?

1. **Write the requirements first.** Input: a 24-hour time as HH:MM in BC. Output: the time in India and whether it is the same day or the next. BC has been on UTC-7 all year since March 2026 and India is on UTC+5:30, so the gap is 12 hours 30 minutes, always.
2. **Anticipate.** List what a user could type wrongly: a missing colon, single-digit minutes, letters, an hour of 24, minutes of 60.
3. **Detect.** Check the shape of the input, then the ranges. Let Python’s own `int()` detect letters, because it already raises an error for them.
4. **Resolve.** Catch each error where the program is used and print a message that tells the user how to fix it, instead of a traceback.
5. **Fill in the expected column before running.** Then run every case and compare.

***Python · clock converter (ours)**python*

```
# Pacific time to India time, with error handling (ours)
# BC is UTC-7 all year from 8 March 2026; India is UTC+5:30, so India is 12 h 30 min ahead.
GAP_MINUTES = 12 * 60 + 30

def parse_clock(text):
    """Turn 'HH:MM' (24-hour) into minutes after midnight, or raise ValueError."""
    parts = text.strip().split(":")
    if len(parts) != 2 or len(parts[1]) != 2:
        raise ValueError("use the form HH:MM, for example 16:30")
    hours, minutes = int(parts[0]), int(parts[1])   # int() raises ValueError on letters
    if not (0 <= hours <= 23 and 0 <= minutes <= 59):
        raise ValueError("hours run 0 to 23 and minutes 0 to 59")
    return hours * 60 + minutes

def to_india(text):
    total = parse_clock(text) + GAP_MINUTES
    day = "next day" if total >= 24 * 60 else "same day"
    total %= 24 * 60
    return f"{total // 60:02d}:{total % 60:02d} ({day})"

for entry in ["16:30", "09:00", "11:29", "11:30", "23:59", "24:00", "7:5", "ab:30", "four"]:
    try:
        print(entry, "->", to_india(entry))
    except ValueError as err:
        print(entry, "-> rejected:", err)
```

| Input | Expected and actual output | What the case tests |
| --- | --- | --- |
| 16:30 | 05:00 (next day) | A typical after-school time crosses midnight in India |
| 09:00 | 21:30 (same day) | A weekend morning in BC is the evening in India |
| 11:29 | 23:59 (same day) | The last minute before the day changes |
| 11:30 | 00:00 (next day) | Exactly midnight counts as the next day |
| 23:59 | 12:29 (next day) | The largest valid input |
| 24:00 | rejected: hours run 0 to 23 and minutes 0 to 59 | An hour that does not exist |
| 7:5 | rejected: use the form HH:MM, for example 16:30 | Single-digit minutes are ambiguous |
| ab:30 | rejected: invalid literal for int() with base 10: 'ab' | Letters, caught by int() itself |
| four | rejected: use the form HH:MM, for example 16:30 | No colon at all |

### Why the boundaries matter

Rows three and four differ by one minute and give different days. A converter written with `>` instead of `>=` in the next-day check passes almost every test and fails at 11:30. Boundary cases exist to catch exactly that, and the curriculum’s test-case content asks students to compare expected with actual output for this reason.

The `ab:30` row shows a judgement call. Python’s message is accurate but unfriendly. A CP 12 student might wrap it in a clearer sentence; a CS 11 student might leave it, since the program still refuses the input. Both choices can be defended, and defending the choice is part of the work.

### One fixed gap, one exception

The program can use a single fixed gap because BC no longer changes its clocks. Before 2026 the same code would have needed two gaps, one for summer and one for winter. That is a nice discussion question in itself: what assumption is built into a constant, and what would break if it changed?

The fixed gap is also not true everywhere in BC. East Kootenay and Golden keep UTC-6 all year, one hour ahead of Vancouver, so a family there needs a gap of 11 hours 30 minutes. A good requirements list would say which region the tool is for.

Practice, ours

## Ten practice questions for CP 11 and CS 11

These questions are ours, written for this page in Python and not taken from any school, district or exam. They follow the content lists above: number systems, scope, logic, loops, searching, factors and multiples, list operations, validation and planning. Answer on paper before you scroll down.

***Question 1 · number systems**python*

```
print(bin(13), int("1011", 2), hex(255))
```

What exactly does this print? Explain each of the three values.

***Question 2 · scope**python*

```
count = 5

def bump():
    count = 1
    count += 1
    return count

print(bump(), count)
```

What does this print, and why is the second number not 2?

**Question 3 · logic.** Build a four-row truth table for `not (a and b)` and for `(not a) or (not b)`. What do you notice, and what is the name of the rule? Then simplify `not (raining or windy)` into an expression with no brackets.

***Question 4 · nested loops**python*

```
total = 0
for i in range(1, 4):
    for j in range(i):
        total += j
print(total)
```

Trace it with a table of i, j and total. What is printed?

**Question 5 · binary search.** The sorted list is 3, 8, 12, 19, 25, 31, 40 (indexes 0 to 6). Using `mid = (lo + hi) // 2`, list the indexes a binary search checks when looking for 31, and then for 10. How many checks would a linear search need to find 31?

***Question 6 · debug the greatest common factor**python*

```
def gcf(a, b):
    while b != 0:
        a = b
        b = a % b
    return a

print(gcf(48, 18))
```

It should print 6. What does it print, and which line is wrong? Fix it, then use it to write a least common multiple function.

***Question 7 · debug a list operation**python*

```
temps = [4, -2, -5, 7, -1]
for t in temps:
    if t < 0:
        temps.remove(t)
print(temps)
```

The plan was to remove every negative reading. What prints, and why is one negative left behind?

**Question 8 · write a function.** Write `lcm(a, b)` using your fixed `gcf`. What are `lcm(4, 6)` and `lcm(21, 6)`? Why is it better to divide before multiplying?

**Question 9 · validate input.** A Canadian postal code has the shape letter, digit, letter, space, digit, letter, digit, as in V6B 1A1. Write `is_postal_code(text)` that returns True only for that shape in capital letters. List six test inputs, with the expected result for each, before you run anything.

**Question 10 · requirements and pairs.** A school club wants a program that records which members attended each meeting and reports anyone who missed three in a row. Write four requirements precise enough that nobody needs to ask the club again, then say how you would split the first hour of work between a driver and a navigator.

Answers, ours

## Answers, with the reasoning

Each program here was run in Python 3.13 to confirm the output. The reasoning is the part to learn; the number at the start is only the check.

1. **0b1101 11 0xff**. Thirteen is 8 + 4 + 1, so binary 1101, and Python prefixes binary with 0b. The string 1011 read in base 2 is 8 + 2 + 1 = 11. Two hundred fifty-five is 15 × 16 + 15, so hexadecimal ff, prefixed 0x.
2. **2 5**. The `count` inside `bump` is a local variable, created by the assignment on its first line. It starts at 1, becomes 2 and is returned. The global `count` outside was never touched, so it is still 5: local versus global, exactly as the CS 11 content names it.
3. **The two columns are identical**: True, True, True, False for the rows FF, FT, TF, TT. That is one of De Morgan’s laws: not (a and b) equals (not a) or (not b). The other law gives `not (raining or windy)` = `(not raining) and (not windy)`.
4. **4**. When i is 1, j takes only 0. When i is 2, j takes 0 and 1, adding 1. When i is 3, j takes 0, 1 and 2, adding 3. The total is 0 + 1 + 3 = 4. The inner loop runs i times, because `range(i)` stops before i.
5. **For 31: indexes 3, then 5.** The first middle is (0 + 6) // 2 = 3, holding 19, which is too small, so lo becomes 4; the next middle is (4 + 6) // 2 = 5, holding 31. **For 10: indexes 3, 1, 2**, then lo passes hi and the search reports not found. A linear search checks 3, 8, 12, 19, 25 and 31: six checks to find 31.
6. **It prints 18.** The line `a = b` overwrites a before the remainder is taken, so `a % b` becomes 18 % 18 = 0 and the loop ends at once. Both new values must come from the old pair: `a, b = b, a % b`. Then 48, 18 becomes 18, 12, then 12, 6, then 6, 0, and the answer is 6. That is Euclid’s algorithm.
7. **It prints [4, -5, 7]**. Removing an item while looping over the same list shifts everything after it one place left, so the loop skips the item that slid into the removed one’s place. After -2 is removed, -5 slides into its index and is never examined. Build a new list instead: `[t for t in temps if t >= 0]`.
8. **12 and 42** (see the code below). The least common multiple is a × b divided by the greatest common factor. Dividing first keeps the intermediate number small, which matters little in Python but prevents overflow in Java with large ints.
9. **See the code below.** Our six tests and results: `V6B 1A1` True; `K1A 0B1` True; `v6b 1a1` False (lower case); `V6B1A1` False (no space); `V6B 1AA` False (letter where a digit belongs); the empty string False. The length check comes first so that a short string never reaches the loop.
10. **One good set:** (1) store member names and meeting dates; (2) for each meeting, record present or absent for every member; (3) a member is reported when they are absent at three meetings in a row, in date order; (4) the report lists each such member once, with the dates missed. For the hour: the driver codes the data entry while the navigator writes the test table for requirement 3, then they swap. Writing requirement 3 precisely (is “three in a row” three meetings or three weeks?) is the real lesson.

***Answers 6 and 8 · Python**python*

```
def gcf(a, b):
    while b != 0:
        a, b = b, a % b      # both new values come from the old pair
    return a

def lcm(a, b):
    return a // gcf(a, b) * b   # divide first so the product stays small

print(gcf(48, 18), lcm(4, 6), lcm(21, 6))   # 6 12 42
```

***Answer 9 · Python**python*

```
def is_postal_code(text):
    """True for letter digit letter, space, digit letter digit, e.g. V6B 1A1."""
    if len(text) != 7 or text[3] != " ":
        return False
    pattern = "LDL DLD"
    for ch, kind in zip(text, pattern):
        if kind == "L" and not (ch.isalpha() and ch.isupper()):
            return False
        if kind == "D" and not ch.isdigit():
            return False
    return True
```

Run against the six inputs above, it returns True, True, False, False, False, False in that order. A regular expression can do the same in one line; for a CS 11 test, the loop shows the reasoning a marker wants to see.

Assessment plan, ours

## A study plan for tests and project deadlines

BC senior programming courses are assessed in different ways by different teachers: tests, coding tasks done in class, and projects with a written process. This plan is ours. It covers both kinds of assessment; drop the half that your teen’s course does not use.

1. **Get the assessment list from the teacher.** Which pieces are tests, which are in-class coding tasks, which are projects, and what does each project hand in besides code: a plan, a test table, a reflection?
2. **Keep a vocabulary page.** Variable, constant, scope, parameter, return value, decision structure, nested loop, syntax error, semantic error, run-time error, logic error. One line of definition and two lines of example each.
3. **For tests, trace on paper daily.** Two short programs a day with a written trace table. Questions 2, 4 and 5 above are the shape to practise.
4. **For CS 11, drill the logic and number topics.** Convert five numbers between decimal, binary and hexadecimal each week, and prove one logical equivalence with a truth table.
5. **Rebuild the standard algorithms from a blank file.** Linear search, binary search, greatest common factor, a running total and a count. No notes; then compare with class versions.
6. **For projects, write requirements before code.** A numbered list, agreed with the teacher if possible. Every later decision gets checked against it.
7. **Keep a test table from day one.** Expected results written before running, boundary cases included, like the converter table above.
8. **Save a working version at every milestone.** A project that worked on Tuesday and is broken on Thursday should never be a disaster. Version control is the grown-up answer; a dated copy of the folder is the minimum.
9. **Practise with a partner.** If the course uses pair programming, rehearse both roles. Navigating well, catching a mistake as it is typed, is a skill that improves only with practice.
10. **Finish early, then improve.** Stop adding features a week before a deadline. Use that week for testing, documentation and the written reflection.

| Weeks to go | For a test | For a project |
| --- | --- | --- |
| 4 | Vocabulary page complete; topics marked solid or shaky | Requirements written and agreed; plan drawn |
| 3 | Daily tracing; standard algorithms rebuilt | Core features working; test table started |
| 2 | Timed practice on shaky topics | All requirements met in a saved version |
| 1 | One full timed practice and a mistakes log | Testing, documentation and reflection only |

After Grade 12

## Senior programming and university computer science from BC

A family planning ahead usually asks whether Computer Programming 12 or Computer Science 12 is needed for a computer science degree. For UBC Vancouver’s Faculty of Science, one of the routes into computer science there, the answer on UBC’s own requirements tool is more about mathematics than programming.

| Level | What UBC lists |
| --- | --- |
| Grade 12 | “English Studies 12 or English First Peoples 12”; “Pre-Calculus 12”; “Anatomy and Physiology 12, or Chemistry 12, or Physics 12” |
| Grade 11 | “Chemistry 11” and “Physics 11” |
| Related subject categories | “Language Arts”, “Mathematics and Computation”, “Sciences” |

### Reading the table

No programming course appears among the required ones. Pre-Calculus 12 does. A related category called Mathematics and Computation is listed as particularly relevant, which is where a senior computing course can show interest and preparation without being a requirement.

So the plan for a BC teen aiming at computer science starts with the math sequence through Pre-calculus 12, with Calculus 12 as a strong addition. Our [Western Canada Grade 12 Math course](/courses/western-canada-grade-12-math-pre-calculus-12-math-30-1-course) teaches Pre-calculus 12 alongside school. Requirements change between admission years, so check UBC’s tool in the year your teen applies.

### Contests as a second bridge

Waterloo’s Centre for Education in Mathematics and Computing organizes the Canadian Computing Competition, and CEMC lists the 2027 CCC for North and South America on Wednesday 17 February 2027. CEMC is direct about entry: “It is not possible for students to individually register for a contest”. If a teen’s own school does not take part, CEMC suggests that “students can look for another local school that will allow them to join as a participant”.

CEMC states that “CCC participants may use C, C++, Python 2, Python 3, or Java.”, so a BC student who has done CP 11 or CS 11 in Python or Java already has a contest language. Our [CCC preparation page](/canadian-computing-competition-ccc-prep) explains the levels and format.

Sources: the [UBC Computer Science (Vancouver) program page](https://you.ubc.ca/programs/computer-science-vancouver-bsc/) and UBC’s requirements tool (Science, applicants from British Columbia), its response kept as a raw file on 22 October 2026; CEMC’s [CCC page](https://cemc.uwaterloo.ca/contests/ccc) and [How contests work](https://cemc.uwaterloo.ca/contests/how-contests-work), read 22 October 2026. We are not connected with UBC or CEMC.

The credit, and the clock

## We teach the course; the school grants the credit

Families sometimes search for Computer Programming 11 online because they want the credit itself. That is a school matter, and it is clearer to say so at the start.

### Where the credit comes from

In BC, a credit for Computer Programming 11 or Computer Science 11 is earned at a school: your teen’s own, a district summer session, or an online learning school that delivers and marks the course. We are a tutoring service, so we do not grant high school credits. We teach next to the school course, using its outline and its assignments.

Questions about the diploma, such as how many credits a student needs and where a computing course counts, belong with the school counsellor. The provincial page on graduation would not load for us when we researched this guide, and we will not guess at its contents.

### Where we fit

Students come to us when the course is moving faster than they are: a project with no plan, a debugger they have never used, a binary search that loops forever, a CS 11 test on truth tables next week. We work from what the teacher set, explain it, and have the student do the work.

A few families book a handful of summer lessons before Grade 11, so loops and functions feel familiar on day one. More arrive in Grade 12, once projects span several files and an outside reviewer earns their keep.

| Where in BC | UTC offset | India time is ahead by | Changes in 2026 to 2027? |
| --- | --- | --- | --- |
| Most of BC, including Vancouver and Victoria | UTC-7 | 12 hours 30 minutes | No: permanent since 8 March 2026 |
| East Kootenay and Golden | UTC-6 | 11 hours 30 minutes | No |

After the spring change on 8 March 2026, BC stopped moving its clocks. In the government’s words, “Pacific time will be set seven hours behind co-ordinated universal time (UTC-7)”, so a lesson booked for a BC afternoon keeps its slot through November and beyond. Ontario and Quebec still change their clocks, which matters only if your teen also takes a class with someone in the east. Our [Canada time zones page](/canada-time-zones-2026-online-class-times) lays out every province.

Where your teen is now

## Four stages of a BC senior programmer

How we see BC teens grow through these courses, in four steps we use for placement.

| Stage | What it looks like |
| --- | --- |
| 1. Follower | Types in the class example and gets it running, but changing it breaks it |
| 2. Predictor | Says what a short program will print before running it, and checks |
| 3. Tester | Writes requirements and an expected-output table before the code |
| 4. Maintainer | Finds a fault in a multi-file project with a debugger, and explains the fix |

### For parents

Ask your teen to show you the test table for their latest program. If there is not one, that is the most useful thing to add this month.

A teen stuck at stage 1 is not behind in talent. They have usually been shown answers instead of being asked to predict them.

### For students

Before running anything, write one line: what you expect to see. Over a term, those lines become the best revision notes you own.

When a partner navigates for you, let them finish the sentence before you change the code. Half the bugs get found that way.

The catalogue

## Nine more courses for BC senior students

Each runs live, with the same teacher every week, either as a group or for one student.

I

### Beside the school course

Grades 10, 11 and 12

COP / SCH / 01

#### Git and GitHub for teens

Commit history for CP 12 team projects.

[Open the syllabus](/courses/git-github-version-control-course-for-teens)

COP / SCH / 02

#### JavaScript for teens

Interfaces and browser projects after Web Development 10.

[Open the syllabus](/courses/javascript-course-for-teens-beginners-interactive-web)

COP / SCH / 03

#### C++ for teens

A fast, strict language for contest-minded students.

[Open the syllabus](/courses/cpp-programming-masterclass-for-teens)II

### Contests and team builds

Grades 9 to 12

COP / CON / 01

#### CCC Junior and Senior preparation

Five problems, three hours, as CEMC sets it.

[Open the syllabus](/courses/ccc-junior-and-senior-preparation-course)

COP / CON / 02

#### Competitive programming

Harder sets once the CCC feels comfortable.

[Open the syllabus](/courses/competitive-programming-for-teens-course)

COP / CON / 03

#### Hackathon preparation

A weekend build with a demo at the end.

[Open the syllabus](/courses/hackathon-prep-for-teens-coding-ai-build-innovate-win-course)III

### Math and data alongside code

Teens

COP / MTH / 01

#### Western Canada Grade 12 Math

Pre-calculus 12, the course UBC Science lists.

[Open the syllabus](/courses/western-canada-grade-12-math-pre-calculus-12-math-30-1-course)

COP / MTH / 02

#### Statistics and probability

The theory behind every simulation.

[Open the syllabus](/courses/statistics-probability-maths-course)

COP / MTH / 03

#### Data science for teens

Clean, chart and question real data in Python.

[Open the syllabus](/courses/data-science-course-for-teens-python-data)

How classes run

## Live classes set to the BC school week

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

After school in Pacific time, agreed when you choose a batch.

Weekends

Saturday or Sunday mornings in BC, evening for the teacher.

1-on-1

Planned around project deadlines and unit tests.

### Same teacher each week

Someone who knows the project history.

### The class language

Python or Java, whichever the school set.

### Pair work on screen

Driver and navigator, roles swapped.

### Assignments explained

Your teen writes every line.

### Tests and tables

Expected output before every run.

### Group or private

Fifteen to twenty, or your teen alone.

Student work

## What our students have built

Programs and projects by our students, many started in the same courses BC teens take now. More on the [student labs](/student-labs) page.

![NutriLife AI nutrition coach project screenshot](/images/projects/nutrilife.webp)

AI and ML

#### NutriLife

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

by Bhavya · [Open it](https://nutrilife-bhavya.lovable.app)

![Misti AI chatbot for maths and coding screenshot](/images/projects/misti.webp)

AI and ML

#### Misti

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

by Harshit · [Open it](https://misti.modernagecoders.com)

![GuardianX AI internet safety assistant screenshot](/images/projects/guardianx.webp)

AI and ML

#### GuardianX

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

by Vivaan · [Open it](https://guardianx-cybersaver.lovable.app)

![SkyCast weather forecast application screenshot](/images/projects/skycast.webp)

Web app

#### SkyCast

A weather forecasting site with live conditions for any location.

by Krish

Fees

## Fees

Start with a free class. Then a monthly fee covers eight live classes a month, shown in your own currency on this page, with no term contract: stop at the end of any month.

Free first class

Free

no card required

- A free first class
- Bring the current project
- No card details asked

Book it

Group batch

$140 CAD

a month, eight live classes

- Fifteen to twenty students
- A regular teacher
- Choose the batch time
- Billed month by month

Start here

One to one

$210 CAD

a month, eight live classes

- Your teen and one teacher
- Times set around deadlines
- Built on their own outline

Enquire

What families say

## Rated 4.9 across 547 Google reviews

What families and students wrote on Google, unedited.

★★★★★

"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

Questions from BC families

## Computer Programming 11 and 12: common questions

### What is Computer Programming 11 in BC?

Computer Programming 11 is a BC Applied Design, Skills, and Technologies course. Its content includes problem decomposition, pair programming, programming constructs for input and output, logic, decisions and loops, turning requirements into algorithms, pre-built libraries and their documentation, and test cases that compare expected and actual output.

### Is Computer Science 11 the same as Computer Programming 11?

No. Computer Science 11 is a Mathematics course and Computer Programming 11 is an ADST course. Both teach programming, but Computer Science 11 adds logic such as truth tables and De Morgan's laws, number systems, searching algorithms and modelling mathematical problems, while Computer Programming 11 centres on design, pair work and testing.

### Do you grant Computer Programming 11 or 12 credit?

No. We teach alongside the student's school course and we do not grant provincial credits. The credit comes from the school that teaches and assesses the course, such as the student's own school, a district summer school or an online learning school.

### What does Computer Programming 12 add?

Bigger, longer projects. Code gets organized into functions, methods or classes, and the list adds documentation with industry standard tools, self-documenting code, user interface design, error handling, a debugger that steps through code, projects with multiple source files, pre-built data structures, and bug reports and feature requests from users.

### Which language do BC computer courses use?

The curriculum pages we read do not fix a language, so it depends on the teacher; ask which one the class uses. We teach in whichever language that is, most often Python or Java, and the practice set on this page is in Python.

### What is in Computer Science 12?

Computer Science 12 is on the BC Mathematics course list. Its content page did not load when we returned to the curriculum site on 22 October 2026, so we do not describe it here. Bring the teacher's outline to the first class and we plan from that.

### Do I need Computer Programming 12 for computer science at UBC?

Not according to UBC's own list. For BC applicants to Science at UBC Vancouver, the requirements tool we read on 22 October 2026 asked for a Grade 12 English, Pre-Calculus 12, one Grade 12 science, and Chemistry 11 and Physics 11. It named no programming course.

### Is pair programming allowed, or is it cheating?

It is part of the course. Computer Programming 11 names pair programming as content: one student, the driver, types while the other, the navigator, reviews each line, and they switch roles often. Copying another pair's work is a different matter, and teachers treat it as such.

### How should my teen prepare for a Computer Science 11 test?

Keep a vocabulary page, trace two short programs on paper each day, practise binary and hexadecimal conversions and truth tables, and rebuild linear search, binary search and the greatest common factor from a blank file. A timed practice in the last week shows what still needs work.

### What times work for families in BC?

Weekdays or weekends, flexible: choose your batch, or for a very personalised plan choose 1-on-1 at your convenience, weekend mornings or weekdays. BC has stayed on UTC-7 all year since March 2026, so a class time agreed in Pacific time does not shift in November.

### How much does help with these courses cost?

Nothing for the first class. Then you pay month by month for eight live classes, with no contract for the term; leaving at a month end is fine. See the fees section above for the present group and private amounts.

Elsewhere on this site

## Related pages

More for BC students and families.

### [Coding classes in British Columbia](/coding-classes-in-british-columbia)

Our BC hub, with courses from age 6.

### [Coding classes in Canada](/coding-classes-in-canada)

The national index of our Canada guides.

### [Coding curriculum by province](/canada-coding-curriculum-by-province)

How each province files its computing courses.

### [Grade 12 math across Canada](/canada-high-school-math-courses-compared)

Pre-calculus 12 beside the other provinces’ courses.

### [CCC preparation](/canadian-computing-competition-ccc-prep)

The Waterloo contest for school programmers.

### [How to debug code](/how-to-debug-code)

A calm method for finding the faulty line.

### [Binary numbers explained](/blog/binary-numbers-explained)

Base 2 from the beginning, for question 1.

### [Logic gates for beginners](/blog/logic-gates-for-beginners)

AND, OR and NOT drawn as circuits.

### [Probability for beginners](/blog/probability-for-beginners)

The counting behind the dice problem.

Start here

## Book a free first class

Tell us which course it is (CP or CS, 11 or 12), the class language and the next deadline. The first class starts with the student’s current assignment.

Want to look around first? Read [how a class with us runs](/how-we-teach), or compare the [Python for Teens syllabus](/courses/python-complete-masterclass-teens) with your teen’s outline.

[WhatsApp us](https://wa.me/919123366161?text=Hello%20Modern%20Age%20Coders%2C%20my%20teen%20in%20BC%20is%20taking%20Computer%20Programming%2011%20(or%20Computer%20Science%2011)%20and%20would%20like%20help%20alongside%20the%20school%20course.%20Could%20we%20book%20a%20free%20first%20class%3F) · [+91 91233 66161](tel:+919123366161) · [connect@modernagecoders.com](mailto:connect@modernagecoders.com)

All classes are live video lessons with teachers based in India. Nobody comes to your home and there is nowhere in BC to drive to; WhatsApp is the fastest way to reach us.

### Want a class sooner? Book a priority demo

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](/book-demo)

## Keep exploring Modern Age Coders

### Related courses and guides

- [Computer Science Extracurriculars, Ranked by What Actually Counts](/computer-science-extracurriculars)
- [Competitive Programming in Australia](/competitive-programming-australia)
- [Computer Science Graduation Requirements by State](/computer-science-graduation-requirements-by-state)
- [Coding Summer Camp for Middle Schoolers: Grades 6 to 8](/coding-summer-camp-for-middle-schoolers)
- [Computer Science Internships for High School Students](/computer-science-internships-for-high-school-students)
- [How to Start Coding: Which Language First & The Full Roadmap (Ages 6–67)](/coding-roadmap)
- [Full Stack Software Development Course](/full-stack-software-development-course-ireland)
- [Mobile App Development Company](/mobile-app-development-services)
- [Coding Classes for Kids in Cambridge, Ontario](/coding-classes-for-kids-in-cambridge-ontario)
- [Best Coding Classes in Logan](/best-coding-classes-in-logan)

### Learn more

- [Grade 6 Math and Coding Help, Ontario: Strands and Practice](/ontario-grade-6-math-and-coding-help)
- [MHF4U Advanced Functions Tutor: Grade 12 Help and Exam Prep](/mhf4u-advanced-functions-tutor)
- [Pre-calculus 12 BC Tutor: Units, Practice Questions, Plan](/pre-calculus-12-tutor-bc)
- [Foundations of Math 11 BC Tutor: Curriculum, Practice, Help](/foundations-of-math-11-tutor-bc)

### Free resources

- [HTML & CSS Tutorial: Build Websites from Scratch](/resources/html-and-css)
- [Dynamic Memory Allocation (new, delete)](/resources/cpp/dynamic-memory-allocation)
- [Headings, Paragraphs, and Text Formatting](/resources/html-and-css/headings-paragraphs-and-text)
- [Loops (for, while, do-while) and Patterns](/resources/cpp/loops-in-cpp)

### From the blog

- [Coding Interview Preparation for Freshers: A Plan](/blog/coding-interview-preparation-for-freshers)
- [The IB Computer Science IA No Longer Needs a Client](/blog/ib-computer-science-ia-client-rule-2027)
- [PCEP vs PCAP: Which Python Certification Is Worth It?](/blog/pcep-vs-pcap-which-python-certification)

### Start here

- [How Modern Age Coders teaches, small batches and real projects](/how-we-teach)
- [What Modern Age Coders families say](/love)

Free class[Priority demo](/book-demo)[Call us](tel:+919123366161)

---

*Canonical: https://learn.modernagecoders.com/computer-programming-11-and-12-bc*