JAVA-290 · Lesson 12 of 12 · 31 min

Demo day and retrospective

▶ Video coming soon A video version of this lesson is on the way.

Wednesday, August 23, 2028 was the college's capstone demo day. Twenty-two teams presented in the afternoon, each with ten minutes to show what they had built and five minutes for questions from a panel of two faculty members and three developers from local companies, in a lecture hall with an audience of students, families and clients. Odile, Tamsin and Kofi came, which few clients did, and Ingrid and Leif sat at the back. This last lesson follows the team through the demo, the first results of the soft launch and the retrospective two days later, and ends where the program ends.

What a demo is for

A demo is not a tour of the code or a list of features. Its audience wants to know three things: what problem the team solved and for whom, whether the solution works, and how the team knows. Ingrid gave the team a structure that answers those questions in order, and a rule for the live part: show the software doing what a real user would do, in that user's words, and never show a screen nobody in the audience would recognize.

The demo plan for August 23, 2028.
PartMinutesWhat it showsWho
The problem1.5The phone tally: 13 of 40 calls missed, mostly around midday; Rosa, Dana and the counterHamza
Live: a customer books and cancels2.5A phone on the projector: free times, book, the text, find and cancelNoemi
Live: the counter's morning1.5The staff day list, part warnings, a check-inThierry
How we know it works2Requirements met, tests, accessibility, the p95, the security reviewThierry
First results1.5Twelve days of the soft launchHamza
What is next1Public launch, the Later page, what we would do differentlyNoemi

The live parts ran on staging, with generated data and the team's test phone, not on production. A demo on production would have put real customers' names on a projector, and a demo that depends on the real SMS provider and the venue's network is a demo that can fail in front of everyone. The team also recorded a video of both live parts on Tuesday, so that if anything went wrong on the day, Noemi could switch to it without a pause, which is a habit worth keeping for every live demonstration.

Ten minutes is short, and teams almost always overrun. On Monday, August 21, the team rehearsed twice with Ingrid timing them, and Thierry wrote down each part's actual time. The first run took twelve minutes. The program below compares the rehearsals with the plan, which made it obvious where to cut.

Java Example
import java.util.*;

public class Main {
    public static void main(String[] args) {
        String[] parts = {"problem", "live: customer", "live: counter", "evidence", "first results", "next"};
        double[] plan = {1.5, 2.5, 1.5, 2.0, 1.5, 1.0};
        int[][] rehearsalSeconds = {{120, 185, 95, 170, 80, 70}, {95, 150, 90, 125, 85, 55}};
        double limit = 10.0;
        System.out.printf("%-16s %6s %8s %8s%n", "part", "plan", "run 1", "run 2");
        double[] totals = new double[2];
        for (int i = 0; i < parts.length; i++) {
            double r1 = rehearsalSeconds[0][i] / 60.0, r2 = rehearsalSeconds[1][i] / 60.0;
            totals[0] += r1; totals[1] += r2;
            String flag = r2 > plan[i] + 0.25 ? "  over" : "";
            System.out.printf("%-16s %6.1f %8.1f %8.1f%s%n", parts[i], plan[i], r1, r2, flag);
        }
        System.out.printf("%-16s %6.1f %8.1f %8.1f%n", "total", Arrays.stream(plan).sum(), totals[0], totals[1]);
        for (int r = 0; r < 2; r++)
            System.out.println("run " + (r + 1) + ": " + (totals[r] <= limit ? "fits" : "over by " + Math.round((totals[r] - limit) * 60) + " s"));
    }
}
Output
part               plan    run 1    run 2
problem             1.5      2.0      1.6
live: customer      2.5      3.1      2.5
live: counter       1.5      1.6      1.5
evidence            2.0      2.8      2.1
first results       1.5      1.3      1.4
next                1.0      1.2      0.9
total              10.0     12.0     10.0
run 1: over by 120 s
run 2: fits

What this code does

Each rehearsal's times are recorded in seconds and converted to minutes for comparison with the plan, and a part is flagged when the second run is more than a quarter of a minute over its share. The totals show the first run two minutes over and the second inside the limit. The flags point at the parts to watch on the day, while the totals say whether the whole fits.

The cuts were instructive. The first run spent two minutes on the problem because Hamza told the story of the October inner-tube shortage from 2026, which the audience loved and which had nothing to do with booking repairs. The evidence part was long because Thierry explained the test pyramid. In the second run he showed one table instead, the requirements with their status, and said that every row had tests behind it, which took twenty seconds and made the same point.

The evidence

The table Thierry showed was the traceability report from lesson 8, summarized by story. Panels at demo days ask whether the team did what it said it would, and the honest answer has three parts: what was finished, what was not, and why.

Requirements at demo day.
StoryMoSCoWStatus on Aug 23
US-01 to US-06MustDone: all criteria tested; in production since Aug 10
US-07 reminder textShouldDone; in production
US-08 waiting listShouldDone, with confirmation by text after the security review; switched on Aug 17
US-09 weekly figuresShouldDone; Odile reports to the board in September
US-10 stand sign-upCouldNot started; on the Later page
US-11 second languageCouldNot started; on the Later page
US-12 payment and accountsWon'tNot planned

Beside it Thierry put four numbers, each with its source: 381 automated tests, all passing; zero accessibility violations in axe-core across twelve page states, plus a screen reader check of every page; a p95 of 49 ms against an objective of 300 ms in the load test; and twelve security findings, all fixed and re-checked. Odile had asked for one more line, which got a laugh from the panel: the shop had not needed to call anyone about the website since it went live.

The first twelve days

The soft launch had run from Thursday, August 10. Its numbers were small, and Hamza said so before showing them, because a panel of developers would ask. Twelve days of an unannounced website cannot prove that it reduces missed calls; that needs the public launch and a new phone tally. But the numbers could show whether the website was being used, whether it was working, and whether anything surprising was happening.

Java Example
import java.util.*;

public class Main {
    record Booking(String source, boolean remind, String outcome) {}

    public static void main(String[] args) {
        List<Booking> b = new ArrayList<>();
        add(b, "WEB", true, "COLLECTED", 17); add(b, "WEB", true, "NO_SHOW", 1); add(b, "WEB", true, "CANCELLED", 3);
        add(b, "WEB", false, "COLLECTED", 6); add(b, "WEB", false, "NO_SHOW", 1); add(b, "WEB", false, "CANCELLED", 1);
        add(b, "WEB", true, "UPCOMING", 2);
        add(b, "PHONE", false, "COLLECTED", 41); add(b, "PHONE", false, "NO_SHOW", 4); add(b, "PHONE", false, "CANCELLED", 6);
        add(b, "COUNTER", false, "COLLECTED", 10);

        Map<String, Long> bySource = new TreeMap<>();
        for (Booking x : b) bySource.merge(x.source(), 1L, Long::sum);
        long total = b.size(), web = bySource.get("WEB");
        System.out.println("bookings Aug 10-21: " + total + " " + bySource);
        System.out.println("made on the web: " + web + " of " + total + " (about " + Math.round(100.0 * web / total) + " in 100)");
        long webCancelOnline = b.stream().filter(x -> x.source().equals("WEB") && x.outcome().equals("CANCELLED")).count();
        System.out.println("web bookings CANCELLED online: " + webCancelOnline);
        for (boolean r : new boolean[] {true, false}) {
            long due = b.stream().filter(x -> x.remind() == r && (x.outcome().equals("COLLECTED") || x.outcome().equals("NO_SHOW"))).count();
            long missed = b.stream().filter(x -> x.remind() == r && x.outcome().equals("NO_SHOW")).count();
            System.out.println((r ? "with a reminder:    " : "without a reminder: ") + missed + " missed of " + due + " appointments");
        }
        System.out.println("too few appointments to say whether reminders help; measure again after the public launch");
    }

    static void add(List<Booking> list, String source, boolean remind, String outcome, int n) {
        for (int i = 0; i < n; i++) list.add(new Booking(source, remind, outcome));
    }
}
Output
bookings Aug 10-21: 92 {COUNTER=10, PHONE=51, WEB=31}
made on the web: 31 of 92 (about 34 in 100)
web bookings CANCELLED online: 4
with a reminder:    1 missed of 18 appointments
without a reminder: 5 missed of 62 appointments
too few appointments to say whether reminders help; measure again after the public launch

What this code does

The bookings from the staff figures page are rebuilt here as records, with how each was made, whether the customer asked for a reminder and what happened. The program counts bookings by source and computes the web's share, then compares missed appointments with and without a reminder among appointments that have already happened, excluding cancelled and upcoming ones. One missed out of eighteen against five out of sixty-two looks like a difference, but with numbers this small it could easily be chance, and the last line says so, as Hamza did on the day.

Thirty-one bookings out of ninety-two were made on the web in the first twelve days, without any announcement, which was more than anyone had expected. The panel's first question went straight to the comparison of reminders, and Hamza's answer, that the numbers were too small to conclude anything and that the team had said so on the slide, was the answer the questioner had hoped for. A capstone panel is often more impressed by a team that knows the limits of its evidence than by a team with impressive numbers.

Questions from the panel

The panel asked six questions in five minutes. Two are worth recording, because they were the ones the team had prepared for least. A developer from a payments company asked what would happen if the shop's server failed on a Saturday morning: the answer was the runbook, the restore drill from the deployment course and the phone, which still worked. And a faculty member asked each team member to name one thing they would do differently. Noemi said she would have run the usability test in sprint 2, not sprint 3, because its findings were cheap to fix and would have been cheaper earlier. Thierry said he would have written the leader lock in sprint 1, because he had nearly missed it. Hamza said he would have asked Tamsin about the problem kinds before writing the domain, not after.

The team did not win the award for the best project, which went to a team that had built a scheduling tool for a hospital volunteers' office. They won the award for the best client partnership, which the panel gave, its chair said, because the client had come to the demo and had spoken without being asked. Odile had stood up during the questions and said that it was the first piece of software the shop had ever had that came with a manual for the volunteers.

The retrospective

On Friday, August 25, after the shop closed, the team held its project retrospective in the back room, with Ingrid facilitating so that all three could take part. Sprint retrospectives had happened every two weeks; this one looked back over the whole project, to learn what each of them would carry into their next team. Ingrid opened with Norm Kerth's Prime Directive, from his 2001 book Project Retrospectives, which many teams read aloud at the start: regardless of what we discover, we understand and truly believe that everyone did the best job they could, given what they knew at the time, their skills and abilities, the resources available, and the situation at hand. Its purpose is to make it safe to talk about what went wrong, by agreeing in advance that the discussion is about the system and the decisions, not about blame.

She used the five stages that Esther Derby and Diana Larsen describe in Agile Retrospectives: set the stage, gather data, generate insights, decide what to do, and close. Gathering data came first, and for that the team had two sources. One was the record in the repository and on the board, which says what happened. The other was their own experience, which says what it was like, and to collect it without the loudest voice dominating, each of them had filled in a short anonymous survey the day before.

Java Example
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Map<String, int[]> ratings = new LinkedHashMap<>();   // 1 = strongly disagree, 5 = strongly agree; three answers each
        ratings.put("We knew what to build next at every point", new int[] {5, 4, 4});
        ratings.put("Reviews were quick enough", new int[] {3, 2, 4});
        ratings.put("I could ask for help without feeling slow", new int[] {5, 5, 4});
        ratings.put("Our estimates were useful", new int[] {3, 3, 2});
        ratings.put("The client was involved enough", new int[] {5, 5, 5});
        ratings.put("I worked a sustainable number of hours", new int[] {2, 4, 3});
        System.out.printf("%-46s %5s %6s%n", "statement", "mean", "spread");
        for (var e : ratings.entrySet()) {
            IntSummaryStatistics s = Arrays.stream(e.getValue()).summaryStatistics();
            int spread = s.getMax() - s.getMin();
            String note = s.getAverage() < 3.5 ? "  discuss" : spread >= 2 ? "  views differ" : "";
            System.out.printf("%-46s %5.1f %6d%s%n", e.getKey(), s.getAverage(), spread, note);
        }
        Map<String, List<String>> comments = new TreeMap<>(Map.of(
            "continue", List.of("written check-ins", "client at every review", "pairing on risky stories"),
            "start", List.of("usability tests earlier", "estimate review time too"),
            "stop", List.of("merging after 22:00", "big pull requests on Sundays")));
        comments.forEach((k, v) -> System.out.println(k + ": " + String.join("; ", v)));
    }
}
Output
statement                                       mean spread
We knew what to build next at every point        4.3      1
Reviews were quick enough                        3.0      2  discuss
I could ask for help without feeling slow        4.7      1
Our estimates were useful                        2.7      1  discuss
The client was involved enough                   5.0      0
I worked a sustainable number of hours           3.0      2  discuss
continue: written check-ins; client at every review; pairing on risky stories
start: usability tests earlier; estimate review time too
stop: merging after 22:00; big pull requests on Sundays

What this code does

Each statement has three anonymous ratings, and IntSummaryStatistics gives their mean, minimum and maximum in one pass. A low mean marks a statement to discuss, and a wide spread, even with a good mean, marks one where the team members had different experiences, which is often the more interesting conversation. The comments are grouped under continue, start and stop, a simple format that turns impressions into proposals.

Three statements were marked, and two of them became the evening's real subject. Reviews had been slow in sprints 2 and 4, when the Review column sat at its limit for days; the board's history showed it. And the hours question had a spread that surprised Hamza and Thierry, until Noemi said that the 2 was hers: she had worked most Sundays in July to keep up with the page work, without telling anyone, because she had not wanted to be the reason the team was late.

The data from the board told the same story in numbers. Thierry had exported it for the evening, and the program below summarizes it: points planned and finished per sprint, and how long pull requests waited for their first review.

Java Example
import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[] planned = {10, 11, 10, 10, 6};
        int[] done = {9, 10, 10, 9, 5};
        double[][] reviewWaitHours = {
            {3, 5, 8, 2, 6}, {14, 22, 30, 9, 18, 26}, {4, 6, 3, 8, 5}, {20, 11, 27, 16, 31}, {2, 4, 3}};
        int totalDone = 0;
        for (int s = 0; s < planned.length; s++) {
            totalDone += done[s];
            double[] w = reviewWaitHours[s].clone();
            Arrays.sort(w);
            double median = w.length % 2 == 1 ? w[w.length / 2] : (w[w.length / 2 - 1] + w[w.length / 2]) / 2;
            System.out.printf("sprint %d: planned %2d, done %2d; median wait for first review %4.1f h%s%n",
                s + 1, planned[s], done[s], median, median > 12 ? "  <- slow" : "");
        }
        System.out.println("total points done: " + totalDone + " (Must 28 + Should 15 = 43)");
        System.out.printf("average velocity: %.1f%n", (double) totalDone / done.length);
    }
}
Output
sprint 1: planned 10, done  9; median wait for first review  5.0 h
sprint 2: planned 11, done 10; median wait for first review 20.0 h  <- slow
sprint 3: planned 10, done 10; median wait for first review  5.0 h
sprint 4: planned 10, done  9; median wait for first review 20.0 h  <- slow
sprint 5: planned  6, done  5; median wait for first review  3.0 h
total points done: 43 (Must 28 + Should 15 = 43)
average velocity: 8.6

What this code does

For each sprint the program prints the points planned and finished, and the median of how long its pull requests waited for a first review, which is less affected than a mean by one very slow review. The median is computed on a sorted copy, taking the middle value or the average of the two middle values. Sprints 2 and 4 stand out with waits of most of a day, while the total confirms that every Must and Should story was finished.

A bar chart of the five sprints with two bars each, points planned and points done: 10 and 9, 11 and 10, 10 and 10, 10 and 9, 6 and 5. A line above the bars shows the median wait for a first review in hours: 5, 20, 5, 20 and 3, with sprints 2 and 4 marked slow.
Points per sprint and the median wait for a first review.

The insights the team drew were about the system they had built for themselves, as the Prime Directive asked. Reviews were slow in sprints 2 and 4 because those were the sprints in which Noemi was writing most of the pages and the other two were busy, and nobody had treated review time as work to plan; the work-in-progress limit had exposed the problem but not solved it. Noemi's Sundays were the same problem seen from the other side: the plan had no slack for page work, which the estimates had undervalued since the planning poker vote on US-02, and the written check-ins asked what people had done but never how they were.

The retrospective's conclusions, August 25, 2028.
InsightWhat each of us will do in the next team
Reviewing is work, and unplanned work does not happenPut review time into sprint plans; agree a maximum wait, such as one working day
Estimates undervalued interface workSize front-end tasks separately, with the person who will build them
Nobody said they were overloadedAdd a fourth line to check-ins: how is your load this week?
Early feedback from users was the cheapestTest with users in the first sprint that has a page
The walking skeleton and the pipeline paid for themselvesBuild both first, every time

The last stage, closing, was short. Each person said one thing they appreciated about each of the others. Ingrid asked them to keep their individual reflections, which the college required, honest about what they had learned rather than a list of what they had done.

Individual contributions

The college asked each team member to show what they had contributed, using the repository's history. That history is real evidence, but Ingrid warned the team against reading it naively. A count of commits rewards people who commit often in small pieces, a count of lines rewards people who write verbose code, and neither counts reviewing, pairing, testing with users, writing the staff guide or the hour spent helping a teammate find a bug. The team's reflection presented the counts with that warning beside them, and with the work the counts could not see.

Java Example
import java.util.*;

public class Main {
    record Commit(String author, String type, String story, int coAuthors) {}

    public static void main(String[] args) {
        List<Commit> log = new ArrayList<>();
        String[][] sample = {
            {"Hamza", "feat", "US-01", "0", "14"}, {"Hamza", "feat", "US-03", "1", "9"}, {"Hamza", "fix", "-", "0", "11"},
            {"Noemi", "feat", "US-02", "0", "21"}, {"Noemi", "feat", "US-05", "0", "17"}, {"Noemi", "docs", "-", "0", "8"},
            {"Thierry", "feat", "US-07", "0", "12"}, {"Thierry", "test", "-", "0", "19"}, {"Thierry", "feat", "US-08", "1", "10"}};
        for (String[] s : sample)
            for (int i = 0; i < Integer.parseInt(s[4]); i++) log.add(new Commit(s[0], s[1], s[2], Integer.parseInt(s[3])));
        Map<String, Integer> reviews = Map.of("Hamza", 41, "Noemi", 33, "Thierry", 52);

        Map<String, Map<String, Integer>> byAuthor = new TreeMap<>();
        Map<String, Integer> paired = new TreeMap<>();
        for (Commit c : log) {
            byAuthor.computeIfAbsent(c.author(), a -> new TreeMap<>()).merge(c.type(), 1, Integer::sum);
            if (c.coAuthors() > 0) paired.merge(c.author(), 1, Integer::sum);
        }
        for (var e : byAuthor.entrySet()) {
            int commits = e.getValue().values().stream().mapToInt(Integer::intValue).sum();
            System.out.println(e.getKey() + ": " + commits + " commits " + e.getValue() + ", " + paired.getOrDefault(e.getKey(), 0)
                + " paired, " + reviews.get(e.getKey()) + " reviews given");
        }
        System.out.println("not counted: usability tests, the staff guide's test with volunteers, drills, help in the chat");
    }
}
Output
Hamza: 34 commits {feat=23, fix=11}, 9 paired, 41 reviews given
Noemi: 46 commits {docs=8, feat=38}, 0 paired, 33 reviews given
Thierry: 41 commits {feat=22, test=19}, 10 paired, 52 reviews given
not counted: usability tests, the staff guide's test with volunteers, drills, help in the chat

What this code does

The sample stands for the squash-merged commits on main, each with its author, its Conventional Commits type, its story and whether a Co-authored-by trailer named a pair. Grouping by author and type shows the different shapes of each person's work, Noemi's on pages and documents and Thierry's on tests, and the review counts come from the pull requests rather than the commits. The last line is part of the report on purpose, because the most important contributions are often the ones a log cannot see.

What comes next

The term ended that Friday, but the website did not. The Later page, which had started in May with Tamsin's fleet tracker, had grown into a short backlog that Odile now owned. The public launch was planned for Tuesday, September 26, with a new phone tally in October to test the first success measure. The email column's contract step waited for the counter app's next release. Kofi wanted part warnings on the weekly figures. Leif wanted to try the ahead-of-time cache from the deployment course to shorten start-up. And the fleet tracker had become, in Odile's words, the next capstone, if the college would send another team.

The backlog after the term.
ItemOwnerWhen
Public launch: shop website, social media, newsletterOdileTue Sep 26, 2028
New two-week phone tallyKofi and the counterOctober 2028
Remove the email column (contract step)HamzaAfter the counter app's next release
Part warnings in the weekly figuresHamzaAutumn 2028
Repair-night stand sign-up (US-10)Odile to decideAfter the public launch
Fleet maintenance trackerOdile, with the collegeProposed for the next capstone term

Two years earlier, in the autumn of 2026, Hamza had written his first Java program, a console tool for counting inner tubes in the parts room, after the shop ran out of them twice in one October. Ingrid reminded him of it at the end of the evening. The booking website used, somewhere, nearly everything that had come between: classes and records, collections and streams, files and a database, tests and builds, concurrency, a web service, a design that kept the rules in one place, a pipeline that made release night boring, and now a team, a client and users who had never heard of Java. The program had taught the language and its tools. The capstone had taught what they were for.

Exercises

Try it yourself

Does the demo fit?

Each part of the demo is name plannedSeconds rehearsedSeconds. Complete main so that it prints each part whose rehearsal took more than 15 seconds longer than planned as over: name (+N s), then the total rehearsed time as total M:SS, then fits if the total is at most 600 seconds, otherwise cut N s.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> parts = List.of("problem 90 120", "live-customer 150 185", "live-counter 90 95",
                                     "evidence 120 170", "results 90 80", "next 60 70");
        System.out.println("total 0:00");
    }
}

Try it yourself

Summarize the survey

Each answer is statement rating, with ratings from 1 to 5 and several answers per statement. Complete main so that it prints, in the order statements first appear, each statement with its mean to one decimal place and the word discuss when the mean is below 3.5 or the ratings differ by 2 or more.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<String> answers = List.of("clear-goals 5", "reviews-quick 3", "clear-goals 4", "reviews-quick 2",
            "sustainable-hours 2", "clear-goals 4", "reviews-quick 4", "sustainable-hours 4", "sustainable-hours 3");
        for (String a : answers) System.out.println(a);
    }
}

Common mistakes

  • MistakeTouring the code at a demo.

    InsteadTell the user's story: the problem, the software doing a real task, the evidence, the results and what is next.

  • MistakeDemonstrating live on production with real data.

    InsteadDemonstrate on staging with generated data, and record a backup video of every live part.

  • MistakePresenting small early numbers as proof.

    InsteadSay what the numbers can and cannot show, and say when they will be measured again.

  • MistakeRetrospectives that become a search for someone to blame.

    InsteadStart with the Prime Directive and look for causes in the system and the decisions.

  • MistakeLetting the loudest voice decide what the team felt.

    InsteadGather data first, including anonymous ratings, and discuss low means and wide spreads.

  • MistakeJudging contributions by commit counts.

    InsteadPresent the history with its limits, together with reviews, pairing and work a log cannot see.

Summary and key terms

  • On demo day, August 23, the team told the user's story in ten minutes: the phone tally, a customer booking and cancelling, the counter's morning, the evidence and the first results.
  • The live parts ran on staging with generated data, with a recorded backup, and two timed rehearsals brought the talk inside the limit by cutting detail rather than evidence.
  • Every Must and Should story was done and tested, with 381 automated tests, no axe-core violations, a p95 of 49 ms and twelve security findings fixed.
  • In twelve days of soft launch, 31 of 92 bookings were made on the web; the reminder comparison was presented as too small to judge.
  • The project retrospective on August 25 opened with the Prime Directive and followed the five stages of gathering data, generating insights and deciding actions.
  • Anonymous ratings and the board's data showed slow reviews in two sprints and unsustainable hours for one member, leading to plans to schedule review time, size interface work separately and ask about load.
  • Contributions were reported from the repository with the warning that logs miss much of the work, and the backlog passed to Odile, with the public launch planned for September 26.
Demo
A short presentation that shows working software solving a real problem for its users.
Backup video
A recording of a live demonstration, used if the live version fails.
Rehearsal
A timed practice of a presentation, used to find where it overruns.
Soft-launch figures
Early usage numbers from a small, unannounced release.
Retrospective
A meeting in which a team examines how it worked and decides what to change.
Prime Directive
Norm Kerth's statement that everyone did the best they could, read to keep retrospectives free of blame.
Five stages
Derby and Larsen's retrospective structure: set the stage, gather data, generate insights, decide, close.
Spread
The difference between the highest and lowest answers, showing whether people agree.
Median
The middle value of a sorted list, less affected by extreme values than the mean.
Backlog
The ordered list of work not yet done, owned by the person who decides priorities.

Practice problems

Work each problem on paper first, then reveal the answer to check.

  1. Why did the team demonstrate on staging rather than production?

    Show answer

    Production would have shown real customers' data, and a demo depending on the live SMS provider and the venue's network could fail.

  2. How did the second rehearsal get under ten minutes?

    Show answer

    By cutting stories and detail that did not serve the point, such as replacing the test pyramid explanation with one table of requirements.

  3. Why did Hamza say the reminder comparison proved nothing?

    Show answer

    One missed appointment in eighteen against five in sixty-two is too small a sample to rule out chance.

  4. What does the Prime Directive protect in a retrospective?

    Show answer

    The safety to discuss what went wrong by agreeing that the discussion is about the system and decisions, not blame.

  5. Why is a commit count a poor measure of contribution?

    Show answer

    It rewards committing often and misses reviewing, pairing, user testing, documentation and helping others.

Lesson quiz · 5 questions

Score 60% or more to complete this lesson.

Take the quiz