Coding classes in La Molina, Lima

Figures copied from the data behind EF's Peru page for its 2025 English Proficiency Index, consulted 8 November 2026. The index is built from adults who take its online test; the youngest group it reports is 18 to 20, so it says nothing directly about children. The 60-point gap is our arithmetic.

1. Recap, five minutes. The learner explains last week's program in two or three sentences: what it does and one thing that went wrong. The mentor listens, then asks one question.
2. The new idea, ten minutes. The mentor introduces a concept on the shared screen, slowly, and asks the learner to predict what a short piece of code will print before running it. Predicting aloud is the key habit.
3. Building, thirty minutes. The learner writes code while thinking aloud. When stuck, they describe the problem in English rather than just pointing; half the time, describing it is enough to solve it.
4. Testing, ten minutes. The learner chooses a case that might break the program, says why, and runs it. This is where the reasoning gets sharp.
5. Summary, five minutes. One sentence on what was learned, one on what is still unclear. The mentor writes a short note for parents.

For a child of seven the hour is shorter and simpler: "first", "then", "repeat", "if". For an adult, the conversation is closer to a code review at work. At every age, the learner is the one doing most of the talking about their own program, which is rare in a school English lesson.

We teach in English only. A learner who reaches for a Spanish word is understood and offered the English one; nobody is corrected harshly. Our page on learning coding and English together in Peru goes further into how the two skills support each other.

grid = [
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0],
]

def neighbours(g, r, c):
    total = 0
    for dr in (-1, 0, 1):
        for dc in (-1, 0, 1):
            if (dr or dc) and 0 <= r + dr < 5 and 0 <= c + dc < 5:
                total += g[r + dr][c + dc]
    return total

def show(g):
    for row in g:
        print("".join("#" if cell else "." for cell in row))

for r in range(5):
    for c in range(5):
        n = neighbours(grid, r, c)
        if grid[r][c] == 1 and n not in (2, 3):
            grid[r][c] = 0
        elif grid[r][c] == 0 and n == 3:
            grid[r][c] = 1
show(grid)

# grid, neighbours() and show() as in Version 1, without its last loop
def step(g):
    new = [[0] * 5 for _ in range(5)]
    for r in range(5):
        for c in range(5):
            n = neighbours(g, r, c)
            if g[r][c] == 1 and n in (2, 3):
                new[r][c] = 1
            elif g[r][c] == 0 and n == 3:
                new[r][c] = 1
    return new

once = step(grid)
show(once)
print("Back after two steps:", step(once) == grid)

Version 2 never touches the old grid while it is deciding. It counts neighbours on the old grid and writes results into a fresh one, so every cell sees the same "before". The vertical line becomes horizontal, and after a second step it is back where it started, which the program checks for us. Programmers call this keeping two buffers; the habit is read from the old, write to the new.

The same bug turns up far from games: a spreadsheet formula that refers to a cell it has just changed, a program that edits a list while looping over it, a database update that reads its own half-finished work. Once a learner has watched a blinker die for this reason, they recognise the pattern everywhere.

1. Ages 8 to 10, on squared paper. Draw the blinker and apply the rules by hand, writing the next grid on a new sheet. Then try doing it on the same sheet with an eraser. What goes wrong?
2. Ages 11 to 13. Run Version 1 and explain, in English, which cell died first and why the next one followed.
3. Ages 13 to 15. Change Version 2 to run ten steps and print each one. Try a 2 by 2 block of live cells. Why does it never change?
4. Ages 15 and over. Make the grid wrap around at the edges, so that cells on the right touch cells on the left. Write a test that shows the blinker still returns after two steps.