.. include:: ../../../global.rst

=======================================
Class Objectives Tracker (goaltracker)
=======================================

.. toctree::
   :maxdepth: 1
   :caption: Contents:

   ferpa_compliance

Overview
========

This project turns a semester's worth of course syllabi into a single,
personal checklist. Each class breaks down into a syllabus-derived tree
of learning objectives ("goals"), and a Django web application
(``goaltracker``) lets a student check them off as they master them,
track progress per course, and build one running project plan across
every class they're taking.

The data starts life in ``pbj.db``, a small SQLite database that holds
five course syllabi (Computer Science I, Data Structures, Database
Management Systems, Fullstack I, and Operating Systems) broken into 175
hierarchical topics -- things like "Imperatives," "Decisions," and
"Iterations/Loops" nested under a parent objective such as "Understanding
and having a strong ability to use the core features of a procedural
programming language." A Django management command
(``import_pbj``) reads that file and imports it into the tracker's
database, preserving the parent/child structure so a broad objective and
its specific sub-skills both show up as separate, checkable items.

How It Works
============

Data Model
----------

The Django app (``tracker``) is built around a small set of models:

``Course``
   A class, with its syllabus metadata (title, course code, credit
   hours, term).

``Goal``
   A single learning objective. Goals are global, not tied to one
   course -- if two classes share an objective (e.g. both a database
   class and a fullstack class expect basic SQL), completing it once
   satisfies it everywhere it's required. Goals may nest under a parent
   goal to preserve the syllabus's own grouping.

``CourseRequirement``
   Links a ``Goal`` to a ``Course`` and marks whether it's required or
   optional for that class.

``GoalCompletion``
   The single source of truth for whether a student has finished a
   goal. Keyed on the student and the goal only -- never per-course --
   so progress made before ever "using" a course still counts the
   moment that course requires the same goal.

``Enrollment`` / ``CourseCompletion`` / ``ProjectPlanItem`` / ``PlanMilestone``
   Support enrolled-course dashboards, an automatically-derived
   "you finished every requirement" badge per course, and a
   drag-and-reordered personal project plan built from goals the
   student has pulled in.

Application
-----------

The web application has three main views:

- **All Goals** -- every objective across every course, each tagged
  with the course(s) it counts toward, with a search box to jump
  straight to one by name or by course.
- **My Plan** -- a single, ongoing, drag-to-reorder list of goals the
  student is actively working through, framed as a running project
  timeline rather than a per-class assignment list.
- **My Courses** -- the student's enrolled courses, each with a
  progress bar and full checklist of its required (and optional)
  goals.

Checking a goal off in any of the three views updates it everywhere
else instantly, in every open browser tab, via a WebSocket connection
(Django Channels + Redis) -- no page reload required. The whole stack
(the Django app, PostgreSQL, and Redis) runs together via Docker
Compose.

Use Cases
=========

Tracking mastery, not just grades
   A letter grade says a class is "done." It doesn't say which of the
   40+ specific skills a syllabus promised were actually absorbed.
   This tool lets a student see, at a glance, exactly which objectives
   from a class they've genuinely covered versus which ones are still
   open -- useful for identifying gaps before a final, a technical
   interview, or a follow-on course that assumes the earlier material.

Reusing shared skills across courses
   Because a ``Goal`` isn't owned by a single course, an objective like
   "Integrate a SQL database" that shows up in both a database class and
   a fullstack class only has to be completed once. A student who
   learns it early (in an internship, a personal project, or an earlier
   class) walks into the second course already partway done.

Building one ongoing portfolio/project plan
   The "My Plan" view isn't scoped to a single semester or class --
   it's meant to hold the actual project(s) a student is building,
   with goals pulled in from whatever courses are relevant, reordered
   to match real build order. It turns scattered syllabus objectives
   into one coherent to-do list for a real piece of work.

Self-directed review and planning ahead
   Because goal completion isn't gated by enrollment, a student can
   browse and check off objectives from a class they haven't
   registered for yet -- useful for getting a head start over a break
   or confirming prerequisite knowledge before registration.

Why It Helps
============

- **Turns a syllabus into something actionable.** A PDF syllabus is a
  list of promises; this tool turns it into a checklist that changes as
  the student actually learns.
- **Makes gaps visible early.** Per-course progress bars and an
  all-goals view surface exactly which objectives are still
  incomplete, rather than discovering the gap on an exam or in a job
  interview.
- **Rewards a small amount of daily upkeep with a persistent record**
  of everything mastered so far, instead of relying on memory or
  scattered notes across multiple classes.
- **Encourages connecting coursework to a real project**, since the
  plan view is framed around one ongoing body of work rather than
  disconnected homework lists.
- **Costs almost nothing to maintain.** New syllabi can be dropped in
  by re-running the same import against an updated ``pbj.db``, and the
  whole stack runs locally with Docker Compose -- no external service
  dependency.