education-expert

name	education-expert
version	1.0.0
description	Expert-level education technology, learning management systems, and ed-tech platforms
category	domains
tags	["education","edtech","lms","e-learning","assessment"]
allowed-tools	["Read","Write","Edit"]

Education Expert

Expert guidance for education technology, learning management systems, online learning platforms, and educational software development.

Core Concepts

Educational Technology

• Learning Management Systems (LMS)
• Student Information Systems (SIS)
• Assessment and evaluation tools
• Adaptive learning platforms
• Virtual classrooms
• Content management

Standards

• SCORM (Sharable Content Object Reference Model)
• xAPI (Experience API / Tin Can API)
• LTI (Learning Tools Interoperability)
• QTI (Question and Test Interoperability)
• Accessibility (WCAG, Section 508)

Key Features

• Course management
• Grade tracking
• Student analytics
• Content delivery
• Collaborative tools
• Assessment engines

LMS Core Implementation

from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime
from enum import Enum

class EnrollmentStatus(Enum):
    ACTIVE = "active"
    COMPLETED = "completed"
    DROPPED = "dropped"
    PENDING = "pending"

@dataclass
class Course:
    course_id: str
    title: str
    description: str
    instructor_id: str
    start_date: datetime
    end_date: datetime
    credits: int
    capacity: int
    syllabus_url: str
    prerequisites: List[str]

@dataclass
class Student:
    student_id: str
    first_name: str
    last_name: str
    email: str
    enrolled_date: datetime
    grade_level: str
    gpa: float

@dataclass
class Enrollment:
    enrollment_id: str
    student_id: str
    course_id: str
    enrollment_date: datetime
    status: EnrollmentStatus
    final_grade: Optional[float]

class LMSPlatform:
    

     ():
        .db = db

     ():
        
        course = .db.get_course(course_id)
        current_enrollment = .db.count_enrollments(course_id)

        
         current_enrollment >= course.capacity:
             Exception()

        
         course.prerequisites:
            completed = .get_completed_courses(student_id)
              (prereq  completed  prereq  course.prerequisites):
                 Exception()

        enrollment = Enrollment(
            enrollment_id=generate_id(),
            student_id=student_id,
            course_id=course_id,
            enrollment_date=datetime.now(),
            status=EnrollmentStatus.ACTIVE,
            final_grade=
        )

         .db.save_enrollment(enrollment)

     ():
        
        enrollments = .db.get_student_enrollments(student_id)
        transcript = []

         enrollment  enrollments:
             enrollment.status == EnrollmentStatus.COMPLETED:
                course = .db.get_course(enrollment.course_id)
                transcript.append({
                    : course.course_id,
                    : course.title,
                    : course.credits,
                    : enrollment.final_grade,
                    : .get_term(enrollment.enrollment_date)
                })

         transcript

     ():
        
        transcript = .get_student_transcript(student_id)
        total_points = 
        total_credits = 

         record  transcript:
             record[]   :
                total_points += record[] * record[]
                total_credits += record[]

         total_points / total_credits  total_credits >   

Assessment Engine

from abc import ABC, abstractmethod

class Question(ABC):
    """Base question class"""

    def __init__(self, question_id, text, points):
        self.question_id = question_id
        self.text = text
        self.points = points

    @abstractmethod
    def check_answer(self, student_answer):
        pass

class MultipleChoiceQuestion(Question):
    """Multiple choice question"""

    def __init__(self, question_id, text, points, choices, correct_answer):
        super().__init__(question_id, text, points)
        self.choices = choices
        self.correct_answer = correct_answer

    def check_answer(self, student_answer):
        return student_answer == self.correct_answer

class Essay Question(Question):
    """Essay question requiring manual grading"""

    def __init__(self, question_id, text, points, rubric):
        super().__init__(question_id, text, points)
        self.rubric = rubric

    def check_answer(self, student_answer):
        
         

 :
    

     ():
        
        total_points = 
        earned_points = 
        results = []

         question  assessment.questions:
            total_points += question.points
            student_answer = student_answers.get(question.question_id)

             (question, MultipleChoiceQuestion):
                is_correct = question.check_answer(student_answer)
                points_earned = question.points  is_correct  
                earned_points += points_earned

                results.append({
                    : question.question_id,
                    : is_correct,
                    : points_earned,
                    :   is_correct  
                })
            :
                
                results.append({
                    : question.question_id,
                    : ,
                    : student_answer
                })

        score_percentage = (earned_points / total_points) *   total_points >   

         {
            : total_points,
            : earned_points,
            : score_percentage,
            : results
        }

     ():
        
        scores = [s[]  s  all_submissions]

         {
            : (scores) / (scores),
            : (scores)[(scores) // ],
            : (scores),
            : (scores),
            : .calculate_std_dev(scores)
        }

Learning Analytics

class LearningAnalytics:
    """Student learning analytics"""

    def get_student_engagement(self, student_id, course_id):
        """Calculate student engagement metrics"""
        activities = self.db.get_student_activities(student_id, course_id)

        metrics = {
            'login_frequency': self.calculate_login_frequency(activities),
            'content_completion_rate': self.calculate_completion_rate(activities),
            'assessment_participation': self.calculate_participation(activities),
            'forum_posts': len([a for a in activities if a['type'] == 'forum_post']),
            'time_on_platform': sum(a['duration'] for a in activities)
        }

        return metrics

    def predict_student_risk(self, student_id, course_id):
        """Predict at-risk students"""
        engagement = self.get_student_engagement(student_id, course_id)
        grades = self.get_recent_grades(student_id, course_id)

        risk_score = 0

        # Low engagement indicators
        if engagement['login_frequency'] < 2:  # Less than 2x per week
            risk_score += 25
        if engagement[] < :
            risk_score += 
         engagement[] < :
            risk_score += 

        
         grades  (grades) / (grades) < :
            risk_score += 

        risk_level =   risk_score >=     risk_score >=   

         {
            : student_id,
            : risk_score,
            : risk_level,
            : .generate_interventions(risk_score, engagement)
        }

     ():
        
        
        current_skills = .assess_skills(student_id)
        gap_analysis = .identify_skill_gaps(current_skills, learning_goals)

        
        recommended_courses = .match_courses_to_goals(gap_analysis)

         {
            : student_id,
            : current_skills,
            : learning_goals,
            : gap_analysis,
            : recommended_courses,
            : .estimate_completion_time(recommended_courses)
        }

xAPI (Tin Can API) Integration

import json
from datetime import datetime

class xAPIStatement:
    """xAPI statement builder"""

    @staticmethod
    def create_statement(actor, verb, object_data, result=None):
        """Create xAPI statement"""
        statement = {
            'actor': {
                'objectType': 'Agent',
                'name': actor['name'],
                'mbox': f"mailto:{actor['email']}"
            },
            'verb': {
                'id': verb['id'],
                'display': {'en-US': verb['display']}
            },
            'object': {
                'id': object_data['id'],
                'definition': {
                    'name': {'en-US': object_data['name']},
                    'description': {'en-US': object_data.get('description', '')}
                }
            },
            'timestamp': datetime.utcnow().isoformat()
        }

        if result:
            statement['result'] = result

        return statement

    @staticmethod
    def completed_course(student, course, score):
        
         xAPIStatement.create_statement(
            actor={: student[], : student[]},
            verb={
                : ,
                : 
            },
            object_data={
                : ,
                : course[]
            },
            result={
                : {
                    : score / ,
                    : score,
                    : ,
                    : 
                },
                : ,
                : score >= 
            }
        )

Best Practices

• Implement accessibility standards (WCAG)
• Support mobile learning
• Enable offline access
• Provide real-time feedback
• Use adaptive learning algorithms
• Protect student data privacy (FERPA)
• Enable collaborative learning
• Provide detailed analytics
• Support multiple content formats
• Implement plagiarism detection
• Enable parent/guardian access
• Support multilingual content

Anti-Patterns

❌ Poor mobile experience ❌ No accessibility features ❌ Ignoring data privacy ❌ No analytics or reporting ❌ Inflexible assessment tools ❌ No offline capabilities ❌ Poor user experience

Resources

• SCORM: https://scorm.com/
• xAPI: https://xapi.com/
• LTI: https://www.imsglobal.org/activity/learning-tools-interoperability
• Moodle: https://moodle.org/
• Canvas LMS: https://www.instructure.com/canvas
• FERPA: https://www2.ed.gov/policy/gen/guid/fpco/ferpa/