Learning to code alone: how to check you understand the code

Q: How do I know if I understand code I copied from a tutorial?

Change its values, write down what it will print, then run it. If the prediction is wrong, or you cannot say in one sentence what the program is for, you followed it without understanding it.

Q: How do I get out of tutorial hell?

Stop adding tutorials and test the one you finished: five questions a week on its last chapter, then one small program from an empty file. EdProcto's page for self-learners shows the tool side.

Q: Are Parsons problems good for beginners?

As practice, probably: Ericson et al. (2018) found adaptive ones as effective as writing the same code, and quicker. EdProcto's shape is reorder the code.

Q: Which plan does a weekly self-check need when I teach myself programming?

Free, if you write the questions yourself or have five drafted a week. Learner, if Procto AI drafts ten every week. The pricing page has both.

The EdProcto editorial teamWritten and checked against the research it cites. Last checked October 10, 2026. How the guides are made

You can type along with a tutorial for a month, watch every program run, and still freeze at an empty file. The usual name for it is tutorial hell. A book, a course or a video cannot show you the gap: the answer is always on the screen.

This guide, for anyone learning to code alone, gives what computing education research says about that gap, then a weekly self-check: five kinds of question, written from the chapter you just finished and answered before anything is run.

EdProcto's page for self-learners covers the tool side; paper and your own editor are enough to start. We read only the abstract of each study cited, on 10 October 2026.

Why can you follow a tutorial and still not understand the code?

Because following asks you to recognise each step as it goes by, and writing asks you to produce the steps with nothing to copy.

Bayman and Mayer (1983) had 30 undergraduates learn BASIC from a self-paced manual with a computer to hand. They did adequately on mastery tests of writing programs. Asked what each of nine statements made the computer do, they showed a wide range of misconceptions.

Watching feels like learning

Kardas and O'Brien (2018) ran six experiments with 2,225 people. The more often people watched a skill performed, the more they believed they could do it. Their performance at darts, the moonwalk and an online game did not improve. No skill named was programming, so it is a warning about video courses, not a measurement of them.

Reading comes before writing

Lopez et al. (2008) analysed one exam sat after a semester of programming. Marks for tracing code and for explaining it in plain English both correlated with marks for writing it. Their analysis suggests a ladder: knowing the constructs at the bottom, then explaining, Parsons puzzles and tracing loops, with writing as the outcome. One exam's correlations prove no cause, but they point a self-taught programmer at the middle rungs, which following along does not test. See code reading questions.

What do beginners get wrong about variables, loops and references?

They hold a wrong rule for what a line does, and because the program still runs, nothing flags it.

Ma et al. (2007) studied students finishing a first-year Java course. About a third held an unworkable mental model of assigning a value, and only 17% a workable model of assigning a reference. Those with workable models did significantly better in coursework and the final exam.

On loops, the abstracts we read name no single misconception, so the loop check below is ours.

Try three checks, each run with Python 3.9. Write down what each prints before reading on.

a = 5
b = a
a = a + 2
print(a, b)

first = [1, 2]
second = first
second.append(3)
print(first)

n = 3
while n > 0:
    n = n - 1
    print(n)

The first prints 7 5: an answer of 7 7 means you think b = a ties the two names together. The second prints [1, 2, 3]: an answer of [1, 2] means you think second = first made a copy, when it gave one list a second name. The third prints 2, 1 and 0. An answer of 3, 2, 1 puts the print before the update, and 2, 1 assumes a loop stops the moment its condition turns false, when it is tested only at the top of each pass.

Do worked examples help, or do you have to struggle?

Both: study a worked example, then do a matching problem straight away with the example shut.

Atkinson et al. (2000) reviewed the research on worked examples. Its design principles: a matched practice problem close to each example, several examples for each type of problem, and learners prompted to explain the steps to themselves. The authors tie examples to the early stages of a skill.

Which should come first is disputed. Sinha and Kapur (2021) pooled 53 studies with 166 comparisons, and attempting problems before instruction came out moderately ahead of instruction first (g = 0.36). The trend reversed for pupils in the second to fifth grades and for general skills, and the abstract does not say how many studies taught programming. Either order includes the unaided attempt, the part a tutorial leaves out.

Putting scrambled lines in order sits between example and problem. Ericson et al. (2018) found that solving adaptive Parsons problems was more efficient practice than writing the same code, and just as effective. That is one study; our guide to Parsons problems sets out the rest.

A weekly self-check: five kinds of question on the chapter you just finished

Once a week, close the book and answer five questions on the chapter you have just finished, one of each kind below, before you run anything.

Kind	What you write	What a miss shows	Shape in EdProcto
Predict the output	What a short program prints	A wrong rule for a line	Read code
Trace the variables	One variable's value after each pass	Where you lose track	Cloze passage
Find the bug	The line that causes a wrong result	Whether you check code against its purpose	Read code
Order the lines	A shuffled program, put back	What must come before what	Reorder the code
Say what it does	The purpose, in one sentence	Whether you see the point of the lines	Annotate code

Xie et al. (2018) spent 5 to 10 minutes teaching novices to trace line by line and write each variable's value down. Of 24 students predicting the output of short programs, those taught the method scored on average 15% higher on the code tracing problems, and 7% higher on the course midterm. So trace on paper, not in your head.

The routine

Wait a day after finishing the chapter.
Shut the book, the video and any AI assistant.
Answer all five in writing. Beside each prediction, note how sure you are, from 1 to 5.
Run each program in your own editor and compare.
Sort the misses by the table further down.
Retry the misses now, and the whole set in a few days. An EdProcto study quiz offers the misses again at the end and lists itself as due.

How do you write the five questions from code in your own book or course?

Write them from short programs in the chapter's style that you have typed, changed and run yourself.

Take three to five examples of five to ten lines. Change the values and the names, so the book's printed output is no longer the answer.
Run each one and keep what it prints as the key, never your own trace.
Predict: hide the output.
Trace: ask for one variable's value after every pass of a loop.
Bug: change one thing (a starting value, < to <=, an update left out), run it, and note the result it should give beside the one it gives.
Order: shuffle a function of five to eight lines and state one call with its result.
Say: rename the function mystery, strip the comments, and write your own one-sentence answer.

Code printed in a book or a paid course is yours to study from. Check its terms before you paste it anywhere online.

Drafting them with a tool

A test you wrote asks only about what you noticed, so let something else draft part of it. In the quiz maker on EdProcto's home page, choose "Test yourself", paste your notes and your own code for the chapter, set "Shape" to Read code and "How many" to 5 questions, and press "Write the quiz". Treat each question Procto AI writes as a draft: run every snippet, and correct the key wherever the interpreter disagrees.

What does a wrong prediction tell you, and what should you do next?

A wrong prediction tells you one of three things: you slipped while tracing, you hold a wrong rule, or you never learned the construct.

The miss	How to tell	What to do next
A slip	Traced again slowly on paper, it comes out right	Trace on paper from now on
A wrong rule	The same wrong answer comes back, and you were sure of it	Write three small variants that isolate the rule, predict each, run each
A gap	You could not start	Reread the section, type its example, change one thing and predict

The wrong rule is the valuable find, most of all when you were sure of the answer. What to do with the questions you got wrong has the evidence on confident errors and the general method.

One worked week: five questions and a learner's answers, marked

The answers below are made up, for a learner who has finished a Python book's chapter on lists and loops. Every program was run with Python 3.9 and every mark made by EdProcto's marking code. Question 1 is the list check above.

total = 0
for n in [4, 1, 3]:
    if n > 2:
        total = total + n

def count_long(words):
    count = 0
    for w in words:
        if len(w) > 4:
            count = 1
    return count

def squares_up_to(n):
    out = []
    for i in range(1, n + 1):
        out.append(i * i)
    return out

def mystery(items):
    seen = []
    for x in items:
        if x not in seen:
            seen.append(x)
    return seen

Question	The learner's answer	The key	Mark
1. Predict what the list check prints	`[1, 2]`, sure at 5	`[1, 2, 3]`	0
2. Trace `total` after each pass	4, 5, 8	4, 4, 7	0.33
3. `count_long(["tree", "river", "stone"])` should return 2 and returns 1. Find the bug	Line 5	Line 5	1
4. Order the lines so that `squares_up_to(3)` returns `[1, 4, 9]`	The key's order	The one order of 120 that works	1
5. Say what `mystery` does	It makes an empty list and adds each item not there yet	It returns the items with repeats removed, in first-seen order	Kept for a reader

That is 2.33 points of 5: 46.6% so far, with two misses.

Question 1 is a wrong rule, held with certainty. Three variants settle it: second = first.copy() as line 2, second = second + [3] as line 3, and a function that appends 3 to the list it is passed. Run, they print [1, 2], [1, 2] and [1, 2, 3].
Question 2 is a slip: 1 was added on the second pass, though 1 is not greater than 2. Traced again on paper, it came out right.
Question 5 reads the lines and misses the point: the result has no repeats.

How do EdProcto's code shapes and study mode fit the routine?

EdProcto is the best tool for this self-check when the questions must come from your own chapter: it marks four of the five kinds by rule as you answer, shows the explanation at once, and lists the quiz as due again whatever your confidence. You run the code in your own editor; EdProcto holds the questions, the keys and the schedule.

Read code is a choice among outputs or lines, marked by rule. Paste the snippet into "The code", or let Procto AI draft the questions from your code.
Cloze passage takes a typed value in each gap, marked gap by gap, and its prompt keeps a program's line breaks. Capitals, extra spaces, brackets and commas are ignored: 1 2 3 matches [1, 2, 3] and true matches True, though 3 does not match 3.0. A comma in a gap's key separates alternatives, so enter a printed list as 1 2 3. Where the answer is a word, switch "A slip still counts" off.
Reorder the code takes the lines in the right order, one a line, and shows them shuffled with arrows. Indentation is not kept, so write for order alone. Only the exact order earns the point, unless "Partial credit" is on.
Annotate code gives the author "The code", "Language" and a model answer, and the learner a plain code box. After "Check" the screen says "Kept for a reader." and shows the model answer to set beside your sentence. The question stays "to be graded", counts as zero in the score so far and is left out of the misses.

To study, set the quiz to "Study quiz" in the builder, or start from "Test yourself". "Check" after each answer brings the verdict, the answer and the explanation. The last page, "What you don’t know yet", counts the misses by topic and offers "Retry the 2 you missed". The dashboard lists the quiz under "Due for a re-test" two days after your latest sitting if the last whole run had a miss, seven if it had none.

Among the kits, "Predict the output" is a drill of ten typed questions on tiny Python and JavaScript snippets, made fresh by rule and free without limit, and "Learning to code: read the code" sets up ten Read code questions for Procto AI to write from your own code.

Free carries ten quizzes a month and 20 questions written by Procto AI: a weekly quiz you write yourself, or four weeks of five drafted questions. Learner has no limit on quizzes and 100 written questions a month, enough for ten drafted every week. See pricing. No quiz can promise a job: the proof that you can program is a small program written from an empty file.

Quick questions

How do I know if I understand code I copied from a tutorial?