Version Control and Project Management Course

Lesson 1 • Core VCS Terminology

Defines repository, commit, branch, merge, tag, and working directory. Precise vocabulary is required before any hands-on tool usage.

Lesson 2 • Types of Version Control Systems

Contrasts local, centralised, and distributed VCS architectures. Connects architectural differences to real-world team workflow implications.

Lesson 3 • Installing and Configuring Git

Guides students through installing Git and setting identity, editor, and line-ending preferences. Correct configuration prevents common beginner errors.

Lesson 1 • Tagging Releases

Introduces lightweight and annotated tags for marking release points. Connects tagging to versioning conventions used in project management.

Lesson 2 • Inspecting Repository History

Teaches git log, diff, show, and status to read project history and detect changes. Builds diagnostic skills essential for debugging and code review.

Lesson 3 • Staging and Committing Changes

Explains the three-stage model: working directory, staging area, and commit history. Students practise crafting atomic, meaningful commits.

Lesson 4 • Initializing and Cloning Repositories

Covers git init for new projects and git clone for existing ones. Students understand the difference between creating and copying a repository.

Lesson 1 • Popular Branching Models

Compares Git Flow, GitHub Flow, and trunk-based development. Students select the model that fits their team size and release cadence.

Lesson 2 • Rebasing for a Clean History

Introduces git rebase as an alternative to merging that produces a linear commit history. Students learn when rebase is appropriate and when it is dangerous.

Lesson 3 • Branch Fundamentals

Explains how branches are lightweight pointers to commits and how HEAD tracks the active branch. Provides the mental model needed for all branching operations.

Lesson 4 • Cherry-Picking and Stashing

Teaches cherry-pick for applying individual commits across branches and stash for shelving incomplete work. Both tools handle common mid-task interruptions.

Lesson 1 • Working with Remotes

Explains remote references, origin conventions, and multiple remote setups. Students add, rename, and remove remotes to manage upstream sources.

Lesson 2 • Handling Remote Conflicts

Addresses diverged histories caused by concurrent pushes and how to reconcile them. Students practise rebase-before-push and force-push safety rules.

Lesson 3 • Access Control and Repository Permissions

Introduces role-based access, protected branches, and SSH vs. HTTPS authentication. Proper permissions prevent accidental overwrites and enforce review gates.

Lesson 1 • Automated Linting and Static Analysis

Integrates linters and static analysers into the repository to enforce style and catch bugs early. Automation reduces reviewer burden on mechanical issues.

Lesson 2 • Branch Protection and Merge Requirements

Configures required reviewers, status checks, and linear history rules on protected branches. These gates enforce quality standards before code reaches main.

Lesson 3 • Principles of Effective Code Review

Defines the goals of code review: correctness, readability, and knowledge transfer. Students distinguish constructive feedback from unproductive criticism.

Lesson 4 • Conducting Reviews on Hosted Platforms

Walks through inline comments, suggestion blocks, and approval workflows on platform PR interfaces. Connects platform features to the review principles taught earlier.

Lesson 1 • Risk Management in Software Projects

Teaches risk identification, probability-impact assessment, and mitigation planning. Students build a risk register and integrate it into sprint planning.

Lesson 2 • Kanban for Continuous Flow

Introduces Kanban boards, WIP limits, and flow metrics as an alternative to sprints. Students apply Kanban to maintenance and support-oriented workflows.

Lesson 3 • Agile and Scrum Essentials

Explains Agile values, Scrum roles, ceremonies, and artefacts for iterative delivery. Students connect sprint cycles to repository branching and release practices.

Lesson 4 • Project Lifecycle and Phases

Maps software projects to initiation, planning, execution, monitoring, and closure phases. Understanding the lifecycle prevents scope creep and missed deliverables.

Lesson 1 • Branch-Based Deployment Strategies

Maps branches to environments: feature branches to dev, main to staging, tags to production. Students implement environment-specific pipeline logic.

Lesson 2 • Pipeline Security and Secret Management

Covers secure storage of credentials, API keys, and tokens used in pipelines. Students apply least-privilege principles to pipeline service accounts.

Lesson 3 • CI/CD Concepts and Pipeline Anatomy

Defines continuous integration, delivery, and deployment and maps each to repository events. Students understand pipeline stages before writing any configuration.

Lesson 4 • Writing Pipeline Configuration Files

Teaches YAML-based pipeline syntax used by common CI platforms. Students write a working pipeline that builds and tests on every push.

Lesson 1 • Performance and Repository Maintenance

Covers git gc, shallow clones, partial clones, and large file storage for repository health. Students diagnose and resolve performance issues in large repositories.

Lesson 2 • Submodules and Subtrees

Compares git submodules and subtrees for embedding external dependencies in a repository. Students choose the right approach based on update frequency and team workflow.

Lesson 3 • Repository Governance Policies

Defines contribution guidelines, commit message conventions, and CODEOWNERS files. Governance policies reduce friction and enforce consistency across contributors.

Lesson 4 • Monorepo Management

Addresses the challenges of hosting multiple projects in one repository, including sparse checkout and tooling. Students configure a monorepo for a multi-package project.