## Key Ideas > [!abstract] Core Concepts > > - **Studying examples beats solving problems for novices**: Research shows novices learn better from examining worked solutions than attempting problems independently > - **Structure determines effectiveness**: Examples must minimise extraneous cognitive load through careful design-poorly structured examples can harm learning > - **Persist far longer than intuition suggests**: Continue using examples until complete familiarity, not just basic understanding-typical abandonment happens far too early ## Definition **Worked Examples**: Step-by-step demonstrations of complete solution procedures with explanations, designed to reduce cognitive load and enable efficient schema construction by showing novice learners how experts solve problems. ## Overview Worked examples are step-by-step demonstrations showing complete solution procedures with explanations. Novice learners benefit more from studying worked examples than from attempting to solve problems independently (Atkinson et al., 2000; Sweller & Cooper, 1985). When students lack schemas for content, problem-solving consumes working memory through trial-and-error rather than schema construction. Worked examples reduce this cognitive load by presenting complete solution paths, allowing students to focus on understanding the method rather than generating solutions. Effective use requires understanding their design principles and duration of use. ## Connected To [[Worked-Example Effect]] | [[Cognitive Load Theory]] | [[I Do]] | [[We Do]] | [[Explicit Teaching]] | [[Scaffolding]] | [[Self-Explanation Effect]] | [[Split-Attention Effect]] | [[Redundancy Effect]] | [[Expertise Reversal Effect]] --- ## The worked-example effect The worked-example effect is a finding in educational psychology demonstrating that novices learn more efficiently from studying worked solutions than from attempting to solve problems independently. ### The foundational research **Sweller and Cooper's seminal studies** established the effect through carefully designed experiments (Sweller & Cooper, 1985): **The problem-solving condition**: Students received problems to solve with minimal guidance, learning through trial and error and teacher feedback. **The worked-example condition**: Students studied complete worked solutions showing step-by-step solution paths, then immediately practiced near-identical problems. **The results**: Students in the worked-example condition: - Learned solution procedures faster - Made fewer errors during learning - Transferred knowledge to novel problems more successfully - Required less instructional time to reach competence These advantages appear for novice learners. The effect reverses as expertise develops, so instruction should adapt to schema development. ### Why the effect occurs [[Cognitive Load Theory]] explains why worked examples are effective for novices: **Problem-solving consumes working memory through means-end analysis**: When novices lack solution schemas, they must use means-end analysis-trying approaches, checking if they're getting closer to the goal, backtracking when they're not (Sweller et al., 1983). This search process consumes extensive working memory resources: - Holding the problem goal in mind - Remembering what's been tried - Evaluating whether attempts approach the solution - Deciding what to try next - Managing frustration when attempts fail **Little working memory remains for learning**: After means-end analysis fills working memory, minimal capacity remains for the actual purpose-constructing schemas for the solution method. Students might eventually solve the problem, but learning the generalizable procedure fails because working memory was consumed by the search process, not schema construction. **Worked examples eliminate search demands**: By presenting complete solutions, worked examples remove means-end analysis from working memory demands. Students can devote full cognitive resources to understanding the solution method-processing each step, seeing how it connects to the overall goal, integrating the procedure into developing schemas. **The result**: More efficient schema construction with less cognitive strain, faster learning, and better transfer. ### The critical misconception: what most teachers get wrong Despite research clarity, most classroom implementations misunderstand the worked-example effect: **What teachers typically do**: Present two or three worked examples, explain them, then ask students to solve a set of related problems. **What research shows works**: Present one worked example, have students immediately solve a near-identical problem, repeat this alternation multiple times (McLaren et al., 2008; Trafton & Reiser, 1993). **Why this distinction matters**: Showing multiple examples before practice is the problem-solving condition: students must search through memory to recall which example applies and how to adapt it. True worked examples alternate individual examples with immediate practice, maintaining focus whilst schemas are still fresh in working memory. This misunderstanding explains why many teachers report worked examples "don't work": they never implemented the approach research demonstrates as effective. ## The two essential principles: structure and persist Effective worked examples require adherence to two key principles. ### Principle 1: structure-minimising extraneous cognitive load **The principle**: Worked examples must be designed to minimise every source of extraneous cognitive load, freeing working memory capacity for learning the solution method. **Why structure matters**: Poorly designed worked examples can be less effective than problem-solving. When examples impose cognitive burdens through split-attention, redundancy, or transient information, the advantage of worked examples diminishes (Chandler & Sweller, 1991). **What careful structure requires**: **Eliminate split-attention**: Integrate text explanations directly with the mathematical or visual content they explain (Chandler & Sweller, 1992). Separating explanations from working imposes cognitive load. **Poor design**: Explanation at top of page, working shown below-students must hold explanation in working memory whilst searching for the relevant part of the working. **Better design**: Each step of working has its explanation immediately adjacent-"We multiply both sides by 4" appears right next to the step showing this multiplication. **Avoid redundancy**: Don't speak an explanation whilst it's written for students to read (Sweller et al., 2010). This forces working memory to process identical information through two channels, creating interference rather than reinforcement. **Poor practice**: Reading aloud what's written on the worksheet whilst students read along. **Better practice**: Show written worked example for students to read at their own pace OR explain verbally whilst students listen, not both simultaneously. **Prevent transience**: Provide permanent written versions of examples (Leahy & Sweller, 2011). Information that disappears before processing completes forces students to hold it in working memory whilst trying to process subsequent steps. **Poor practice**: Only showing worked examples on board that get erased, or verbal explanations without written reference. **Better practice**: Providing printed worked examples students can study repeatedly, refer back to, and review later. **Chunk complex procedures**: Break solution paths into visually distinct steps, each representing one meaningful decision or operation. Present like IKEA instructions or comic panels-discrete, digestible chunks rather than continuous text. **Poor design**: Dense paragraph explaining entire solution in running text. **Better design**: Numbered or boxed steps, each showing one operation with its brief explanation, creating clear progression students can follow step-by-step. ### Principle 2: persist-continuing far longer than intuition suggests **The principle**: Continue providing worked examples far longer than traditionally thought necessary: until students demonstrate complete familiarity and automaticity, not just basic understanding. **Why teachers abandon examples too early**: Expert teachers possess automated schemas that make procedures feel simple. Their intuition about when students are "ready" to practice independently reflects expert perception, not novice reality. The point where worked examples feel unnecessary to teachers often marks when students still need them most. **What "persist" actually means**: **Complete familiarity, not basic familiarity**: Students should reach the point where encountering a problem type triggers automatic schema activation, not conscious recall of the method. This requires extensive exposure-far more than the 2-3 examples teachers typically provide. **Evidence-based persistence**: Continue until success rates on practice problems exceed 80% consistently. Lower success indicates schemas aren't yet robust, so more worked examples would benefit learning. **Gradual fading**: Don't jump from worked examples directly to independent problem-solving. Use completion problems (partially worked examples where students complete missing steps) to bridge the transition. This maintains support whilst building independence. **Persist despite discomfort**: Continuing worked examples when it feels like students "should be ready" requires trusting research over intuition. The discomfort teachers feel at "not challenging students enough" often indicates the right level of support for schema construction. ## Designing effective worked examples: content selection Beyond structure and persistence, specific content choices determine whether examples enable or prevent learning. ### Keep arithmetic simple **The principle**: When teaching procedures, use numbers that minimise calculation burden so cognitive resources focus on the method, not arithmetic. **Why this matters**: If students must consciously calculate whilst learning a procedure, working memory divides between the calculation and the method. The procedure (what you're teaching) gets shortchanged. **Application**: - Teaching fraction addition? Use fractions with easily found common denominators ($\frac{1}{2} + \frac{1}{4}$ rather than $\frac{5}{12} + \frac{7}{18}$) - Teaching algebraic manipulation? Use small whole numbers ($3x + 5 = 17$ rather than $7.3x - 4.8 = 12.1$) - Teaching substitution? Choose values that make arithmetic straightforward **Later complexity**: Once procedures are automated, increase arithmetic complexity to build robustness. But during initial learning, simple arithmetic is essential, not "dumbing down." ### Start with general examples, not "simple" cases **The principle**: Use examples that require executing all steps of the general procedure, even if this seems more complex initially. **Why "simple" examples harm learning**: Examples like $(x+1)(x+1)$ for expanding brackets hide the general procedure because the numbers create patterns not representative of the general case. Students learn the specific pattern (middle term is double the constant) rather than the general method (multiply everything in the first bracket by everything in the second). **What happens later**: When encountering $(2x+3)(5x-4)$, students who learnt from $(x+1)(x+1)$ lack the general procedure and must learn from scratch. The "simple" example wasted time. **Better approach**: Use examples like $(2x+5)(3x+7)$ that require full execution of the general procedure (Paas & van Merriënboer, 1994): - First terms: $2x \times 3x = 6x^2$ - Outer terms: $2x \times 7 = 14x$ - Inner terms: $5 \times 3x = 15x$ - Last terms: $5 \times 7 = 35$ - Combine: $6x^2 + 29x + 35$ All steps visible, general procedure clear, no hidden special cases. ### Avoid misleading number patterns **The principle**: Don't use examples where numbers coincidentally create patterns that won't generalise. **Why this matters**: Patterns in worked examples powerfully influence what students learn. If examples accidentally contain patterns not representative of the general procedure, students construct defective schemas. **Example of problematic pattern**: Teaching exponent rules with $2^2 = 4$-the base and exponent matching the result creates a pattern that's coincidental, not generalizable. Students might incorrectly conclude the pattern holds generally. **Better practice**: Use varied numbers that prevent pattern over-learning whilst keeping arithmetic manageable: $2^3 = 8$, $3^2 = 9$, $5^2 = 25$-no false patterns, general principle visible. ## Visual design principles: making examples scannable and clear How examples appear visually affects how effectively students learn from them. ### Integrate text and working **The design challenge**: Students need both the mathematical working and explanations of what each step accomplishes, but separating them creates split-attention. **Poor design**: ``` Steps: 1. Multiply both sides by 4 2. Simplify to get x = 12 Working: x/4 = 3 x = 12 ``` Students must look back and forth, losing context with each shift of attention. **Better design**: ``` x/4 = 3 x/4 × 4 = 3 × 4 ← Multiply both sides by 4 x = 12 ← Simplified ``` Explanation appears exactly where it's needed, eliminating attention-switching. ### Separate question from working visually **The design challenge**: Students must distinguish the problem they're solving from the solution method being demonstrated. **Visual strategies**: - Use different colours (problem in black, working in blue) - Different fonts or sizes - Boxes or borders separating problem from solution - Clear "Question:" and "Solution:" labels **Why this helps**: Visual distinction reduces working memory burden of tracking "Which part am I reading?" and prevents confusion between problem and solution. ### Chunk complex procedures into steps **The design challenge**: Long procedures overwhelm when presented as continuous text-students lose track of progression. **The chunking solution**: Present like instruction manuals or comic strips-discrete, visually separated steps students process one at a time. **Implementation**: - Number each major step - Use boxes, borders, or spacing to isolate steps visually - Each chunk represents one decision or operation - Progressive revelation possible-show one step, discuss, show next **Example structure**: ``` Step 1: Expand the brackets (2x + 3)(x - 5) = 2x² - 10x + 3x - 15 Step 2: Collect like terms 2x² - 10x + 3x - 15 = 2x² - 7x - 15 Step 3: Check by substitution (x = 0): 2(0)² - 7(0) - 15 = -15 ✓ ``` Each step digestible independently, overall progression clear. ## Types of examples: building complete understanding Different types of worked examples serve different learning purposes, all contributing to robust schema development. ### Examples and non-examples for concept learning **When teaching concepts** (rather than procedures), students need to discern critical features from irrelevant ones. **Strategy**: Show what something IS and what it ISN'T: **Teaching prime numbers**: - Examples: 2, 3, 5, 7, 11, 13 (with explanation: exactly two factors) - Non-examples: 1 (only one factor), 4 (three factors: 1, 2, 4), 6 (four factors) **Teaching perpendicular lines**: - Examples: Various orientations of 90° intersections - Non-examples: Parallel lines, acute angle intersections, lines that don't meet **Why this works**: Contrasting examples and non-examples helps students identify the critical attributes (exactly two factors, 90° angles) and ignore irrelevant features (which numbers, line orientation). ### Multiple examples for pattern recognition **The need**: Students require multiple examples to extract the general procedure from specific instances. **Minimum requirement**: At least 2-3 examples per problem type, but typically 5-8 needed for robust schema construction. **Variation strategy**: Change only one critical feature between consecutive examples so students see what varies and what stays constant: **Teaching solving linear equations**: 1. $2x + 5 = 17$ (basic structure) 2. $3x + 5 = 17$ (coefficient changes) 3. $3x + 8 = 17$ (constant changes) 4. $3x - 8 = 17$ (operation changes) Each variation reveals which features matter and which are incidental to the general method. ### Sequences for pattern discovery **The strategy**: Carefully sequence examples so patterns become visible: **Teaching subtracting negative integers**: - $5 - (-2) = 7$ - $3 - (-4) = 7$ - $1 - (-6) = 7$ - $0 - (-7) = 7$ The consistent result (7) makes the pattern visible: subtracting a negative adds its absolute value. The final example (starting from 0) clarifies the effect. ### Boundary and edge cases **The need**: General schemas must include understanding of where procedures apply and where they don't. **Strategy**: Include worked examples that: - Look routine but have unexpected features - Represent boundaries of procedure applicability - Demonstrate common error situations **Example**: When teaching polynomial division, include examples where: - The divisor doesn't go in evenly (remainder exists) - Terms are missing in the polynomial (need placeholders) - The leading coefficient isn't 1 Students learn the full scope of the procedure, not just the easy cases. ## Implementation strategies: from theory to practice Understanding worked examples theoretically doesn't guarantee effective classroom implementation. Specific strategies bridge the gap. ### The alternation strategy: example-practice-example-practice **The core implementation**: Present one worked example, immediately have students practice one near-identical problem, repeat. **Why this works**: - Schema is fresh in working memory during practice - Immediate application strengthens encoding - Success builds confidence for next example - Prevents working memory overload from multiple examples **Typical sequence**: 1. Teacher demonstrates example 1 2. Students practice problem 1 (near-identical to example 1) 3. Check answers, address errors 4. Teacher demonstrates example 2 (slight variation) 5. Students practice problem 2 6. Continue alternating until procedure is automatic **Not this**: Show 3 examples, then give 10 practice problems-this is the less effective problem-solving condition. ### Avoiding transience: making examples permanent **The problem**: Worked examples shown only on board or explained only verbally create transient information-it disappears before students finish processing. **The solution**: Always provide permanent written versions: **Printed booklets**: Worked examples in booklets students can: - Study at their own pace - Refer back to during practice - Review when uncertain - Keep for future reference **Clear worksheets**: If not booklets, provide worksheets with: - Worked examples at top - Practice problems below - All on same page (no flipping between pages) **What to avoid**: - Expecting students to copy worked examples whilst you explain - Showing examples only on board that get erased - Verbal-only explanations without written reference Copying divides attention between listening and writing-students miss explanation whilst writing, or miss working whilst listening. Transient presentations prevent the repeated study that builds robust schemas. ### Subgoal labelling: making structure visible **The strategy**: Explicitly label the major steps or subgoals in worked examples, making the procedure's structure visible. **Implementation**: ``` Goal: Solve for x Subgoal 1: Eliminate the fraction x/4 + 3 = 7 x/4 = 4 (subtract 3 from both sides) Subgoal 2: Isolate x x = 16 (multiply both sides by 4) ``` **Benefits**: - Makes goal hierarchy explicit - Helps students organise their understanding - Improves transfer to novel problems - Supports [[Self-Explanation Effect|self-explanation]] **Research evidence**: Subgoal-labelled examples produce better learning and transfer than unlabelled examples, especially for complex procedures (Catrambone, 1998). ### Self-explanation: increasing germane load productively **The strategy**: After studying a worked example, have students explain to themselves (not peers) why each step works (Chi et al., 1989; Renkl, 1997). **Implementation**: - "Read through this worked example" - "Now explain to yourself why each step was necessary" - "What would happen if we skipped step 2?" **Why to themselves, not peers**: For novices, explaining to peers creates additional cognitive load from social interaction, audience consideration, and managing the explanation process. Self-explanation provides the benefits without the extraneous load. **When to use**: After students have studied multiple examples and have partial understanding. Self-explanation too early (when schemas barely exist) frustrates because students lack knowledge to explain. **Benefits**: - Deepens understanding of underlying principles - Connects procedural knowledge to conceptual understanding - Reveals gaps in understanding - Increases germane cognitive load when students are ready for it ## Fading worked examples: the transition to independence Worked examples shouldn't continue forever-expertise development requires transitioning to independent problem-solving. The transition method matters critically. ### Completion problems: the bridge to independence **The strategy**: Gradually fade worked examples by providing completion problems-partially worked examples where students complete missing steps (Atkinson et al., 2003; Renkl & Atkinson, 2003). **Progression**: **Stage 1-Full worked example**: ``` Solve: 3x + 5 = 17 3x = 12 (subtract 5) x = 4 (divide by 3) ``` **Stage 2-Complete final step**: ``` Solve: 3x + 5 = 17 3x = 12 (subtract 5) ____ (now you complete) ``` **Stage 3-Complete last two steps**: ``` Solve: 3x + 5 = 17 ____ (now you complete) ____ ``` **Stage 4-Complete independently**: ``` Solve: 3x + 5 = 17 (Solve completely) ``` **Why this works**: Completion problems maintain support whilst building independence (van Merriënboer, 1990). Each stage reduces scaffolding gradually based on developing competence, not arbitrary timelines. ### Evidence-based fading decisions **When to fade**: Base decisions on evidence, not planned timelines: **Success rate above 80%**: Consider reducing support-students demonstrating consistent success probably have robust enough schemas for less guidance. **Success rate below 80%**: Maintain or increase support-students still building schemas need continued worked examples. **What this requires**: Systematic checking of practice problem success rates, not assumptions about readiness. **Common error**: Fading based on "we're on lesson 3, time to move to independent practice" rather than evidence of schema development. ## The expertise reversal effect: when examples become counterproductive **The critical principle**: Worked examples benefit novices but hinder experts-optimal instruction must adapt to developing competence (Kalyuga et al., 2003). ### Why the reversal occurs **For novices**: Worked examples reduce cognitive load by eliminating means-end analysis, freeing working memory for schema construction. **For developing experts**: Students with robust schemas don't need means-end analysis-they recognise problem types and activate appropriate procedures automatically. Forcing them to study worked examples: - Wastes time processing information they've automated - Bores students unchallenged by material they've mastered - Slows down their automated processing - Prevents the productive struggle that strengthens schemas ### Implications for differentiation **The challenge**: Students in the same class often possess different levels of expertise, requiring different approaches. **Strategic responses**: **Flexible grouping**: Novices study worked examples whilst developing experts solve problems independently. **Completion problems for middle ground**: Students with partial expertise complete partially worked examples, receiving support where needed whilst practicing where ready. **Self-paced progression**: Allow students to move from examples to practice based on demonstrated competence, not class-wide timelines. **What doesn't work**: Forcing all students through identical worked examples regardless of expertise-wastes advanced students' time whilst potentially still rushing novices. ## Common pitfalls: what undermines worked example effectiveness Even understanding worked examples doesn't guarantee effective implementation. Several common errors undermine their power. ### Pitfall 1: using "simple" examples that hide the procedure **The error**: Choosing examples like $(x+1)(x+1)$ because they "seem easier" for students. **Why it fails**: Special cases hide the general procedure. Students learn the specific pattern rather than the method, then fail when encountering general cases. **The solution**: Use examples requiring full execution of the general procedure, even if this seems initially harder. Students learn the complete method once rather than learning twice (special case then general case). ### Pitfall 2: redundant verbal and written explanations **The error**: Reading aloud what's written on worksheets whilst students read along. **Why it fails**: Creates [[Redundancy Effect]]-forcing working memory to process identical information through both visual and auditory channels. The redundancy creates interference, not reinforcement. **The solution**: Present information once in the most effective modality. Either show written worked examples students read silently, OR explain verbally whilst students listen without reading, not both simultaneously. ### Pitfall 3: complex arithmetic distracting from the procedure **The error**: Using numbers that make arithmetic difficult, believing this "challenges" students appropriately. **Why it fails**: When students struggle with calculation whilst learning a procedure, working memory divides between arithmetic and method. The procedure-what you're teaching-gets inadequate processing. **The solution**: Keep arithmetic simple during initial learning. Once the procedure is automated, increase arithmetic complexity to build robustness. But during schema construction, minimise calculation burden. ### Pitfall 4: abandoning examples too early **The error**: Providing 2-3 examples then moving to independent practice, believing students are "ready." **Why it fails**: Teachers underestimate how many examples students need for robust schema construction. Expert perception ("this is simple") blinds teachers to novice reality ("this is complex and overwhelming"). **The solution**: Persist with worked examples far longer than feels necessary. Use 80%+ success rate on practice problems as the evidence-based indicator of readiness, not intuition or curriculum pacing guides. ### Pitfall 5: bundling examples before practice **The error**: Showing multiple examples then asking for practice-the typical classroom implementation. **Why it fails**: This is the problem-solving condition, not the worked-example effect. Students must search memory for which example applies and adapt it-precisely the means-end analysis worked examples should eliminate. **The solution**: Alternate individual examples with immediate practice on near-identical problems. One example, one practice, repeat. This keeps schemas fresh in working memory during practice. ## Summary Worked examples are an evidence-based instructional strategy in which novices learn from studying worked solutions rather than attempting problems independently (Atkinson et al., 2000; Sweller & Cooper, 1985). Problem-solving consumes working memory through means-end analysis (Sweller et al., 1983), whilst worked examples eliminate this burden, allowing cognitive resources to focus on understanding methods and constructing schemas. Effective implementation requires two principles. First, structure: examples must minimise extraneous cognitive load through integration of text and working (Chandler & Sweller, 1992), elimination of redundancy (Sweller et al., 2010), and clear visual design. Second, persistence: examples should continue until automation develops, not merely basic understanding. Implementation involves specific design choices: simple arithmetic that focuses attention on procedures, general examples requiring full method execution (Paas & van Merriënboer, 1994), and gradual fading through completion problems (Atkinson et al., 2003; Renkl & Atkinson, 2003). The expertise reversal effect indicates that instruction should adapt as competence develops (Kalyuga et al., 2003). Common errors include using special-case examples that hide general procedures, creating redundant explanations, allowing complex arithmetic to distract from methods, abandoning examples prematurely, and presenting multiple examples before practice rather than alternating example and practice. > [!tip] Implications for Teaching > > - **Alternate examples and practice** one-to-one, not multiple examples then practice-keeps schemas fresh during application > - **Structure examples carefully** to minimise split-attention, redundancy, and transience-poor design undermines effectiveness > - **Use simple arithmetic** when teaching procedures so cognitive resources focus on method, not calculation > - **Persist far longer than intuition suggests**-continue until 80%+ success rates, not when examples feel unnecessary > - **Use general examples** requiring full procedure execution, not "simple" special cases that hide the method > - **Provide printed permanent examples** students can study repeatedly, not transient board displays > - **Fade through completion problems** gradually removing steps as competence develops, maintaining support whilst building independence > - **Recognise expertise reversal**-adapt from worked examples to problem-solving as schemas develop ## References Atkinson, R. K., Derry, S. J., Renkl, A., & Wortham, D. W. (2000). Learning from examples: Instructional principles from the worked examples research. *Review of Educational Research*, 70(2), 181-214. https://doi.org/10.3102/00346543070002181 Atkinson, R. K., Renkl, A., & Merrill, M. M. (2003). Transitioning from studying examples to solving problems: Effects of self-explanation prompts and fading worked-out steps. *Journal of Educational Psychology*, 95(4), 774-783. https://doi.org/10.1037/0022-0663.95.4.774 Catrambone, R. (1998). The subgoal learning model: Creating better examples so that students can solve novel problems. *Journal of Experimental Psychology: General*, 127(4), 355-376. https://doi.org/10.1037/0096-3445.127.4.355 Chandler, P., & Sweller, J. (1991). Cognitive load theory and the format of instruction. *Cognition and Instruction*, 8(4), 293-332. https://doi.org/10.1207/s1532690xci0804_2 Chandler, P., & Sweller, J. (1992). The split-attention effect as a factor in the design of instruction. *British Journal of Educational Psychology*, 62(2), 233-246. https://doi.org/10.1111/j.2044-8279.1992.tb01017.x Chi, M. T. H., Bassok, M., Lewis, M. W., Reimann, P., & Glaser, R. (1989). Self-explanations: How students study and use examples in learning to solve problems. *Cognitive Science*, 13(2), 145-182. https://doi.org/10.1207/s15516709cog1302_1 Kalyuga, S., Ayres, P., Chandler, P., & Sweller, J. (2003). The expertise reversal effect. *Educational Psychologist*, 38(1), 23-31. https://doi.org/10.1207/S15326985EP3801_4 Leahy, W., & Sweller, J. (2011). Cognitive load theory, modality of presentation and the transient information effect. *Applied Cognitive Psychology*, 25(6), 943-951. https://doi.org/10.1002/acp.1787 McLaren, B. M., Lim, S., & Koedinger, K. R. (2008). When and how often should worked examples be given to students? New results and a summary of the current state of research. In *Proceedings of the 30th Annual Conference of the Cognitive Science Society* (pp. 2176-2181). Cognitive Science Society. Paas, F., & van Merriënboer, J. J. G. (1994). Variability of worked examples and transfer of geometrical problem-solving skills: A cognitive-load approach. *Journal of Educational Psychology*, 86(1), 122-133. https://doi.org/10.1037/0022-0663.86.1.122 Renkl, A. (1997). Learning from worked-out examples: A study on individual differences. *Cognitive Science*, 21(1), 1-29. https://doi.org/10.1207/s15516709cog2101_1 Renkl, A., & Atkinson, R. K. (2003). Structuring the transition from example study to problem solving in cognitive skill acquisition: A cognitive load perspective. *Educational Psychologist*, 38(1), 15-22. https://doi.org/10.1207/S15326985EP3801_3 Sweller, J., & Cooper, G. A. (1985). The use of worked examples as a substitute for problem solving in learning algebra. *Cognition and Instruction*, 2(1), 59-89. https://doi.org/10.1207/s1532690xci0201_3 Sweller, J., Mawer, R. F., & Ward, M. R. (1983). Development of expertise in mathematical problem solving. *Journal of Experimental Psychology: General*, 112(4), 639-661. https://doi.org/10.1037/0096-3445.112.4.639 Sweller, J., van Merriënboer, J. J. G., & Paas, F. (2010). Cognitive architecture and instructional design: 20 years later. *Educational Psychology Review*, 31(2), 261-292. https://doi.org/10.1007/s10648-019-09465-5 Trafton, J. G., & Reiser, B. J. (1993). Studying examples and solving problems: Contributions to skill acquisition. In *Proceedings of the 15th Annual Conference of the Cognitive Science Society* (pp. 1017-1022). Cognitive Science Society. van Merriënboer, J. J. G. (1990). Strategies for programming instruction in high school: Program completion vs. program generation. *Journal of Educational Computing Research*, 6(3), 265-285. https://doi.org/10.2190/4NK5-17L7-TWQV-1EKN