How to use this deck
This deck focuses on concepts that recur across introductory programming courses. The code-specific cards use Python syntax; the underlying ideas, such as variables, functions and search complexity, apply across many languages. If your course uses another language, translate the syntax rather than memorising Python as a universal rule.
Work through the cards in order. Read the question, say or write an answer from memory, then reveal the answer. Choose Again if you could not retrieve it, Hard if you needed substantial effort, Good if your answer was correct, or Easy if it was immediate and precise. Grade the answer you actually gave, not the one you wish you had given.
A MySummaries deck on programming fundamentals looks like this:
In a program, what does a variable name refer to?
A name bound to a value; the name can be used to access that value.
All 18 cards
That is a MySummaries deck, filled with programming fundamentals material. Yours is written from your own notes. Start free
Review the answers, not just the cards
For each card, compare your response with the answer. A correct keyword without the defining distinction may not be enough. For example, “equals” alone does not distinguish assignment from comparison; say that = assigns and == compares. Likewise, “a function displays a result” is not a reliable description of return: the returned value goes back to the caller, while displaying output is a separate action.
If your answer is partly right, use Hard rather than Good. That distinction matters for cards where a small condition changes the answer: range(2, 5) excludes 5, and binary search depends on sorted data. When an answer is wrong, take a moment to identify why. Did you confuse two operators, forget a boundary, or apply an algorithm without its precondition? Then grade it Again and try to state the complete answer once more.
The MySummaries core checklist for this deck keeps the facts most likely to cause avoidable errors together:
Turn weak answers into a second attempt
Do not try to memorise every sentence exactly. Aim to retrieve the rule and its important limit. For a complexity card, include the input-size variable and the relevant assumption. For a Python card, give the syntax and what it does. For a definition, make the contrast clear where one is asked for.
After a session, sort the misses into a few practical causes:
- Syntax recall: you know the idea but mix up symbols or language details.
- Concept confusion: you treat two different operations, such as returning and printing, as interchangeable.
- Boundary or precondition miss: you forget that a range stop is excluded or that binary search needs sorted input.
- Complexity reasoning: you state a growth rate without relating it to input size or loop structure.
Choose a small next action for each cause. For syntax, write a tiny example and predict its result. For concept confusion, explain the contrast in one sentence. For a boundary miss, test the smallest or last relevant value. For complexity, count how many times the main operation runs as the input grows. Then revisit the missed card in a later session rather than immediately repeating the entire deck.
A MySummaries remediation card from a repeated binary-search mistake could look like this:
You lost this mark twice: what must be true of the data before binary search can safely discard half of the remaining search range?
A short routine for using the deck
In a first session, attempt all 18 cards and grade each one honestly. Spend a few minutes afterwards on the cards marked Again: give the answer in your own words and make a tiny example for any syntax or boundary rule you missed.
In the next review, start with cards due for practice rather than rereading the whole deck. For each correct answer, try to give the reason as well as the fact: why does binary search need sorted data, or why is a pair of nested n-step loops usually quadratic? If you can state the answer but cannot explain the condition behind it, grade it Hard.
Finally, connect the cards to code you are already studying. Trace a loop with a small input, call a function and inspect its returned value, or compare a linear scan with a binary search on sorted items. Keep each exercise small enough that you can predict the result before running it. Flashcards help retrieve definitions and rules; short code traces check whether you can apply them.
How MySummaries helps
Build a programming fundamentals revision board from your own course notes, then use it to generate and review topic-specific flashcards. Start at MySummaries.