Commit 764b19

2026-04-26 08:07:23 lisa: Source material C02-C05: 6 new DRAFT pages, verified external rows YouTube-first priority sourcing per CXX-WIKI-VIDEO-guide §7. All external resources verified rigorously (oEmbed for YouTube, browser DOM check via playwright-cli for Isaac CS); no curl-200-only links. New DRAFT wiki pages (6): - C02: Excalidraw Diagram Starters - C03: Analytical Tools Template Guide - C04: Efficiency vs Effectiveness; Evaluation Criteria and the SRS - C05: Annotated Mock-up in Excalidraw; Plan B Contingency Table Verified external rows added across CXX-Resources.md (MPT YouTube, NNgroup, VCAA Teaching and Learning, Isaac CS prog_cwk_evaluation_ocr, Ryan's Tutorials). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

sd/C02/C02-home.md ..
@@ 13,6 13,7 @@
	- [Context Diagram vs Data Flow Diagram](/sd/C02/Context%20Diagram%20vs%20Data%20Flow%20Diagram) — what can appear on each diagram, side-by-side; the most common notation errors in C2-2
	- [What Is an Entity?](/sd/C02/What%20Is%20an%20Entity) — why entities include external systems (APIs, email servers) as well as human users; how to find every entity from your user stories
	- [Explaining vs Describing Your Data Collection](/sd/C02/Explaining%20vs%20Describing%20Your%20Data%20Collection) — the exact rubric difference between 7–8 and 9–10 for Indicator 1; worked examples of each level
+	- [Excalidraw Diagram Starters](/sd/C02/Excalidraw%20Diagram%20Starters) — pre-framed skeletons for all three C02 diagrams (context diagram, DFD, use case diagram) with shape keys and notation checks (DRAFT)
	## Resources
/dev/null .. sd/C02/Excalidraw Diagram Starters.md
@@ 0,0 1,143 @@
+	> **DRAFT** — under teacher review.
+
+	# Excalidraw Diagram Starters — C02
+
+	Hamilton College · Year 12 · 2026
+
+	Drawing from scratch each session costs 10–15 minutes of setup time and often produces inconsistent notation across the three diagrams. These Excalidraw starters give you pre-framed skeletons — correct shapes, correct labels — so you can focus on the content, not the canvas.
+
+	---
+
+	## Why consistent notation matters
+
+	All three C02 diagrams use the same cast of external entities. If the entity is named "Student" on your context diagram, it must be named "Student" (not "User" or "Person") on your DFD. Starting from a shared canvas makes this consistency automatic.
+
+	At **9–10**, the rubric requires *"no errors, inconsistencies or omissions"* across all three diagrams. Inconsistent entity names between diagrams is a named inconsistency — even if both diagrams are otherwise correct.
+
+	---
+
+	## Getting started in Excalidraw
+
+	Excalidraw is available free at [excalidraw.com](https://excalidraw.com). No account required. Your teacher may share a `.excalidraw` file directly — open it with File → Open.
+
+	---
+
+	## Skeleton: Context Diagram
+
+	The context diagram has **exactly one system circle**. Everything else is an external entity (rectangle) or a data flow (labelled arrow).
+
+	```
+	[Entity A] ──── label ────▶ ( Your System Name ) ──── label ────▶ [Entity B]
+	▲
+	label
+	│
+	[Entity C]
+	```
+
+	**Shape key:**
+
+	| Shape | What it represents |
+	|---|---|
+	| Rectangle | External entity (a person, organisation, or external system) |
+	| Circle / oval | The entire system — one only |
+	| Labelled arrow | Data flow — must carry a specific name (not "data" or "info") |
+
+	**Common setup errors to avoid before you start drawing:**
+
+	- Do not add any second circle — multiple circles make it a DFD, not a context diagram.
+	- Do not add data stores (double lines) — they do not exist at context level.
+	- Label every arrow with the specific data being exchanged, not a direction (wrong: "sends data"; right: "assignment submission form").
+
+	---
+
+	## Skeleton: Level-1 Data Flow Diagram
+
+	The Level-1 DFD **decomposes** the single system circle into 3–6 numbered processes. Use the same external entities as your context diagram.
+
+	```
+	[Entity A] ──── label ────▶ (1. Process Name) ────▶ ║ Data Store ║
+	│
+	label
+	▼
+	(2. Process Name) ──── label ────▶ [Entity B]
+	│
+	label
+	▼
+	(3. Process Name) ──── label ────▶ ║ Data Store ║
+	```
+
+	**Shape key:**
+
+	| Shape | What it represents |
+	|---|---|
+	| Rectangle | External entity — same names as context diagram |
+	| Circle / oval | A numbered process (verb–noun phrase, e.g. "1. Verify Login") |
+	| Double-line rectangle | Data store (named collection of stored data) |
+	| Labelled arrow | Data flow |
+
+	**Minimum check before you submit:**
+
+	- Each process has at least one input AND one output arrow.
+	- At least one data store is present.
+	- Every entity name matches your context diagram exactly.
+	- No entity ↔ entity arrows (all flows route through a process).
+	- No entity ↔ data store arrows (data stores only connect to processes).
+
+	---
+
+	## Skeleton: Use Case Diagram
+
+	The use case diagram shows **who** can do **what** with your system. Actors (stick figures) sit outside the system boundary; use cases (ovals) sit inside.
+
+	```
+	┌──────────────────────────────────────────┐
+	Actor A │ (Use Case 1) (Use Case 3) │
+	🧍─────┼──────────────────────────────────────────│
+	│ (Use Case 2) ──«include»──▶ (Use Case 4)│
+	🧍─────┼──────────────────────────────────────────│
+	Actor B │ │
+	└──────────────────────────────────────────┘
+	```
+
+	**Shape key:**
+
+	| Shape | What it represents |
+	|---|---|
+	| Stick figure (outside box) | Actor (a person or external system that uses the system) |
+	| Oval (inside box) | Use case (a function the system performs) |
+	| Rectangle | System boundary |
+	| Solid line | Association (actor participates in use case) |
+	| Dashed arrow «include» | Use case A *always* triggers use case B |
+	| Dashed arrow «extend» | Use case B *sometimes* triggers optional use case C |
+
+	**Arrow direction rules (the most common exam mistake):**
+
+	- **«include»:** arrow points FROM the base use case TO the included use case. ("Login" includes "Verify Credentials" — arrow: Login → Verify Credentials.)
+	- **«extend»:** arrow points FROM the extending use case TO the base use case. ("Display Error Message" extends "Login" — arrow: Display Error Message → Login.)
+
+	If in doubt: the arrow always points *towards* the use case that is being **used** or **extended into**.
+
+	---
+
+	## Practice check — before the hand-drawn validation
+
+	Run through this list with your Excalidraw diagrams before the timed hand-drawing session:
+
+	- [ ] Context diagram: exactly one system circle, no data stores, every arrow labelled.
+	- [ ] DFD: 3–6 numbered processes, at least one data store, entity names match context diagram.
+	- [ ] Use case diagram: all actors outside the boundary, all use cases inside, «include»/«extend» arrows pointing the correct direction.
+	- [ ] All three diagrams use identical names for the same entities and data stores.
+
+	If you can redraw all three from memory using only these skeletons as a prompt, you are ready for the hand-drawn validation.
+
+	---
+
+	## See also
+
+	- [Context Diagram vs Data Flow Diagram](/sd/C02/Context%20Diagram%20vs%20Data%20Flow%20Diagram) — what can appear on each diagram; the most common notation errors
+	- [What Is an Entity?](/sd/C02/What%20Is%20an%20Entity) — human and non-human entities; how to find all entities from your user stories
+	- C02 Resources: [external reading and videos](/sd/Resources/C02-Resources)
+
+	---
+
+	← Back to [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
/dev/null .. sd/C03/Analytical Tools Template Guide.md
@@ 0,0 1,86 @@
+	> **DRAFT** — under teacher review.
+
+	# Analytical Tools Template — UCD, Context Diagram, and DFD
+
+	Hamilton College · Year 12 · 2026
+
+	When you update your analytical tools in C3-1 (Step 1), you need to reproduce a Use Case Diagram, a Context Diagram, and a Data Flow Diagram. Setting up the notation from scratch each time costs 15–20 minutes and introduces layout errors. This page explains what is in the pre-labelled Excalidraw template and how to use it.
+
+	---
+
+	## What the template contains
+
+	The Excalidraw file (`C03-Analytical-Tools.excalidraw`) has three pre-built diagram skeletons on a single canvas, each with placeholder nodes labelled by notation role:
+
+	| Diagram | Pre-built elements |
+	|---|---|
+	| **Use Case Diagram (UCD)** | System boundary box; actor stick figures (primary user, secondary user); labelled oval placeholders for use cases; `«include»` and `«extend»` relationship stubs |
+	| **Context Diagram** | Central process circle (labelled with your system name placeholder); external entity rectangles on each side; labelled data-flow arrows in and out |
+	| **Data Flow Diagram (DFD)** | Level 1 layout with process circles, data store open rectangles, external entity rectangles, and directional arrow stubs; numbered process placeholders |
+
+	All three diagrams use the standard Yourdon–DeMarco notation that VCAA markers expect.
+
+	---
+
+	## How to use it
+
+	1. **Download the file** — ask your teacher for `C03-Analytical-Tools.excalidraw`.
+	2. **Open in Excalidraw** — go to [excalidraw.com](https://excalidraw.com) and drag the file onto the canvas, or use the **Open** menu.
+	3. **Replace placeholders** — click each labelled placeholder and type your own system name, actor names, use cases, data stores, and process names.
+	4. **Add or remove elements** — copy a placeholder shape to add more use cases, or delete extras. Keep the notation style consistent (don't mix shapes between diagram types).
+	5. **Export** — when done, export as PNG or SVG to paste into your SRS document.
+
+	---
+
+	## What to notice when you update
+
+	Coming back to these diagrams from C02, check:
+
+	- **New actors**: has your scope change added a new type of user? Add them to the UCD.
+	- **New data flows**: does your updated scope require new data in or out? Update the Context Diagram arrows.
+	- **New processes**: does the DFD reflect how data now moves through the updated system?
+
+	The rubric at 7–8 band requires diagrams that accurately reflect your current SRS — not your C02 version. Change what has changed; don't just copy-paste from C02.
+
+	---
+
+	## Notation quick reference
+
+	### Use Case Diagram
+
+	| Symbol | Meaning |
+	|---|---|
+	| Stick figure | Actor (a person or external system that interacts with yours) |
+	| Oval | Use case (a goal the actor achieves using the system) |
+	| Rectangle | System boundary (what is inside vs outside the scope) |
+	| `«include»` arrow | Use case A always includes use case B |
+	| `«extend»` arrow | Use case B optionally extends use case A |
+
+	### Context Diagram
+
+	| Symbol | Meaning |
+	|---|---|
+	| Circle | The system (one only — this is a Level 0 DFD) |
+	| Rectangle | External entity (person, group, or system outside your scope) |
+	| Arrow with label | Data flow (label = what data moves, direction = which way) |
+
+	### Data Flow Diagram (Level 1)
+
+	| Symbol | Meaning |
+	|---|---|
+	| Circle | Process (transforms data; numbered: 1.0, 2.0…) |
+	| Open rectangle | Data store (where data is held; labelled D1, D2…) |
+	| Rectangle | External entity (same as context diagram) |
+	| Arrow with label | Data flow |
+
+	---
+
+	## See also
+
+	- [Functional vs Non-Functional Requirements](/sd/C03/Functional%20vs%20Non-Functional%20Requirements) — requirements that feed into your diagrams
+	- [Scope vs Constraints](/sd/C03/Scope%20vs%20Constraints) — what determines the system boundary in your UCD and Context Diagram
+	- C03 Resources: [external reading and videos](/sd/Resources/C03-Resources)
+
+	---
+
+	← Back to [C03 Home](/sd/C03/C03-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
sd/C03/C03-home.md ..
@@ 12,6 12,7 @@
	- [Functional vs Non-Functional Requirements](/sd/C03/Functional%20vs%20Non-Functional%20Requirements) — the exact difference, with a side-by-side table for the same project; the most common mislabelling errors that cost marks at 5–6
	- [Scope vs Constraints](/sd/C03/Scope%20vs%20Constraints) — why budget is a constraint, not a scope decision; how MoSCoW and the constraints table work together; what the 9–10 band cross-reference looks like
+	- [Analytical Tools Template Guide](/sd/C03/Analytical%20Tools%20Template%20Guide) — how to use the pre-labelled Excalidraw file (UCD / Context Diagram / DFD skeletons) when updating your analytical tools in Step 1 (DRAFT)
	## Resources
sd/C04/C04-home.md ..
@@ 11,6 11,8 @@
	Short explainers for the concepts most commonly confused or under-done at each rubric band:
	- [Evaluation vs Testing](/sd/C04/Evaluation%20vs%20Testing) — why a solution can pass all tests and still fail evaluation; the exact distinction the 7–10 band requires you to hold
+	- [Efficiency vs Effectiveness](/sd/C04/Efficiency%20vs%20Effectiveness) — side-by-side scenario; how each term maps to separate evaluation matrix tables; why getting this wrong costs marks
+	- [Evaluation Criteria and the SRS](/sd/C04/Evaluation%20Criteria%20and%20the%20SRS) — why every criterion must trace to a numbered SRS requirement, with worked counter-examples and a pre-submission checklist
	## Resources
/dev/null .. sd/C04/Efficiency vs Effectiveness.md
@@ 0,0 1,74 @@
+	> **DRAFT** — under teacher review.
+
+	# Efficiency vs Effectiveness — What's the Difference?
+
+	Hamilton College · Year 12 · 2026
+
+	Two of the most commonly confused terms in C4-2 are *efficiency* and *effectiveness*. The rubric treats them as distinct — and the evaluation matrix has separate tables for each. Getting them confused means applying the wrong criteria to your design ideas.
+
+	---
+
+	## The one-sentence rule
+
+	| Term | One-sentence definition | Core question |
+	|---|---|---|
+	| **Efficiency** | How well the software uses resources (time, memory, processing) to do its job | "Does it do this **fast enough** and at **low enough cost**?" |
+	| **Effectiveness** | How well the software meets the needs of its users and fulfils its purpose | "Does it do the **right thing** for the **right people**?" |
+
+	These are not synonyms. A system can be highly efficient (fast, lean) but completely ineffective (solves the wrong problem, confuses users). A system can be highly effective (users love it, every requirement met) but inefficient (slow, resource-heavy).
+
+	---
+
+	## Side-by-side scenario
+
+	Imagine two versions of a student event-booking app:
+
+	| Scenario | Version A | Version B |
+	|---|---|---|
+	| Loads event list in | 0.3 seconds | 4.5 seconds |
+	| First-time users can complete a booking without help | 30% | 90% |
+	| Verdict | **Efficient, not effective** | **Effective, not efficient** |
+
+	Version A is fast but unusable for most students — it fails effectiveness.
+	Version B is slow but most students can use it independently — it fails efficiency.
+
+	The best design scores well on *both*.
+
+	---
+
+	## The evaluation matrix — where this matters
+
+	In your evaluation matrix, each table uses separate factors:
+
+	**Efficiency factors** (measure resource use):
+	- Speed of Processing (time)
+	- Cost of Data Manipulation
+	- Functionality Implementation (effort/complexity)
+	- Hardware Requirements
+	- Bandwidth Usage (if applicable)
+
+	**Effectiveness factors** (measure fitness for purpose):
+	- Usability, Accessibility, Clarity, Completeness, Accuracy, Relevance, Readability, Attractiveness, Maintainability, Timeliness, Communication of Message
+
+	When writing criteria, make sure each criterion lands in the right table. "The app loads in under 2 seconds" is an efficiency criterion. "80% of users can book an event without assistance" is an effectiveness criterion.
+
+	---
+
+	## Why VCAA cares
+
+	At **5–6**, you must *develop and apply evaluation criteria*. This requires criteria in both tables — not just one.
+
+	At **7–8**, you must *explain* which design elements should proceed, referencing your criteria scores. Mixing up efficiency and effectiveness makes your explanations incoherent.
+
+	At **9–10**, you must *justify* decisions with clear reasoning from scores to SRS requirements. The distinction between efficiency and effectiveness must be held precisely throughout.
+
+	---
+
+	## See also
+
+	- [Evaluation vs Testing](/sd/C04/Evaluation%20vs%20Testing) — the other common conflation
+	- [C04 Resources](/sd/Resources/C04-Resources) — external reading on efficiency and effectiveness
+
+	---
+
+	← Back to [C04 Home](/sd/C04/C04-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
/dev/null .. sd/C04/Evaluation Criteria and the SRS.md
@@ 0,0 1,88 @@
+	> **DRAFT** — under teacher review.
+
+	# Evaluation Criteria Must Come From Your SRS
+
+	Hamilton College · Year 12 · 2026
+
+	One of the most commonly skipped steps in C4-2 is linking evaluation criteria back to the SRS. Students often write criteria that sound plausible but weren't in the requirements they set at the start of the project. The rubric penalises this — criteria that float free of the SRS cannot provide genuine evidence that your solution met its goals.
+
+	---
+
+	## The rule
+
+	> Every evaluation criterion must trace back to a numbered requirement in your SRS.
+
+	If you can't point to a requirement ID (FR1, NFR2, etc.) for a criterion, the criterion should not be in your evaluation matrix.
+
+	---
+
+	## A concrete counter-example
+
+	### Floating criteria (wrong)
+
+	| Criterion | SRS link |
+	|---|---|
+	| The interface looks modern | — none — |
+	| The app is easy to use | — none — |
+	| The colour scheme is attractive | — none — |
+
+	These criteria were invented after the fact. They aren't measuring whether the solution met its stated requirements — they're measuring whatever the student decided to judge it on at evaluation time. The rubric at 7–10 specifically requires criteria derived from the SRS.
+
+	### SRS-anchored criteria (right)
+
+	| Criterion | SRS Requirement | Factor type |
+	|---|---|---|
+	| A first-time user shall complete a booking in under 4 minutes without assistance | NFR2 — Usability | Effectiveness |
+	| The event list shall load in under 2 seconds on school Wi-Fi | NFR1 — Performance | Efficiency |
+	| All travel plans entered by the user shall be saved and retrievable across sessions | FR3 — Data persistence | Effectiveness |
+
+	Each criterion is measurable, has a scoring scale, and traces to a specific SRS requirement ID. When you score it, you're producing genuine evidence.
+
+	---
+
+	## How to derive criteria from your SRS
+
+	For each requirement in your SRS, ask:
+
+	1. **What does "met" look like?** — turn the requirement into a measurable criterion.
+	2. **What type is it?** — efficiency (resource use) or effectiveness (fitness for purpose)?
+	3. **How will you score it?** — define a 1–5 scale with thresholds.
+
+	**Example:**
+
+	SRS Requirement: *NFR2 — The interface shall be learnable by a first-time user within one session.*
+
+	→ Criterion: "80% of test users can complete the primary task on their first attempt without assistance."
+	→ Type: Effectiveness — Usability
+	→ Scoring: 1: <40% | 2: 40–59% | 3: 60–74% | 4: 75–89% | 5: ≥90%
+
+	---
+
+	## Why VCAA cares
+
+	At **5–6**: criteria must exist and be applied — even floating criteria partially satisfy this.
+
+	At **7–8**: criteria must be *used to explain* decisions. Floating criteria make this hollow — you can't explain a decision in terms of requirements you never set.
+
+	At **9–10**: criteria must be *used to justify* decisions with explicit SRS links. Without requirement IDs in your matrix, this band is unreachable.
+
+	---
+
+	## Checklist before submitting your evaluation matrix
+
+	- [ ] Every criterion has a SRS requirement ID next to it
+	- [ ] No criterion appears that isn't in the SRS
+	- [ ] Efficiency and effectiveness criteria are in separate tables
+	- [ ] Each criterion has a defined scoring scale (not just pass/fail)
+
+	---
+
+	## See also
+
+	- [Evaluation vs Testing](/sd/C04/Evaluation%20vs%20Testing) — a related conflation to avoid
+	- [Efficiency vs Effectiveness](/sd/C04/Efficiency%20vs%20Effectiveness) — how to sort criteria into the right table
+	- [C04 Resources](/sd/Resources/C04-Resources) — external reading and resources
+
+	---
+
+	← Back to [C04 Home](/sd/C04/C04-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
/dev/null .. sd/C05/Annotated Mock-up in Excalidraw.md
@@ 0,0 1,122 @@
+	> **DRAFT** — under teacher review.
+
+	# Annotated Mock-up in Excalidraw — Reusable Template
+
+	Hamilton College · Year 12 · 2026
+
+	Setting up a fresh Excalidraw file from scratch each time costs 10+ minutes and often produces sparse, inconsistent annotations. This page gives you a standard starting point: a blank screen frame with labelled callout arrows and a dedicated annotation zone, so your time goes into the annotations themselves rather than the scaffolding.
+
+	---
+
+	## What an annotated mock-up needs
+
+	A VCE-compliant annotated mock-up is not just a sketch with some labels. It must show:
+
+	| Element | What it means |
+	|---|---|
+	| **Screen frame** | A bordered rectangle representing the UI window or mobile screen — makes the layout context clear |
+	| **Labelled UI components** | Named elements (button, text field, label, image area) placed inside the frame |
+	| **Callout arrows** | Lines or elbowed arrows from a UI element to an annotation box — not floating text |
+	| **Annotation text** | A sentence or two per callout: *what* the element is, *how* it applies a design principle, and *why* that serves the user |
+	| **Design principle named explicitly** | "Contrast" not "I used a colour" |
+
+	A rough sketch that labels what the screen contains (layout / structure) is a sketch. A mock-up adds the annotation layer that argues for design decisions. That distinction sits exactly at the 3–4 / 5–6 band boundary.
+
+	---
+
+	## Setting up the template in Excalidraw
+
+	### Step 1 — Open a new file
+
+	Go to [excalidraw.com](https://excalidraw.com) and open a blank canvas, or use Excalidraw inside VS Code if your teacher has that set up.
+
+	### Step 2 — Draw the screen frame
+
+	Use the **Rectangle** tool. Draw a large rectangle (roughly two-thirds of your canvas). This is your screen / application window.
+
+	- Set **stroke** to black, **fill** to white or light grey.
+	- Add a label at the top: small text inside the rectangle top edge, e.g. `Main Menu — ClubTracker`.
+
+	### Step 3 — Place UI components
+
+	Inside the screen frame, add rectangles or rounded rectangles for:
+
+	- Navigation bar (top strip)
+	- Buttons (smaller rectangles with centred labels)
+	- Text fields (narrow rectangles)
+	- Image or chart area (rectangle with an X through it, or a placeholder label)
+
+	Keep components sparse at first — you can add more as you build your design.
+
+	### Step 4 — Add the annotation zone
+
+	Draw a rectangle to the **right** or **below** the screen frame, roughly the same height or width. Label it `Annotation Zone`. This keeps your callout text from floating over the UI.
+
+	### Step 5 — Add callout arrows
+
+	For each UI element you want to annotate:
+
+	1. Select the **Arrow** tool; choose **elbow** style (right-angle corners look clean for callouts).
+	2. Click the UI element, drag to an empty spot in the annotation zone.
+	3. Add a text label on the arrow's endpoint (or use an attached text box).
+
+	### Step 6 — Write annotation text
+
+	In each annotation box, write in full sentences. A minimum annotation for a 5–6 band:
+
+	> "The navigation bar is aligned to the top edge of the screen (Alignment). This placement matches the user's expectation of where navigation lives, reducing cognitive load and supporting usability."
+
+	For 7–8 or 9–10, also name the UX characteristic your design choice produces:
+
+	> "The high-contrast login button (Contrast, design principle) makes the primary action immediately visible, improving affordance (UX characteristic) for first-time users."
+
+	---
+
+	## Standard annotation structure (copy and fill in)
+
+	```
+	[Design principle name]: [What element you applied it to]
+	→ Appearance / functionality: [one sentence describing the visual or behavioural choice]
+	→ Why it helps the user: [one sentence connecting to user need or UX outcome]
+	```
+
+	Example filled in:
+
+	```
+	Contrast: Login button vs background
+	→ Appearance: Button uses dark blue (#1a56db) against a white background, with white button text.
+	→ Why it helps the user: The high contrast makes the primary action visible at a glance,
+	supporting affordance — users immediately know what to click.
+	```
+
+	---
+
+	## Saving your template
+
+	Once your blank screen frame, annotation zone, and one sample callout are set up:
+
+	1. Press **Ctrl+A** (select all) then **Ctrl+C** (copy).
+	2. Open a new Excalidraw file for your next screen.
+	3. **Ctrl+V** to paste the scaffold in and start fresh for that screen.
+
+	Alternatively, save the blank file and duplicate it in your file system for each new screen you need to annotate.
+
+	---
+
+	## Common mistakes
+
+	- **Floating text labels** — typing a label directly on the canvas with no arrow is not a callout annotation. Use arrow → annotation box.
+	- **Design principle not named** — "I made the button blue for visibility" does not name a principle. Write "Contrast" explicitly.
+	- **Annotation zone inside the screen frame** — this makes the mock-up unreadable. Keep annotations outside the frame.
+	- **One annotation for the whole screen** — VCAA expects multiple design decisions documented. Aim for at least three distinct callouts per screen.
+
+	---
+
+	## See also
+
+	- [Design Principles vs UX Characteristics](/sd/C05/Design%20Principles%20vs%20UX%20Characteristics) — which list each term belongs to
+	- [C05 Resources](/sd/Resources/C05-Resources) — external reading on design principles and mock-up fidelity
+
+	---
+
+	← Back to [C05 Home](/sd/C05/C05-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
sd/C05/C05-home.md ..
@@ 12,6 12,13 @@
	- [Design Principles vs UX Characteristics](/sd/C05/Design%20Principles%20vs%20UX%20Characteristics) — why these are two separate lists, why usability appearing in both is a trap, and what the slot-five validation is actually checking
+	## Templates and scaffolds
+
+	Reusable starting points for C05 deliverables:
+
+	- [Annotated Mock-up in Excalidraw](/sd/C05/Annotated%20Mock-up%20in%20Excalidraw) — blank screen frame, annotation zone, and callout arrows ready to fill in; saves 10+ minutes of setup and produces consistent annotations (DRAFT)
+	- [Plan B Contingency Table](/sd/C05/Plan%20B%20Contingency%20Table) — pre-filled risk-prompt table for C05-3 contingency planning; prompts force specificity without hinting at solutions (DRAFT)
+
	## Resources
	- [C05 Resources](/sd/Resources/C05-Resources) — per-topic reading and external resources for design tools, design principles, UX characteristics, and critical and creative thinking
/dev/null .. sd/C05/Plan B Contingency Table.md
@@ 0,0 1,78 @@
+	> **DRAFT** — under teacher review.
+
+	# Plan B Contingency Table — Reusable Template
+
+	Hamilton College · Year 12 · 2026
+
+	The C05-3 step "Plan B Ready" asks you to show that you have thought about what could go wrong and prepared a specific alternative. The most common problem: students write "I'll think of another way" — which is not a contingency plan, it is a placeholder.
+
+	This page gives you a pre-filled Markdown table to copy into your design log. The risk prompts are specific enough to force real thinking, but they do not hint at solutions — that part is yours.
+
+	---
+
+	## The template
+
+	Copy this table into your design log or SAT submission document. Fill in the **Contingency / Backup design** and **Impact if triggered** columns for every row. Delete rows that genuinely do not apply to your project and add rows for risks you can identify from your own scope.
+
+	```markdown
+	| Risk | Trigger (when does this become a problem?) | Contingency / Backup design | Impact if triggered |
+	|---|---|---|---|
+	| **Library / package incompatibility** | A required library does not install on the target machine, or breaks after an update | | |
+	| **Scope creep** | Client or teacher requests a feature not in the original functional requirements, mid-project | | |
+	| **UI testing failure** | Beta-testing reveals a screen layout or workflow that users cannot navigate without assistance | | |
+	| **API or data-source change** | An external API changes its format, is rate-limited, or goes offline | | |
+	| **Client pivot** | The client changes the core purpose or target audience of the solution after designs are approved | | |
+	| **Time overrun on a critical task** | A core module (e.g. database integration, user authentication) takes longer than the project plan allows | | |
+	```
+
+	---
+
+	## How to fill it in
+
+	### What makes a good Contingency / Backup design entry
+
+	A contingency is a **specific alternative action**, not a vague reassurance.
+
+	| Weak (no marks) | Strong (marks) |
+	|---|---|
+	| "I'll fix it if it happens" | "Revert to the previous pinned library version and document the version in `requirements.txt`" |
+	| "I'll think of another way" | "Remove the feature from scope and document the decision in the design log; notify client in writing" |
+	| "I'll ask my teacher" | "Replace the external API with a locally-stored JSON dataset that mirrors the last-known good API response" |
+
+	### What makes a good Impact if triggered entry
+
+	Name **two things**: the scope impact (what feature or quality is affected) and the timeline impact (how many days or steps are delayed).
+
+	> Example: "Login feature delayed by 1–2 days; authentication falls back to a single shared password stored in `config.ini` until resolved."
+
+	---
+
+	## Completed example (ClubTracker project)
+
+	| Risk | Trigger | Contingency / Backup design | Impact if triggered |
+	|---|---|---|---|
+	| **Library incompatibility** | `nicegui` fails to install on school computers | Switch to `tkinter` (Python standard library; no install needed); redesign affected screens in the week before submission | UI redesign costs 1–2 days; appearance is less polished but all functional requirements are met |
+	| **Scope creep** | Client requests a report-export feature not in the original brief | Log the request in the design log; defer to post-submission iteration and document in the contingency section of the evaluation | No timeline impact; manage client expectation in writing |
+	| **UI testing failure** | Peer-testing reveals the member-search screen is unusable without prompting | Replace the free-text search field with a dropdown populated from the database; re-test with the same tester | 1 day to rebuild the search component; re-test adds half a day |
+	| **Time overrun** | Database integration takes longer than the 3-day Gantt allocation | Simplify the data model: flatten the member table, remove the `events` table, and hard-code event dates for the demo | Core membership features still functional; event tracking deferred |
+
+	---
+
+	## Adding your own risks
+
+	Think about the specific libraries, APIs, and features in *your* project. Add a row for any risk that would force a design change — not just a bug fix. Good custom risk prompts for student projects:
+
+	- "My chosen GUI framework does not support [specific feature]"
+	- "The school network blocks the API endpoint I rely on"
+	- "My only tester (client) is unavailable in the final two weeks"
+	- "I discover mid-build that the data structure I chose makes [key feature] impractical"
+
+	---
+
+	## See also
+
+	- [C05 Resources](/sd/Resources/C05-Resources) — external reading on critical and creative thinking in software design
+
+	---
+
+	← Back to [C05 Home](/sd/C05/C05-home) · [VCE Software Development Hub](/sd/VCE%20Software%20Development%20Hub)
sd/Resources/C02-Resources.md ..
@@ 60,12 60,13 @@
	|---|---|
	| [Context Diagram vs Data Flow Diagram](/sd/C02/Context%20Diagram%20vs%20Data%20Flow%20Diagram) | Side-by-side table of what can appear on each diagram; the most common notation mistakes (DRAFT) |
	| [What Is an Entity?](/sd/C02/What%20Is%20an%20Entity) | Human and non-human entities; how to find all entities from user stories; common omissions (DRAFT) |
+	| [Excalidraw Diagram Starters](/sd/C02/Excalidraw%20Diagram%20Starters) | Pre-framed skeletons for all three C02 diagrams with shape keys, notation rules, and a pre-validation checklist. Open the `.excalidraw` file from your teacher or use excalidraw.com (free, no account). (DRAFT) |
	### Gaps — C2-2
	- **No VCE-specific video** walking through all three diagrams for a single project. The NSW video above is the closest AU-curriculum substitute. A teacher-recorded walkthrough would close this gap fully.
	- **Hand-drawing practice** — no external resource covers the specific 45-minute timed rehearsal format used in the C2-2 validation. This is a candidate for a teacher-recorded video.
-	- **Excalidraw starter template** — a pre-built `.excalidraw` canvas with all three diagram skeletons would save students 10–15 min of setup time. Not yet built.
+	- **Excalidraw starter template** — a text-based wiki scaffold is now available at [Excalidraw Diagram Starters](/sd/C02/Excalidraw%20Diagram%20Starters). A companion `.excalidraw` binary file (with actual shapes) is still a candidate for a teacher-built asset.
	---
sd/Resources/C03-Resources.md ..
@@ 32,11 32,12 @@
	|---|---|
	| [Functional vs Non-Functional Requirements](/sd/C03/Functional%20vs%20Non-Functional%20Requirements) | Side-by-side table of both requirement types for the same project; most common mislabelling errors; how to make NF requirements measurable (DRAFT) |
	| [Scope vs Constraints](/sd/C03/Scope%20vs%20Constraints) | Why budget is a constraint not a scope decision; MoSCoW and constraints table side-by-side; how a 9–10 band response links them (DRAFT) |
+	| [Analytical Tools Template Guide](/sd/C03/Analytical%20Tools%20Template%20Guide) | How to use the pre-labelled Excalidraw file (UCD / Context Diagram / DFD skeletons); notation quick reference; what to check when updating diagrams from C02 (DRAFT) |
	### Gaps — C3-1
-	- **Technical environment documentation** — students often struggle to describe the technical environment adequately. A worked example showing hardware/software/network requirements for a typical SAT project would help. No strong external resource found.
-	- **Excalidraw UCD/Context Diagram/DFD skeleton template** — students spend 15–20 min recreating blank diagram structure from C02. A pre-built `.excalidraw` file would close this gap. Requires teacher-created asset — not auto-generated.
+	- **Technical environment documentation** — students often struggle to describe the technical environment adequately. A worked example showing hardware/software/network requirements for a typical SAT project would help. No strong external resource found. Teacher-recorded walkthrough recommended.
+	- **Excalidraw template file** — the wiki page ([Analytical Tools Template Guide](/sd/C03/Analytical%20Tools%20Template%20Guide)) is ready; the actual `C03-Analytical-Tools.excalidraw` file still needs to be created by Jeremy and distributed to students.
	---
@@ 52,6 53,7 @@
	|----------|--------|--------|--------------|-----------------|
	| [How I Conduct a Requirements Gathering Interview as a Business Analyst](https://www.youtube.com/watch?v=iIAbSOvf96E) | YouTube — Stefano The Agile BA (US) | Video (≈12 min) | C3-2: writing client-facing data-gathering questions (not meta-questions about the document) | Shows what real requirements interview questions look like — aimed at extracting information from a client, not at evaluating a document. Useful contrast for students who write meta-questions ("Did I write my SRS correctly?") instead of client-facing ones. |
	| [Requirements Gathering 101 — My Secret to Asking Great Questions](https://www.youtube.com/watch?v=PmCGiTWJ9Gg) | YouTube — Angelo the BA (US) | Video (≈10 min) | C3-2: writing effective data-gathering questions | Focuses on question quality — open vs closed, probing follow-ups, avoiding leading questions. Directly addresses the question-quality judgment required at 7–8 band in C3-2 Indicator 2. |
+	| [Probing in User Interviews](https://www.youtube.com/watch?v=1bionYPAPhg) | YouTube — NNgroup (US) | Video (≈3 min) | C3-2: writing follow-up questions that add new information (not restatements) | Demonstrates two forms of probing follow-up: questions that prompt elaboration, and questions that probe a specific detail already mentioned. Maps to the C3-2 9–10 band expectation that follow-up questions "clarify collected data" rather than repeat the original question. Context is UX research, not VCE SRS — translate "participant" to "client/user" and "researcher" to "you." |
	### Gaps — C3-2
@@ 62,6 64,8 @@
	## Recommended Actions
-	1. **New wiki pages** — [Functional vs Non-Functional Requirements](/sd/C03/Functional%20vs%20Non-Functional%20Requirements) and [Scope vs Constraints](/sd/C03/Scope%20vs%20Constraints) address the two highest-frequency C3-1 misconceptions.
+	1. **New wiki pages** — [Functional vs Non-Functional Requirements](/sd/C03/Functional%20vs%20Non-Functional%20Requirements), [Scope vs Constraints](/sd/C03/Scope%20vs%20Constraints), and [Analytical Tools Template Guide](/sd/C03/Analytical%20Tools%20Template%20Guide) address the highest-frequency C3-1 pain points.
	2. **Legal constraints gap** — the Australian Privacy Principles video (IILPM) is the best available resource for the Privacy Act angle; students commonly skip this entirely.
-	3. **C3-2 self-assessment and SRS 2.0** — no suitable external resources found. Teacher-recorded walkthroughs are the only viable solution for these VCAA-specific tasks.
+	3. **Excalidraw template file** — the Analytical Tools Template Guide wiki page exists, but requires Jeremy to create and distribute the actual `C03-Analytical-Tools.excalidraw` file. Teacher action required.
+	4. **Technical environment documentation** — no suitable external video found for a 4-min annotated walkthrough of all five categories. Teacher-recorded walkthrough is the only viable solution.
+	5. **C3-2 self-assessment and SRS 2.0** — no suitable external resources found for evaluating questions (High/Medium/Low) or SRS 2.0 tracing. Teacher-recorded walkthroughs are the only viable solution for these VCAA-specific tasks.
sd/Resources/C04-Resources.md ..
@@ 39,6 39,9 @@
	| Resource | Source | Format | VCAA Mapping | Why It's Useful |
	|----------|--------|--------|--------------|-----------------|
+	| [VCE Computing Key Terms Part 1 — Effectiveness vs Efficiency](https://www.youtube.com/watch?v=4UMjbzj9LTI) | YouTube (MPT / MichaelPokeTeacher) (AU) | Video | Efficiency and effectiveness factors, evaluation criteria | AU teacher explains effectiveness vs efficiency as distinct VCE Computing concepts — the exact distinction the C4-2 evaluation matrix requires students to hold. Short and directly on-topic. |
+	| [VCAA Teaching and Learning — Applied Computing](https://www.vcaa.vic.edu.au/curriculum/vce-curriculum/vce-study-designs/applied-computing/teaching-and-learning) | VCAA (AU) | Reading — official guidance | Design annotations, evaluation criteria, SRS requirements | Official VCAA advice for teachers: covers annotation requirements ("text notes that demonstrate … ability to use data visualisation software"), evaluation rubric construction, and linking criteria to SRS requirements. The authoritative source for rubric language. |
+	| [Evaluation (OCR) — Isaac Computer Science](https://isaaccomputerscience.org/concepts/prog_cwk_evaluation_ocr) | Isaac CS (UK) | Concept page | Evaluation criteria, SRS-linked criteria, justification | UK A-level concept page covering: evaluate against success criteria from analysis, annotated evidence of usability testing, justifying usability features, discussing limitations. Maps well to VCE C4-2 evaluation structure. Requires free Isaac CS account (sign-up at isaaccomputerscience.org). |
	| [ATARNotes Forum — Efficiency and Effectiveness Criteria](https://archive.atarnotes.com/forum/index.php?topic=146265.0) | ATARNotes | Reading (forum discussion) | Evaluation criteria, efficiency, effectiveness | VCE-specific discussion of what counts as efficiency vs effectiveness criteria. Real student questions with community answers. |
	| [VCAA Assessment Page — Software Development](https://www.vcaa.vic.edu.au/curriculum/vce-curriculum/vce-study-designs/applied-computing-software-development/assessment) | VCAA | Reading | Evaluation criteria — official requirements | Official VCAA guidance on what the SAT assessment expects for evaluation criteria. The authority on what "develops and applies evaluation criteria" means. |
	| [Farrell's VCE Software Development — SAT Overview](https://farrellv0.wixsite.com/softwaredevelopment/sat) | Teacher resource (Wix site) | Reading | Design folio, evaluation criteria | Overview of SAT expectations including design folio and evaluation criteria. Useful for understanding context. |
@@ 49,6 52,8 @@
	| Page | What it covers |
	|---|---|
	| [Evaluation vs Testing](/sd/C04/Evaluation%20vs%20Testing) | Why passing all tests does not mean passing evaluation; concrete worked example; the most common rubric mistakes at 5–6, 7–8, 9–10 (DRAFT) |
+	| [Efficiency vs Effectiveness](/sd/C04/Efficiency%20vs%20Effectiveness) | Side-by-side scenario showing a fast-but-unusable app vs a slow-but-usable app; how each term maps to evaluation matrix factors; why the distinction matters at 7–10 (DRAFT) |
+	| [Evaluation Criteria and the SRS](/sd/C04/Evaluation%20Criteria%20and%20the%20SRS) | Worked counter-example of floating vs SRS-anchored criteria; step-by-step derivation of a criterion from an SRS requirement; checklist for submission (DRAFT) |
	### Gaps — C4-2
sd/Resources/C05-Resources.md ..
@@ 15,6 15,7 @@
	| Resource | Source | Format | VCAA Mapping | Why It's Useful |
	|----------|--------|--------|--------------|-----------------|
	| [Ryan's Tutorials — Input Process Output Tables](https://ryanstutorials.net/software-design-and-development/input-process-output.php) | Ryan's Tutorials | Reading + examples | IPO charts: input, process, output | Free, clear explanation of IPO charts aimed at secondary students. Good supplement to existing materials. Explains why IPO charts are useful, not just how to create them. |
+	| [Ryan's Tutorials — Data Dictionary](https://ryanstutorials.net/software-design-and-development/data-dictionary.php) | Ryan's Tutorials (AU) | Reading + worked table | Data dictionary — Format column vs data type | Shows a complete data dictionary with a dedicated "Format for Display" column using N (digit) and X (character) notation, clearly separate from the Type column. Directly addresses the most common C5-1 data-dictionary error: treating Format as a synonym for data type. Free; secondary-pitched. |
	| [Codecademy — Pseudocode and Flowchart: Complete Beginner's Guide](https://www.codecademy.com/article/pseudocode-and-flowchart-complete-beginners-guide) | Codecademy | Reading | Pseudocode — structured English, algorithm representation | Beginner-friendly guide to pseudocode with examples. Helps students understand the conventions. |
	| [Lucidchart — UML Class Diagram Tutorial](https://www.lucidchart.com/pages/uml-class-diagram) | Lucidchart | Reading + interactive | Object descriptions, class diagrams — OOP design | Tutorial on creating UML class diagrams. Directly supports the object descriptions and class diagram requirements. Students can use Lucidchart's free tier to create their diagrams. |
	| [StudyLib — Database Design Tools: IPO Charts, Data Tables](https://studylib.net/doc/9259677/database-design-tools---vce-it-lecture-notes-by-mark-kelly) | Mark Kelly (VCE) | Reading | IPO charts, data dictionaries — VCE-specific | VCE-specific lecture notes on design tools by Mark Kelly. Directly aligned to study design expectations. |