Rename scoreboard 'wave' to 'assignment' and document optional features

- Replace 'wave' with 'assignment' in SCOREBOARD.md and in comments
  and user-facing strings under webapp/ref/{view/api.py, core/scoring.py,
  model/exercise_config.py}.
- Add an "Optional Features" section to README.md describing the groups
  and scoreboard settings, both disabled by default and configured from
  the admin system-settings page.

Author: Nils Bars

README.md

@@ -176,3 +176,12 @@ User: ref
 Database name: ref
 Password: See settings.yaml (secrets.postgres_password)
 ```
+
+### Optional Features
+The following features are disabled by default and can be enabled from the admin UI at `/admin/system/settings/`.
+
+#### Groups
+Allows students to be organized into named groups with a configurable maximum size. Students pick a group during registration, and admins can manage the available groups and reassign students afterwards. Enable via the `GROUPS_ENABLED` setting and configure the per-group capacity via `GROUP_SIZE`.
+
+#### Scoreboard
+A public leaderboard at `/scoreboard` that ranks students based on their exercise submissions. Exercises can be grouped into assignments, the ranking strategy is selected via `SCOREBOARD_RANKING_MODE`, and the visual layout via `SCOREBOARD_VIEW`. Enable via `SCOREBOARD_ENABLED`; optionally set `LANDING_PAGE` to `scoreboard` to use it as the default landing page.

docs/SCOREBOARD.md

@@ -4,25 +4,25 @@ This document describes how to integrate a scoreboard into REF, based on the pro
 
 ## Overview
 
-The scoreboard is a public-facing page that shows team/student rankings based on submission scores. Exercises are grouped into **waves** (time-boxed rounds). Each exercise defines a **scoring policy** that maps raw submission scores to scoreboard points. The frontend fetches data via two JSON APIs and renders rankings, badges, charts, and per-challenge plots client-side.
+The scoreboard is a public-facing page that shows team/student rankings based on submission scores. Exercises are grouped into **assignments** (time-boxed rounds). Each exercise defines a **scoring policy** that maps raw submission scores to scoreboard points. The frontend fetches data via two JSON APIs and renders rankings, badges, charts, and per-challenge plots client-side.
 
 ## What exists in `raid/raid`
 
 The prototype adds:
 
-- **Two API endpoints** (`/api/waves`, `/api/submissions`) that return exercise metadata and submission scores as JSON.
+- **Two API endpoints** (`/api/assignments`, `/api/submissions`) that return exercise metadata and submission scores as JSON.
 - **Three new Exercise model fields**: `baseline_score`, `badge_score`, `badge_points` — parsed from the exercise YAML config.
 - **A scoreboard page** (`/student/scoreboard`) with a Jinja template and ~2300 lines of client-side JS (`scoreboard.js`, `utils.js`, `plots.js`) using Chart.js.
 - **Badges**: per-challenge achievement icons shown in the ranking table when a team's score exceeds `badge_score`. Each challenge can have custom SVG/PNG assets with a default fallback.
 - **System settings**: `LANDING_PAGE` (choose which page students see first), `DEMO_MODE_ENABLED` (serve dummy JSON data).
-- **A demo/dummy data system** (`dummies/waves.json`, `dummies/submissions.json`) for development without real submissions.
+- **A demo/dummy data system** (`dummies/assignments.json`, `dummies/submissions.json`) for development without real submissions.
 
-The prototype is tightly coupled to a fixed 3-waves x 3-challenges layout and hardcodes wave/challenge indices in the template. It also bundles all scoring logic (ranking, badges, rates) in the frontend JS.
+The prototype is tightly coupled to a fixed 3-assignments x 3-challenges layout and hardcodes assignment/challenge indices in the template. It also bundles all scoring logic (ranking, badges, rates) in the frontend JS.
 
 ## What already exists in `dev`
 
 - `SubmissionTestResult.score` (float, nullable) — already in the model. This is the raw per-submission score.
-- Exercise `category` field — used as the wave/group name.
+- Exercise `category` field — used as the assignment/group name.
 - `Submission.all()`, exercise deadlines, the full submission lifecycle.
 
 ## ExerciseConfig: Separating Administrative from Build-Time Config
@@ -41,7 +41,7 @@ class ExerciseConfig(db.Model):
 
     id: Mapped[int]                                     # PK (integer)
     short_name: Mapped[str]                             # unique constraint
-    category: Mapped[Optional[str]]                     # wave/group name
+    category: Mapped[Optional[str]]                     # assignment/group name
     scoring_policy: Mapped[Optional[dict]]              # JSON, see Scoring Architecture
     submission_deadline_start: Mapped[Optional[datetime]]
     submission_deadline_end: Mapped[Optional[datetime]]
@@ -96,7 +96,7 @@ Future candidates for `ExerciseConfig`: display name, description, visibility/pu
 
 The exercise list page gets an **Edit** button per exercise (per `short_name`, not per version). It opens a form editing the `ExerciseConfig`:
 
-- Category / wave assignment
+- Category / assignment
 - Deadlines (start, end)
 - Scoring policy (mode selector + mode-specific fields)
 - Max grading points
@@ -166,11 +166,11 @@ The migration:
 
 ### 3. Scoring API Endpoints
 
-**`GET /api/scoreboard/config`** — Returns exercise metadata grouped by `category` (wave), including the scoring policy:
+**`GET /api/scoreboard/config`** — Returns exercise metadata grouped by `category` (assignment), including the scoring policy:
 
 ```json
 {
-  "Wave 1": {
+  "Assignment 1": {
     "exercise_name": {
       "start": "...",
       "end": "...",
@@ -203,7 +203,7 @@ Both endpoints are rate-limited and publicly accessible (no auth required).
 
 Add an edit button to the exercise list page. The edit form modifies `ExerciseConfig` fields:
 
-- Category / wave
+- Category / assignment
 - Deadlines
 - Scoring policy (mode dropdown + dynamic fields per mode)
 - Max grading points
@@ -216,9 +216,9 @@ Add a scoreboard page at `/scoreboard`:
 - Fetches `/api/scoreboard/config` and `/api/submissions` periodically.
 - Renders a **ranking table** (sorted by total points) with **badge icons** for earned challenges.
 - Renders **per-challenge score charts** using Chart.js with baseline annotation lines.
-- Shows a **countdown timer** for the active wave's deadline.
-- Supports multiple waves via tab navigation.
-- Fully dynamic — number of waves and challenges driven by API data.
+- Shows a **countdown timer** for the active assignment's deadline.
+- Supports multiple assignments via tab navigation.
+- Fully dynamic — number of assignments and challenges driven by API data.
 
 The `raid/raid` JS can be reused but should be refactored to remove the hardcoded 3x3 layout.
 

webapp/ref/core/scoring.py

@@ -39,7 +39,7 @@
 # independent of the ranking strategy — views share utils.js and the
 # ranking/*.js modules. Adding a new view is one dict entry + two files.
 SCOREBOARD_VIEWS: dict[str, str] = {
-    "default": "Default (waves, charts, badges)",
+    "default": "Default (assignments, charts, badges)",
     "minimal": "Minimal (ranking table only)",
 }
 DEFAULT_SCOREBOARD_VIEW = "default"

webapp/ref/model/exercise_config.py

@@ -25,7 +25,7 @@ class ExerciseConfig(CommonDbOpsMixin, ModelToStringMixin, db.Model):
     id: Mapped[int] = mapped_column(primary_key=True)
     short_name: Mapped[str] = mapped_column(Text, unique=True)
 
-    # Used to group exercises (e.g., wave name for scoreboard)
+    # Used to group exercises (e.g., assignment name for scoreboard)
     category: Mapped[Optional[str]] = mapped_column(Text)
 
     submission_deadline_start: Mapped[Optional[datetime.datetime]]

webapp/ref/view/api.py

@@ -1001,8 +1001,8 @@ def api_scoreboard_config():
     }
 
     # The outer grouping key is `ExerciseConfig.category` — whatever label
-    # the admin chose in the exercise config edit form (e.g. "Assignment 1",
-    # "Wave 1", "Phase A"). Rendered verbatim by the frontend.
+    # the admin chose in the exercise config edit form (e.g. "Assignment 1"
+    # or "Phase A"). Rendered verbatim by the frontend.
     assignments: dict[str, dict[str, dict]] = defaultdict(dict)
     configs = ExerciseConfig.query.filter(
         ExerciseConfig.category.isnot(None),