Mastery-Based Learning

Traditional:
- Fixed time, variable learning
- Move on regardless of understanding
- One chance assessments
- Gaps accumulate

Mastery-Based:
- Variable time, fixed learning
- Advance only after mastery
- Multiple attempts allowed
- Strong foundations built

Typical mastery thresholds:
- 80%: Minimum competency
- 85%: Standard mastery
- 90%: Strong mastery
- 95%: Advanced mastery

Context matters:
- Foundational skills: 90%+ (critical for later learning)
- Advanced topics: 80%+ (some uncertainty acceptable)
- Practical skills: 85%+ (can perform reliably)

Skill: Python Functions

To achieve mastery (85%), student must demonstrate:
✓ Define functions with parameters
✓ Return values correctly
✓ Call functions with arguments
✓ Understand scope
✓ Use default arguments
✓ Apply functions to solve problems

Assessment: 10 questions/tasks
- Must score 8.5+/10 (85%+)
- If score < 85%: Review and retry
- Unlimited attempts allowed

Benjamin Bloom (1984):
- Students with mastery-based instruction + tutoring 
  performed 2 standard deviations better than control
- "2 sigma problem": Can we achieve tutor-level results 
  at scale?

Modern studies show:
- Reduced achievement gaps
- Better long-term retention
- Stronger conceptual understanding
- Increased student confidence

Learning is cumulative:

Topic A (60% mastery) → Topic B (struggle)
                      → Topic C (fail)
                      → Topic D (lost)

vs.

Topic A (90% mastery) → Topic B (success)
                      → Topic C (success)
                      → Topic D (success)

Gaps compound; solid foundations enable progression.

Poor objective:
❌ "Understand loops"

Better objective:
✓ "Students will be able to:
   - Write for loops to iterate over sequences
   - Write while loops with proper exit conditions
   - Choose appropriate loop type for a problem
   - Debug common loop errors (infinite loops, off-by-one)
   - Apply loops to solve multi-step problems"

Level 1 - Remember:
→ "Recall the syntax of a for loop"

Level 2 - Understand:
→ "Explain when to use for vs while loops"

Level 3 - Apply:
→ "Use loops to process a list of numbers"

Level 4 - Analyze:
→ "Identify why a loop produces incorrect output"

Level 5 - Evaluate:
→ "Compare loop approaches and choose the best"

Level 6 - Create:
→ "Design a solution using nested loops"

Mastery requires: Levels 1-4 minimum
Advanced mastery: All levels

Not: How do you compare to others? (norm-referenced)
But: Can you do X? (criterion-referenced)

Example rubric:

Skill: Write a function to filter a list

Criteria:
□ Correct function syntax (def, parameters, return)
□ Proper iteration through list
□ Correct filtering logic
□ Handles edge cases (empty list)
□ Returns correct type (list)

Score: 5/5 criteria = Mastery
       4/5 criteria = Near mastery (retry)
       ≤3/5 criteria = Not yet (review + retry)

Knowledge checks:
- Multiple choice (quick, many items)
- True/false (misconceptions)
- Fill-in-the-blank (terminology)

Skill demonstrations:
- Coding problems (apply knowledge)
- Debugging tasks (understand errors)
- Explain code (conceptual understanding)

Transfer tasks:
- Novel problems (can they generalize?)
- Real-world scenarios (authentic application)
- Projects (integrate multiple skills)

Formative (practice):
- Low stakes
- Frequent feedback
- Identify gaps
- Guide learning
- Unlimited attempts

Example: Practice quizzes, exercises

Summative (mastery check):
- Demonstrates mastery
- Multiple attempts allowed
- Must meet threshold
- Gates progression

Example: Unit mastery test

Traditional course:
Week 1: Topic A (everyone)
Week 2: Topic B (everyone)
Week 3: Topic C (everyone)
→ Some students lost, some bored

Mastery-based course:
Topic A → Assessment → 85%+ → Topic B
                    → <85% → Review → Retry

Student progress:
Alice: A(week 1) → B(week 2) → C(week 3) → D(week 4)
Bob:   A(week 1-2) → B(week 3) → C(week 4-5) → D(week 6)
Carol: A(week 1) → B(week 1) → C(week 2) → D(week 2-3)

Each advances when ready, not when calendar says.

Skill graph:

         ┌→ [Strings] →┐
         │              ↓
[Variables] → [Lists] → [Dictionaries]
         │              ↑
         └→ [Loops] ─→ ─┘

Rules:
- Can't start Lists until Variables mastered
- Can start Strings, Lists, or Loops after Variables
- Need Lists + Loops for Dictionaries
- Personalized path based on interests/goals

class MasteryPath:
    def __init__(self):
        self.skills = {}
        self.prerequisites = {}
        self.mastery_threshold = 0.85
    
    def add_skill(self, skill, prereqs=[]):
        self.skills[skill] = Skill(skill)
        self.prerequisites[skill] = prereqs
    
    def can_attempt(self, student, skill):
        # Check if prerequisites are mastered
        prereqs = self.prerequisites[skill]
        for prereq in prereqs:
            if student.get_mastery(prereq) < self.mastery_threshold:
                return False, f"Must master {prereq} first"
        return True, "Ready to attempt"
    
    def get_available_skills(self, student):
        # Return all skills where prerequisites are met
        available = []
        for skill in self.skills:
            can_attempt, _ = self.can_attempt(student, skill)
            is_mastered = student.get_mastery(skill) >= self.mastery_threshold
            if can_attempt and not is_mastered:
                available.append(skill)
        return available
    
    def recommend_next(self, student):
        # Recommend based on goals and difficulty
        available = self.get_available_skills(student)
        if not available:
            return None
        
        # Prioritize:
        # 1. Goal-aligned skills
        # 2. Appropriate difficulty
        # 3. Variety (different from recent)
        
        goal_aligned = [s for s in available if s in student.goals]
        if goal_aligned:
            return goal_aligned[0]
        
        return available[0]

Attempt 1: Full assessment
→ Score 72% (below threshold)
→ Feedback: "Strong on X and Y, struggling with Z"
→ Recommendation: "Review Z content, try practice problems"

Attempt 2: Full assessment (different questions)
→ Score 81% (below threshold, but improving)
→ Feedback: "Better on Z! Still missing edge cases"
→ Recommendation: "Practice edge cases"

Attempt 3: Full assessment
→ Score 89% (mastery!)
→ "Excellent! You've mastered functions. Ready for recursion?"

Concerns:
- Students guess repeatedly
- Memorize answers without understanding
- Take test immediately after failing

Solutions:

1. Delay between attempts:
   - Attempt 1 → Immediate retry
   - Attempt 2 → 30 minute delay
   - Attempt 3+ → 24 hour delay

2. Question banks:
   - Draw from pool of equivalent questions
   - Same skills, different content
   - Can't memorize specific answers

3. Minimum review:
   - Must complete review content before retry
   - Must attempt practice problems
   - Must wait for concept to "settle"

4. Increasing difficulty:
   - Later attempts slightly harder
   - Shows deeper understanding
   - Prevents lucky guesses

class MasteryAssessment:
    def __init__(self, skill, threshold=0.85):
        self.skill = skill
        self.threshold = threshold
        self.question_bank = []
        self.max_attempts = 5
    
    def can_retry(self, student):
        attempts = student.get_attempts(self.skill)
        
        if attempts >= self.max_attempts:
            return False, "Maximum attempts reached. Seek help."
        
        # Check delay between attempts
        last_attempt = student.get_last_attempt_time(self.skill)
        if attempts == 0:
            return True, "First attempt"
        elif attempts == 1:
            return True, "Immediate retry allowed"
        elif attempts >= 2:
            hours_since = (datetime.now() - last_attempt).hours
            if hours_since < 24:
                return False, f"Wait {24-hours_since} more hours"
        
        # Check if review completed
        if not student.has_completed_review(self.skill):
            return False, "Complete review materials first"
        
        return True, "Ready for retry"
    
    def generate_test(self, attempt_number):
        # Draw random questions from bank
        questions = sample(self.question_bank, k=10)
        
        # Slight difficulty increase for later attempts
        if attempt_number >= 3:
            questions = self.add_challenge_questions(questions)
        
        return Assessment(questions)

Break skill into smaller pieces:

Skill: Write function with parameters
→ Too hard initially

Sub-skills:
1. Write function with no parameters
2. Add one parameter
3. Use parameter in function body
4. Add multiple parameters
5. Return a value based on parameters

Each sub-skill mastered separately, then combined.

If student fails assessment:
1. Diagnostic: Which specific parts are difficult?
2. Targeted review: Focus on weak areas
3. Alternative explanations: Different approach/format
4. Worked examples: Step-by-step solutions
5. Hint-based practice: Scaffolded exercises
6. One-on-one help: Teacher/tutor support

def provide_support(student, skill, assessment_result):
    # Identify specific gaps
    gaps = assessment_result.analyze_gaps()
    
    support_plan = []
    
    for gap in gaps:
        # Micro-lesson on specific gap
        support_plan.append({
            'type': 'video',
            'content': f"short_explanation_{gap}",
            'duration': 5
        })
        
        # Targeted practice
        support_plan.append({
            'type': 'practice',
            'content': f"exercises_{gap}",
            'required_score': 0.8
        })
    
    # Full skill practice after gaps addressed
    support_plan.append({
        'type': 'integrated_practice',
        'content': f"full_skill_{skill}",
        'required_score': 0.85
    })
    
    return support_plan

Strong students master quickly:

Topic A: 1 day (vs 1 week)
→ Assessment: 95% (mastery)
→ Don't wait: Advance to Topic B

Benefit: Learn at their pace, stay engaged

After mastering core content:

Core: Write basic function (85% mastery)
→ Achieved quickly

Enrichment options:
1. Advanced topic: Recursion
2. Application project: Build calculator
3. Teaching role: Help peers
4. Exploration: Research decorators

def personalize_path(student, skill, mastery_score):
    if mastery_score >= 0.95:
        # Advanced: offer enrichment
        return {
            'status': 'mastered',
            'next': get_advanced_topic(skill),
            'enrichment': [
                f"{skill}_advanced_project",
                f"{skill}_mentor_opportunity",
                f"{skill}_exploration_topic"
            ]
        }
    elif mastery_score >= 0.85:
        # Mastered: normal progression
        return {
            'status': 'mastered',
            'next': get_next_skill(skill),
            'optional': f"{skill}_extension_activities"
        }
    else:
        # Not yet: support and retry
        return {
            'status': 'not_yet',
            'review': generate_review_path(student, skill),
            'retry': True
        }

Daily/per-lesson:
- Exit tickets (1-2 questions)
- Practice problems
- Self-checks
- Peer quizzes

Purpose:
- Monitor understanding
- Identify misconceptions early
- Guide instruction
- Build toward summative

Lesson: For loops

Exit ticket (2 minutes):
1. What does this code output?
   for i in range(3):
       print(i * 2)

2. One thing I understood:
   _______________________

3. One thing I'm unsure about:
   _______________________

Teacher reviews → Addresses common issues next lesson

Covers all learning objectives:

Functions Mastery Assessment:
Part 1: Knowledge (30%)
- Syntax
- Terminology
- Concepts

Part 2: Skills (50%)
- Write functions
- Use parameters
- Return values
- Call functions

Part 3: Transfer (20%)
- Novel problem
- Multiple steps
- Real-world context

Total: 85%+ for mastery

Knowledge:
"What keyword is used to return a value from a function?"
→ Tests recall

Skills:
"Write a function that takes two numbers and returns their sum."
→ Tests application

Transfer:
"You're building a temperature converter. Write functions to convert 
between Celsius and Fahrenheit. Your program should let users input 
a temperature and choose the conversion direction."
→ Tests transfer to new context

Instead of: Multiple choice test
Try: Build a working program

Example (Web Development):
"Build a personal website that includes:
- 3 pages with navigation
- Responsive layout
- Contact form
- Deployed to web

Rubric:
□ All pages load correctly
□ Navigation works
□ Layout adapts to mobile
□ Form submits data
□ Site is live

5/5 = Mastery"

Collect evidence of mastery over time:

Portfolio for "Python Programming":
1. Variables project: Grade calculator
2. Functions project: Text analyzer
3. Loops project: Game
4. Data structures project: Todo app
5. Final project: Student choice

Each must meet mastery criteria.
Demonstrates sustained competency.

Khan Academy:
- Skill mastery system
- Practice until fluent
- Adaptive problem selection
- Clear progress tracking

Duolingo:
- Spaced repetition
- Must maintain skill level
- Refresher when rusty
- Crown levels (mastery tiers)

Coursera (some courses):
- Must pass quizzes to advance
- Unlimited attempts
- Personalized feedback

✓ Skill/competency tracking
✓ Prerequisite enforcement
✓ Multiple assessment attempts
✓ Mastery threshold configuration
✓ Personalized pathways
✓ Progress dashboards
✓ Feedback and resources

class MasteryLMS:
    def __init__(self):
        self.students = {}
        self.skills = {}
        self.assessments = {}
    
    def check_progress(self, student_id, skill):
        student = self.students[student_id]
        attempts = student.get_attempts(skill)
        
        if not attempts:
            return "Not yet attempted"
        
        latest_score = attempts[-1].score
        threshold = self.skills[skill].mastery_threshold
        
        if latest_score >= threshold:
            return f"Mastered ({latest_score*100:.0f}%)"
        else:
            return f"Not yet ({latest_score*100:.0f}%). Retry available."
    
    def unlock_next_skills(self, student_id):
        student = self.students[student_id]
        mastered = student.get_mastered_skills()
        
        # Find skills where prerequisites are met
        unlocked = []
        for skill in self.skills.values():
            if skill.id not in mastered:
                prereqs_met = all(p in mastered for p in skill.prerequisites)
                if prereqs_met:
                    unlocked.append(skill)
        
        return unlocked

┌─ Your Mastery Progress ────────────────┐
│                                        │
│ Python Programming                     │
│                                        │
│ ✓ Variables         [████████] 95%    │
│ ✓ Operators         [████████] 88%    │
│ ✓ Conditionals      [████████] 92%    │
│ ⚡ Functions         [█████░░░] 72%    │
│   → Retry available                    │
│ 🔒 Loops           [locked]            │
│ 🔒 Data Structures [locked]            │
│                                        │
│ Overall: 4 of 6 skills mastered        │
└────────────────────────────────────────┘

Students progress at different rates:
- Some finish quickly
- Others need more time
- Hard to schedule

1. Flexible deadlines:
   - "Complete by end of semester" not "Week 3"
   - Suggested pace, not required pace

2. Blended model:
   - Core content: Mastery-based
   - Projects/discussions: Cohort-based
   - Balance flexibility and community

3. Cohort grouping:
   - Group students at similar levels
   - Peer learning
   - Shared experiences

"I'll just keep retrying until I pass"
→ Lack of effort on first attempts
→ Gaming the system

1. Meaningful delays:
   - Can't immediately retry
   - Must complete review
   - Time for learning to consolidate

2. Varied assessments:
   - Different questions each time
   - Can't memorize answers
   - Must truly understand

3. Growth mindset framing:
   - "Not yet" instead of "failed"
   - Celebrate improvement
   - Effort leads to mastery

4. Progress tracking:
   - Show improvement over attempts
   - Recognize persistence
   - Visualize growth

Students at different points:
- Who needs help?
- What content to teach?
- How to grade efficiently?

1. Technology:
   - Auto-graded assessments
   - Automated feedback
   - Progress dashboards

2. Peer support:
   - Advanced students help beginners
   - Study groups
   - Discussion forums

3. Targeted instruction:
   - Small group lessons for common gaps
   - One-on-one for unique struggles
   - Let mastery students self-direct

4. Clear structure:
   - Well-defined objectives
   - Robust question banks
   - Organized resources

Traditional grades:
- Average of all attempts? (Penalizes struggle)
- Last attempt only? (Ignores learning process)
- Letter grades? (Doesn't reflect mastery)

1. Mastery transcript:
   ✓ Functions: Mastered
   ✓ Loops: Mastered
   ⚡ Recursion: In progress
   🔒 Algorithms: Not started

2. Proficiency levels:
   - Not yet started
   - Developing (1-79%)
   - Proficient (80-89%)
   - Advanced (90-100%)

3. Most recent demonstration:
   - Grade reflects current capability
   - Improvement always possible
   - Encourages growth

4. Hybrid:
   - Mastery for core skills (pass/not yet)
   - Traditional for projects/applications
   - Best of both

✓ Define mastery level explicitly
✓ Share rubrics in advance
✓ Provide exemplars (what mastery looks like)
✓ Explain why mastery matters
✓ Show progression pathway

Not: "67% - Try again"
But: "You've mastered function syntax (✓) and parameters (✓).
      You're struggling with return values - watch this video 
      and try these 3 practice problems, then retry."

Language matters:
❌ "You failed"
✓ "You haven't mastered it yet"

❌ "You're not good at this"
✓ "This is challenging right now, but you'll get it"

❌ "Some people just can't code"
✓ "Everyone can learn to code with practice"

Celebrate:
- Improvement
- Persistence
- Mastery achieved
- Multiple attempts (learning process)

Too rigid: Everyone moves exactly together
→ Boredom for fast learners
→ Stress for slow learners

Too flexible: Everyone completely self-paced
→ Isolation
→ Procrastination
→ No cohort

Balanced:
- Flexible daily/weekly pacing
- Milestone checkpoints for cohort
- Community building activities
- Support for those behind
- Enrichment for those ahead