Handling Projects: Release Plans and Release Notes
Plan a release with tasks and dependencies, find the critical path, write release notes from history, and react when the plan changes.
In this lesson you will
- Write release notes from history
- Plan tasks and find the critical path
- Explain slack
- Update a plan when it changes
About 32 minutes
A release is a project
The garden club decides to publish version 1.0 of its notes: the plan and the rota, in their best state, with a name and a date that people can rely on. Nia is asked to run it. She quickly learns that shipping something is not one task, it is six, and that they depend on each other. This lesson shows how to plan a release, how to write release notes from history, and how to react when the plan changes.
Release notes from real history
If commit messages follow a simple pattern, the release notes almost write themselves. The messages in the session start with a short word and a colon: feat for something new, fix for a repair, docs for documentation. The log command lists every commit between the two tags, and the tag range counts 5 of them.
$ mkdir garden-notes
$ cd garden-notes
$ git init
Initialized empty Git repository in /home/nia/garden-notes/.git/
$ echo "Beans: row 1" > plan.txt
$ git add plan.txt
$ git commit -m "feat: add the planting plan"
[main (root-commit) 53576e2] feat: add the planting plan
1 file changed, 1 insertion(+)
create mode 100644 plan.txt
$ echo "Mon: Nia" > rota.txt
$ git add rota.txt
$ git commit -m "feat: add the rota"
[main 5b973e9] feat: add the rota
1 file changed, 1 insertion(+)
create mode 100644 rota.txt
$ git tag v0.9.0
$ echo "Carrots: row 2" >> plan.txt
$ git commit -am "feat: add carrots"
[main 79dcb06] feat: add carrots
1 file changed, 1 insertion(+)
$ echo "Beans: row 1 (fixed)" > plan.txt
$ git commit -am "fix: correct the beans row"
[main 15766dd] fix: correct the beans row
1 file changed, 1 insertion(+), 2 deletions(-)
$ echo "Tue: Dev" >> rota.txt
$ git commit -am "feat: add Tuesday to the rota"
[main dd435d2] feat: add Tuesday to the rota
1 file changed, 1 insertion(+)
$ echo "Mon: Nia Okafor" > rota.txt
$ git commit -am "fix: use the full name on Monday"
[main 97fc2ea] fix: use the full name on Monday
1 file changed, 1 insertion(+), 2 deletions(-)
$ echo "Notes: see README" >> plan.txt
$ git commit -am "docs: point to the README"
[main c6d7319] docs: point to the README
1 file changed, 1 insertion(+)
$ git tag -a v1.0.0 -m "First full release"
$ git log --format="%s" v0.9.0..v1.0.0
docs: point to the README
fix: use the full name on Monday
feat: add Tuesday to the rota
fix: correct the beans row
feat: add carrots
$ git log --oneline v0.9.0..v1.0.0 | wc -l
5
A short program groups those subjects under headings. Because it reads the real history, it cannot forget a change, and it never invents one. A person still decides what is worth telling users, and rewrites technical lines into plain words, but the first draft costs nothing.
import subprocess, collections
out = subprocess.run(["git", "-C", "/home/nia/garden-notes", "log", "--format=%s", "v0.9.0..v1.0.0"], capture_output=True, text=True).stdout.splitlines()
groups = collections.OrderedDict([("feat", "New"), ("fix", "Fixed"), ("docs", "Documentation")])
notes = collections.defaultdict(list)
for line in out:
kind, _, text = line.partition(": ")
notes[kind].append(text)
print("Release notes for v1.0.0")
for kind, heading in groups.items():
if notes[kind]:
print(heading + " (" + str(len(notes[kind])) + ")")
for text in reversed(notes[kind]):
print(" - " + text)
Release notes for v1.0.0
New (2)
- add carrots
- add Tuesday to the rota
Fixed (2)
- correct the beans row
- use the full name on Monday
Documentation (1)
- point to the README
The notes list 5 changes under three headings. The tag pair defines “what is in this release” exactly, which is the strongest argument for tagging every release, as lesson 17 recommended.
The plan: tasks, order and the critical path
Now the schedule. A release plan lists the tasks, how long each takes, and which must finish before another can start. The critical path is the longest chain of dependent tasks. It decides the earliest finish, and any delay on it delays the release. Tasks off the path have slack: room to be late without changing the end date. Here the documents can be updated while bugs are fixed, so they have slack. The program computes the finish times itself, then finds the longest chain a second way, by listing every route and adding it up.
import networkx as nx
import numpy as np
tasks = {"freeze scope": 1, "fix known bugs": 3, "update docs": 2, "review": 1, "tag and publish": 1, "announce": 1}
deps = [("freeze scope", "fix known bugs"), ("freeze scope", "update docs"), ("fix known bugs", "review"), ("update docs", "review"), ("review", "tag and publish"), ("tag and publish", "announce")]
g = nx.DiGraph()
for name, days in tasks.items(): g.add_node(name, days=days)
g.add_edges_from(deps)
finish = {}
for name in nx.topological_sort(g):
start = max([finish[p] for p in g.predecessors(name)], default=0)
finish[name] = start + tasks[name]
total = max(finish.values())
longest = max(nx.all_simple_paths(g, "freeze scope", "announce"), key=lambda p: sum(tasks[n] for n in p))
print("total working days:", total)
print("critical path:", " > ".join(longest))
start = np.datetime64("2026-11-09")
print("starts:", np.datetime_as_string(start), "(Monday)")
last = np.busday_offset(start, total - 1, roll="forward")
print("ends:", np.datetime_as_string(last), np.datetime64(last, "D").astype(object).strftime("(%A)"))
tasks["fix known bugs"] = 5
finish2 = {}
for name in nx.topological_sort(g):
st = max([finish2[p] for p in g.predecessors(name)], default=0)
finish2[name] = st + tasks[name]
print("if bug fixing takes 5 days:", max(finish2.values()), "working days")
last2 = np.busday_offset(start, max(finish2.values()) - 1, roll="forward")
print("new end:", np.datetime_as_string(last2), np.datetime64(last2, "D").astype(object).strftime("(%A)"))
total working days: 7
critical path: freeze scope > fix known bugs > review > tag and publish > announce
starts: 2026-11-09 (Monday)
ends: 2026-11-17 (Tuesday)
if bug fixing takes 5 days: 9 working days
new end: 2026-11-19 (Thursday)
The plan needs 7 working days, and the critical path is: freeze scope > fix known bugs > review > tag and publish > announce. Starting on Monday 9 November 2026, the release lands on Tuesday 17 November 2026. Weekends are skipped, and the sample plan ignores public holidays. The documents task is not on the path, so a one day delay there changes nothing, while a one day delay in bug fixing moves the date by a whole day.
When the plan changes
Midway, the club discovers that bug fixing will take five days, not three. The program shows the effect at once: the total becomes 9 working days and the new end date is Thursday 19 November 2026. Changes like this are normal. What matters is that you notice, you tell the people waiting, and you decide on purpose: move the date, remove a task, or add help. A plan that is never updated is only a wish.
A release checklist built from this course
- Freeze. Decide what is in the release, and write the rest down for next time.
- Check. The checks from lessons 23 and 24 pass on the exact commit you will tag.
- Tag. Create an annotated tag, push it, and write the notes.
- Have a way back. Know which tag to return to, and how: revert from lesson 5, or a branch from the old tag.
- Tell people. Announce what changed and where to report problems.
Tagging a commit that was never checked, because everyone was in a hurry. A tag is permanent, and a bad release with a good looking number is hard to undo gracefully.
The tasks, durations, dates and release notes are made up, and the sample plan ignores public holidays and part days. Real projects add risks, people’s availability, and testing time, which this small model leaves out.
Practice for this lesson
Check what you learned
Five quick questions. Pick an answer and you will see straight away whether it is right and why.
Why do consistent commit messages help release notes?
- Git requires them
- They make commits smaller
- They hide bugs
- A program can group them under headings without guessing
The notes were built from the prefixes feat, fix and docs.
What does a pair of tags define?
- The author of the release
- Exactly which changes are in the release between them
- The price of the release
- The branch name
The log between the two tags listed five commits.
What is the critical path?
- The most important person
- The shortest task
- The longest chain of dependent tasks, which sets the earliest finish
- The first task only
Delays on it delay the release.
Why did a delay in updating the documents not move the date?
- That task had slack because it ran alongside bug fixing
- Documents never matter
- The date was fixed
- Git hides document changes
It was not on the critical path.
What should you do when a task takes longer than planned?
- Hide it until the end
- Tag the release anyway
- Update the plan, tell people, and decide on purpose
- Delete the plan
Five days of bug fixing moved the end date later.
Summary
- Tags define exactly what is in a release, and commit patterns make notes automatic.
- The critical path decides the earliest finish; other tasks have slack.
- Update the plan, tell people, and decide on purpose when it changes.
- Check before you tag, and know your way back.
Questions
Do I need a formal commit message style?
Not formally, but a simple pattern pays off at release time. Pick one, write it in your contributing notes, and let a hook or review enforce it.
How far ahead should I plan a release?
Plan in small pieces you can estimate. The further ahead you plan, the more you should treat the dates as guesses.
What about public holidays and part days?
Real plans should include them. This lesson's model skips weekends only, so adjust it for your own calendar.
