Unit Project: Learning Analytics

Unit Project: Learning Analytics | JavaScript Course | SovranCode

COMPLETE LESSON · ABOUT 65 MIN OF ACTIVE PRACTICE

Learn Unit Project: Learning Analytics step by step

Follow the lesson in order: understand the model, trace worked examples, run a controlled experiment, debug a faulty assumption, build independently, and verify your reasoning.

LESSON MAP

What you will understand and apply

Write the data contract before implementation
Derive at least four useful metrics
Test empty, malformed, and mixed records
Build and test a learning analytics report with status counts, total minutes, completion percentage, and a recommended next lesson.

DEEP EXPLANATION

Build the complete mental model

Build the mental model

Begin with acceptance criteria rather than the final code. Define the exact lesson record: title, minutes, completion state, and perhaps difficulty. Decide whether one invalid record rejects the entire collection or is reported separately. A project becomes maintainable when its output shape and failure behavior are written before implementation. Before writing more syntax, name the values involved in Unit Project: Learning Analytics, who creates them, and which result or effect the program promises. Trace the smallest example by hand and identify any browser or runtime API separately from the language feature. A useful mental model should predict a changed input, not merely describe the demonstration after it runs.

Use the API deliberately

Separate validateLessons, calculateMetrics, chooseRecommendation, and formatReport. Each function should receive explicit inputs and return a value. Keep the source array unchanged so tests can compare before and after. Derive completion percentage only when a denominator exists, and represent an empty curriculum with an intentional result rather than NaN. During implementation, keep the report rule in a focused function or event boundary with explicit inputs. Choose names that reveal the domain, keep calculation separate from document, console, storage, or network effects, and prefer the narrowest API that expresses the problem. Compare this design with one reasonable alternative and explain why the selected construct makes ownership or control flow clearer.

Handle boundaries and tradeoffs

Your evidence should include a test matrix with an empty collection, one completed lesson, one open lesson, malformed minutes, and a mixed realistic list. Trace one calculation by hand, then compare the program output. Explain why each array method matches its question and where a loop would have been clearer. Verification for Unit Project: Learning Analytics must cover an ordinary case, an empty or missing case, invalid input, and the most important threshold. Predict each result before running it, then locate the first value that violates the contract when reality differs. Record the corrected case as a repeatable check and explain which product behavior should occur instead of allowing undefined, NaN, stale data, or silent failure to spread.

WORKED EXAMPLES

Read the decision before the syntax

Example 1: Project foundation

Trace this Unit Project: Learning Analytics example from validated input to returned value or visible effect before editing it.

function buildReport(lessons) {
  if (!Array.isArray(lessons)) throw new TypeError("Lessons must be an array");
  const valid = lessons.filter(item => typeof item.title === "string" && Number.isFinite(item.minutes));
  return {
    total: valid.length,
    completed: valid.filter(item => item.done === true).length,
    minutes: valid.reduce((sum, item) => sum + item.minutes, 0),
  };
}
console.log(buildReport([{ title: "Arrays", minutes: 35, done: true }]));

Example 2: Second worked example

This variation changes the shape of the problem so you can compare the underlying report contract instead of copying one solution.

function completionPercent(report) {
  if (report.total === 0) return 0;
  return Math.round((report.completed / report.total) * 100);
}
const report = { total: 4, completed: 3, minutes: 120 };
console.assert(completionPercent(report) === 75, "three of four should be 75%");

How to trace this lesson

Write down the exact inputs used by Unit Project: Learning Analytics.
Predict each returned value and observable effect before running the example.
Mark the first boundary where invalid or missing data could enter.
Verify the ordinary, empty, invalid, and threshold cases independently.

Common mistakes and corrections

Silently accepting partly invalid records can produce a polished dashboard whose totals cannot be trusted.: Make the report rule explicit and cover it with a focused example.
Changing several parts of the example before explaining the original result.: Make one change at a time and compare it with a written prediction.
Testing only the demonstration's happy path.: Add missing, invalid, empty, and boundary inputs that exercise the stated contract.

PRACTICE LADDER

Move from recognition to independent work

1
Write the data contract before implementation
2
Derive at least four useful metrics
3
Test empty, malformed, and mixed records
4
Build and test a learning analytics report with status counts, total minutes, completion percentage, and a recommended next lesson.

Complete these in order. The final step should work without copying the lesson example; use the runner and lab below to test it.

Core rule

Applied boundary

RUNNABLE EXAMPLE

Change one assumption at a time

Predict the output, run the example, then change one input and one boundary in the Unit Project: Learning Analytics example. Explain every changed result before continuing.

function buildReport(lessons) {
  if (!Array.isArray(lessons)) throw new TypeError("Lessons must be an array");
  const valid = lessons.filter(item => typeof item.title === "string" && Number.isFinite(item.minutes));
  return {
    total: valid.length,
    completed: valid.filter(item => item.done === true).length,
    minutes: valid.reduce((sum, item) => sum + item.minutes, 0),
  };
}
console.log(buildReport([{ title: "Arrays", minutes: 35, done: true }]));

function buildReport(lessons) {
  if (!Array.isArray(lessons)) throw new TypeError("Lessons must be an array");
  const valid = lessons.filter(item => typeof item.title === "string" && Number.isFinite(item.minutes));
  return {
    total: valid.length,
    completed: valid.filter(item => item.done === true).length,
    minutes: valid.reduce((sum, item) => sum + item.minutes, 0),
  };
}
console.log(buildReport([{ title: "Arrays", minutes: 35, done: true }]));

Press Run to execute your code.

DEBUGGING CHALLENGE

Locate the first incorrect value

Predict the failure and write your repair before revealing the explanation.

const percent = completed / lessons.length * 100;

Reveal repair and explanation

const percent = lessons.length === 0 ? 0 : Math.round((completed / lessons.length) * 100);

The repaired calculation defines the empty collection and rounds only after calculating the ratio.

INDEPENDENT LAB

Build without copying the example

Build and test a learning analytics report with status counts, total minutes, completion percentage, and a recommended next lesson.

// Define small functions before composing the complete solution.
// Build and test a learning analytics report with status counts, total minutes, completion percentage, and a recommended next lesson.

// Define small functions before composing the complete solution.
// Build and test a learning analytics report with status counts, total minutes, completion percentage, and a recommended next lesson.

Press Run to execute your code.

Self-review checklist Write the data contract before implementation Derive at least four useful metrics Test empty, malformed, and mixed recordsWhat did you predict, observe, and change?

KNOWLEDGE CHECK

Explain the rule, not only the syntax

1. What should a dashboard report for completion of an empty curriculum? A deliberately defined value such as 0 NaN without explanation Infinity

2. Which evidence best demonstrates mastery of Unit Project: Learning Analytics? A prediction, boundary tests, and an explained result A copied snippet with no changes One successful happy-path run

Loading saved work…

Code and answers save automatically. Guest work stays on this device; signed-in work syncs to your account. The runner is isolated, blocks network access, and stops long-running console programs.

1. JavaScript Foundations

2. Functions and Collections

3. Objects and Structured Data

4. Browser Interfaces

5. Async and Reliable Applications

6. Application Engineering