--- 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 ```python 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: """Learning Management System core functionality""" def __init__(self, db): self.db = db def enroll_student(self, student_id, course_id): """Enroll student in course""" course = self.db.get_course(course_id) current_enrollment = self.db.count_enrollments(course_id) # Check capacity if current_enrollment >= course.capacity: raise Exception("Course is full") # Check prerequisites if course.prerequisites: completed = self.get_completed_courses(student_id) if not all(prereq in completed for prereq in course.prerequisites): raise Exception("Prerequisites not met") enrollment = Enrollment( enrollment_id=generate_id(), student_id=student_id, course_id=course_id, enrollment_date=datetime.now(), status=EnrollmentStatus.ACTIVE, final_grade=None ) return self.db.save_enrollment(enrollment) def get_student_transcript(self, student_id): """Generate student transcript""" enrollments = self.db.get_student_enrollments(student_id) transcript = [] for enrollment in enrollments: if enrollment.status == EnrollmentStatus.COMPLETED: course = self.db.get_course(enrollment.course_id) transcript.append({ 'course_code': course.course_id, 'course_name': course.title, 'credits': course.credits, 'grade': enrollment.final_grade, 'term': self.get_term(enrollment.enrollment_date) }) return transcript def calculate_gpa(self, student_id): """Calculate student GPA""" transcript = self.get_student_transcript(student_id) total_points = 0 total_credits = 0 for record in transcript: if record['grade'] is not None: total_points += record['grade'] * record['credits'] total_credits += record['credits'] return total_points / total_credits if total_credits > 0 else 0.0 ``` ## Assessment Engine ```python 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): # Requires manual grading return None class AssessmentEngine: """Assessment and grading system""" def grade_assessment(self, assessment, student_answers): """Grade student assessment""" total_points = 0 earned_points = 0 results = [] for question in assessment.questions: total_points += question.points student_answer = student_answers.get(question.question_id) if isinstance(question, MultipleChoiceQuestion): is_correct = question.check_answer(student_answer) points_earned = question.points if is_correct else 0 earned_points += points_earned results.append({ 'question_id': question.question_id, 'correct': is_correct, 'points': points_earned, 'feedback': 'Correct!' if is_correct else f'Incorrect. Correct answer: {question.correct_answer}' }) else: # Essay questions need manual grading results.append({ 'question_id': question.question_id, 'status': 'pending_review', 'answer': student_answer }) score_percentage = (earned_points / total_points) * 100 if total_points > 0 else 0 return { 'total_points': total_points, 'earned_points': earned_points, 'percentage': score_percentage, 'results': results } def analyze_assessment_statistics(self, assessment_id, all_submissions): """Analyze assessment performance""" scores = [s['percentage'] for s in all_submissions] return { 'mean': sum(scores) / len(scores), 'median': sorted(scores)[len(scores) // 2], 'min': min(scores), 'max': max(scores), 'std_dev': self.calculate_std_dev(scores) } ``` ## Learning Analytics ```python 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['content_completion_rate'] < 0.5: risk_score += 25 if engagement['assessment_participation'] < 0.7: risk_score += 25 # Grade indicators if grades and sum(grades) / len(grades) < 60: risk_score += 25 risk_level = 'high' if risk_score >= 75 else 'medium' if risk_score >= 50 else 'low' return { 'student_id': student_id, 'risk_score': risk_score, 'risk_level': risk_level, 'recommendations': self.generate_interventions(risk_score, engagement) } def generate_learning_path(self, student_id, learning_goals): """Generate personalized learning path""" # Analyze student's current knowledge current_skills = self.assess_skills(student_id) gap_analysis = self.identify_skill_gaps(current_skills, learning_goals) # Recommend courses and resources recommended_courses = self.match_courses_to_goals(gap_analysis) return { 'student_id': student_id, 'current_level': current_skills, 'target_level': learning_goals, 'skill_gaps': gap_analysis, 'recommended_path': recommended_courses, 'estimated_duration': self.estimate_completion_time(recommended_courses) } ``` ## xAPI (Tin Can API) Integration ```python 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): """Create course completion statement""" return xAPIStatement.create_statement( actor={'name': student['name'], 'email': student['email']}, verb={ 'id': 'http://adlnet.gov/expapi/verbs/completed', 'display': 'completed' }, object_data={ 'id': f"http://lms.example.com/course/{course['id']}", 'name': course['title'] }, result={ 'score': { 'scaled': score / 100, 'raw': score, 'min': 0, 'max': 100 }, 'completion': True, 'success': score >= 70 } ) ``` ## 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/