← Back to Module

Using GitHub & Project Management Tools

CMU601: Dissertation - Week 6

Birmingham Newman University

Lecturer: James Williams

Undergraduate Final Year Project

3-hour session • 30 slides • 2 practical tasks

Session Timeline:

  • 10 min: Introduction & objectives
  • 45 min: GitHub workflows & collaboration
  • 40 min: Task 1 - Advanced GitHub features
  • 15 min: Break/Catch up
  • 30 min: Project management tools overview
  • 40 min: Task 2 - Set up project board
  • Remaining: Self-directed work

Learning Objectives

  • Master GitHub workflows for solo and collaborative development
  • Use branches, pull requests, and GitHub Issues effectively
  • Implement project management with Kanban boards
  • Explore various project management tools (Trello, Jira, etc.)
  • Track dissertation progress systematically
  • Demonstrate professional development practices
Why This Matters: Professional developers use these tools daily. Mastering them shows technical maturity and makes your work more manageable.

GitHub: More Than Just Storage

GitHub is a complete project management platform

Key Features for Dissertation Projects:

  • Version Control: Track every change, revert when needed
  • Branches: Work on features without breaking main code
  • Issues: Track bugs, tasks, and features
  • Projects: Kanban boards integrated with your repo
  • Wiki: Documentation beyond README
  • Releases: Version your dissertation milestones
  • GitHub Actions: Automate testing and deployment
  • Insights: Visualize your development activity

Branching Strategy for Dissertations

Why Use Branches?

  • Experiment safely without breaking working code
  • Develop features independently
  • Easy to show supervisor "stable" vs "experimental" versions
  • Organize work by feature or iteration

Recommended Structure:

main # Stable, working version
├── develop # Integration branch
├── feature/user-auth # User authentication feature
├── feature/dashboard # Dashboard implementation
├── feature/api # API development
└── bugfix/login-error # Bug fixes

Golden Rule: Main branch should always be deployable/demonstrable

Essential Branch Commands

Creating and Switching Branches:

# Create new branch
git branch feature/user-authentication

# Switch to branch
git checkout feature/user-authentication

# Create and switch in one command
git checkout -b feature/user-authentication

# See all branches
git branch -a

# Switch back to main
git checkout main

Merging Branches:

# Switch to main branch
git checkout main

# Merge feature branch into main
git merge feature/user-authentication

# Push to GitHub
git push origin main

Example: Implementing a New Feature

Scenario: Adding Email Notifications

# 1. Create feature branch from main
git checkout main
git pull origin main # Get latest changes
git checkout -b feature/email-notifications

# 2. Make changes, commit regularly
# ... edit files ...
git add .
git commit -m "Add email service configuration"
# ... more changes ...
git commit -m "Implement notification templates"
git commit -m "Add email sending functionality"

# 3. Push feature branch to GitHub
git push origin feature/email-notifications

# 4. Test feature thoroughly

# 5. Merge back to main when ready
git checkout main
git merge feature/email-notifications
git push origin main

# 6. Delete feature branch (optional)
git branch -d feature/email-notifications

GitHub Issues: Your Task Tracker

Issues help you organize work and demonstrate systematic development

What to Track with Issues:

  • Features: New functionality to implement
  • Bugs: Problems that need fixing
  • Enhancements: Improvements to existing features
  • Documentation: Writing or updating docs
  • Research: Investigation tasks

Issue Best Practices:

  • Use descriptive titles: "Add user authentication" not "Feature"
  • Include context in description
  • Add labels (bug, enhancement, documentation)
  • Reference issues in commits: "Fix #12: Resolve login timeout"
  • Close issues when complete

Writing Good Issues

❌ Poor Issue:

Title: Fix stuff

Description: The thing isn't working

✅ Good Issue:

Title: Add password reset functionality

Description:
Users need ability to reset forgotten passwords.

Requirements:
- Email verification link to user
- Secure token generation (expires in 1 hour)
- New password form
- Update password in database
- Confirmation email

Acceptance Criteria:
- User receives reset email within 1 minute
- Token expires after 1 hour
- Password meets security requirements
- User can login with new password

Related: #15 (User authentication system)

Labels: enhancement, user-management

GitHub Projects: Built-in Kanban

Setting Up a Project Board:

  1. Go to your repository on GitHub
  2. Click "Projects" tab
  3. Create "New project"
  4. Choose "Board" template
  5. Create columns: To Do, In Progress, Done
  6. Add issues as cards to columns

Workflow:

To Do → In Progress → In Review → Done

Example:
- Issue #12: Add user profiles [To Do]
- Issue #15: Database optimization [In Progress]
- Issue #18: Implement search [In Review]
- Issue #21: Setup CI/CD [Done]
Benefit: Visual progress tracking perfect for demonstrating systematic development in your dissertation report!

Pull Requests (PRs)

What is a Pull Request?

A way to propose changes from one branch to another, with review and discussion.

Why Use PRs for Solo Projects?

  • Review your own code before merging
  • Create documented history of major changes
  • Supervisor can review code easily
  • Automatic checks (if you set up GitHub Actions)
  • Professional development practice

Creating a Pull Request:

  1. Push feature branch to GitHub
  2. Go to repository on GitHub
  3. Click "Pull requests" → "New pull request"
  4. Select base (main) and compare (feature) branches
  5. Add title and description
  6. Create pull request
  7. Review changes, then merge

Task 1: Implement GitHub Workflow

Objective:

Set up professional GitHub workflow for your dissertation project

Activity Steps:

  1. Create a GitHub Project board for your repository
  2. Add columns: Backlog, To Do, In Progress, Done
  3. Create 5-7 issues for upcoming features/tasks
  4. Add labels to categorize issues (bug, feature, docs, etc.)
  5. Create a new feature branch for one task
  6. Make changes on that branch and commit
  7. Push branch to GitHub
  8. Create a Pull Request with detailed description
  9. Review and merge your PR
  10. Close the related issue

Deliverable:

Working project board with issues and at least one completed PR

Time:

40 minutes

Project Management Tools Overview

The right tool helps you stay organized and productive

Why Use PM Tools?

  • Visualize what needs to be done
  • Track progress over time
  • Plan iterations and sprints
  • Manage deadlines and milestones
  • Document development decisions
  • Share progress with supervisors

Popular Options:

  • Trello: Simple, visual, Kanban-based
  • Jira: Comprehensive, agile-focused
  • Asana: Task-focused with timeline views
  • Notion: All-in-one workspace
  • Monday.com: Highly customizable

Trello: Visual Project Management

Key Features:

  • Boards: Represent projects
  • Lists: Columns for workflow stages
  • Cards: Individual tasks
  • Labels: Color-coded categories
  • Checklists: Sub-tasks within cards
  • Due Dates: Deadline tracking
  • Attachments: Files, links, images
  • Power-Ups: Integrations (GitHub, Calendar, etc.)

Sample Board Structure:

Dissertation Board:
├── 📋 Research & Planning
├── 🔥 This Week
├── 👨‍💻 In Development
├── 🧪 Testing
├── 📝 Documentation
└── ✅ Complete

Setting Up Trello for Dissertations

Example Cards:

Card: "Implement User Authentication"
List: In Development
Labels: Backend, High Priority
Due Date: March 15, 2025

Description:
Build secure authentication system with JWT tokens

Checklist:
☑ Design database schema for users
☑ Implement registration endpoint
☐ Implement login endpoint
☐ Add JWT token generation
☐ Add password hashing
☐ Write unit tests
☐ Update API documentation

Attachments:
- auth-flow-diagram.png
- JWT-research.pdf

Comments:
"Using bcrypt for password hashing - more secure than md5"

Jira: Professional Agile Tool

When to Use Jira:

  • Complex projects with many components
  • Want to learn industry-standard tool
  • Need advanced reporting features
  • Planning sprints and iterations

Key Features:

  • Epic: Large feature (e.g., "User Management System")
  • Story: User-focused feature (e.g., "As a user, I can reset my password")
  • Task: Work item (e.g., "Create password reset form")
  • Bug: Issues to fix
  • Sprints: 1-2 week development cycles
  • Reports: Burndown charts, velocity tracking
Free for students! Use your .ac.uk email to get free access

Additional Project Management Tools

Notion

All-in-one workspace combining docs, wikis, and databases. Great for documentation alongside project management.

Asana

Task management with timeline and calendar views. Good for deadline-heavy projects.

ClickUp

Comprehensive tool with docs, tasks, goals, and time tracking. Highly customizable.

Todoist

Simple task manager with natural language dates. Good for personal task tracking.

Choosing Your Tool:

  • Start simple (Trello or GitHub Projects)
  • Choose based on project complexity
  • Consider what you'll actually use consistently
  • Free tier is usually sufficient for dissertations

Time Tracking for Dissertations

Tracking time helps with project planning and demonstrates work in reports

Why Track Time?

  • Understand how long tasks actually take
  • Improve future estimates
  • Document effort for dissertation report
  • Identify time-consuming areas
  • Prove consistent work to supervisors

Recommended Tools:

  • Toggl Track: Simple time tracking with reports
  • Clockify: Free unlimited time tracking
  • RescueTime: Automatic tracking of computer activity
  • WakaTime: Automatic coding time tracking (IDE plugin)

Understanding Kanban

Core Principles:

  • Visualize Work: See all tasks at a glance
  • Limit WIP: Work In Progress - focus on finishing tasks
  • Flow: Move tasks smoothly through stages
  • Continuous Improvement: Reflect and adjust

Typical Kanban Board:

┌─────────┬──────────┬────────────┬──────┐
│ Backlog │ To Do │ In Progress│ Done │
├─────────┼──────────┼────────────┼──────┤
│ Task A │ Task D │ Task G │Task J│
│ Task B │ Task E │ Task H │Task K│
│ Task C │ Task F │ │Task L│
│ │ │ │ │
└─────────┴──────────┴────────────┴──────┘

WIP Limit: Max 2 tasks in "In Progress"

Golden Rule: Finish what you start before taking on new tasks

Sprint Planning for Dissertations

What is a Sprint?

A fixed time period (1-2 weeks) where you commit to completing specific tasks.

Benefits for Dissertations:

  • Creates regular milestones and deadlines
  • Forces prioritization of work
  • Natural review and reflection points
  • Manageable chunks of work
  • Regular sense of progress and completion

Example Sprint Plan:

Sprint 3 (Feb 10-23):

Sprint Goal: Complete user authentication system

Tasks:
1. Design database schema (3h) - HIGH
2. Implement registration (5h) - HIGH
3. Implement login (4h) - HIGH
4. Add password hashing (2h) - HIGH
5. Write tests (4h) - MEDIUM
6. Update documentation (2h) - MEDIUM

Total: 20 hours over 2 weeks = 10h/week

Establishing Development Routines

Daily Routine (15-30 minutes):

Morning:
1. Review project board
2. Pick 1-2 tasks for today
3. Move cards to "In Progress"
4. Start timer (if tracking time)

During Development:
1. Work on tasks
2. Commit regularly
3. Update card checklists

Evening:
1. Move completed tasks to "Done"
2. Stop timer
3. Quick reflection note
4. Plan tomorrow's task

Weekly Review (30-60 minutes):

  • Review completed tasks
  • Update project timeline
  • Plan next week's sprint
  • Document any blockers
  • Backup code and documents

Documentation Management

Where to Keep Documentation:

  • GitHub Wiki: Technical docs, API reference
  • Notion: Research notes, meeting notes
  • Google Docs: Dissertation writing, shared docs
  • Markdown Files: In repository (docs/ folder)

Essential Documentation:

  • README.md: Project overview and setup
  • CHANGELOG.md: Version history
  • ARCHITECTURE.md: System design decisions
  • API.md: API endpoints and usage
  • DEVELOPMENT-LOG.md: Weekly progress notes
  • TESTING.md: Testing strategy and results

Task 2: Set Up Project Management

Objective:

Create comprehensive project management system for your dissertation

Activity Steps:

  1. Choose a PM tool (Trello recommended for simplicity)
  2. Create a board for your dissertation project
  3. Set up columns matching your workflow
  4. Create cards for all major features and tasks
  5. Add detailed descriptions and checklists to cards
  6. Set due dates for upcoming milestones
  7. Create labels for categorization
  8. If using Trello, add GitHub Power-Up
  9. Move 2-3 cards to "In Progress"
  10. Create a development log document

Bonus:

  • Set up time tracking with Toggl or Clockify
  • Create calendar view of deadlines
  • Share board with supervisor

Time:

40 minutes

Communication & Collaboration Tools

Staying Connected:

  • Slack: Team communication, channels for different topics
  • Discord: Voice chat, screen sharing, communities
  • Microsoft Teams: University standard, includes video calls
  • Email: Formal supervisor communication

For Supervisor Meetings:

  • Share your project board link before meetings
  • Prepare demo of recent progress
  • Document decisions in meeting notes
  • Create issues for supervisor feedback
  • Send summary email after each meeting
Pro Tip: Keep meeting notes in a shared document both you and supervisor can access

Backup & Version Control Strategy

⚠️ CRITICAL: Multiple backups prevent disaster!

3-2-1 Backup Rule:

  • 3 copies: Original + 2 backups
  • 2 different media: Local + Cloud
  • 1 offsite: Cloud or remote location

Backup Locations:

  • GitHub: Code and documentation (primary)
  • University OneDrive: Dissertation document, reports
  • Google Drive: Secondary backup
  • External Drive: Weekly full backups
  • Local Machine: Working copies

What to Backup:

  • All source code (GitHub handles this)
  • Dissertation report drafts
  • Design documents and diagrams
  • Research notes and references
  • Test data and results

Automation to Save Time

GitHub Actions (CI/CD):

# .github/workflows/tests.yml
name: Run Tests

on: [push, pull_request]

jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Python
uses: actions/setup-python@v2
with:
python-version: 3.11
- name: Install dependencies
run: pip install -r requirements.txt
- name: Run tests
run: pytest

Other Automation:

  • Code formatters: Black (Python), Prettier (JS) - auto-format code
  • Linters: Pylint, ESLint - catch errors automatically
  • Zapier/IFTTT: Connect tools (GitHub → Trello updates)

Tracking and Reporting Progress

What to Track:

  • Commits: GitHub tracks automatically
  • Completed Features: Project board visualization
  • Time Spent: Time tracking tools
  • Milestones: Major achievements
  • Challenges: Problems and solutions
  • Decisions: Why you made certain choices

Creating Progress Reports:

Weekly Progress Report Template:

Week: [Date Range]

Completed:
- Implemented user authentication (8 hours)
- Wrote unit tests for auth module (3 hours)
- Updated API documentation (2 hours)

In Progress:
- User profile page (60% complete)

Next Week:
- Complete user profiles
- Start dashboard implementation

Challenges:
- JWT token validation took longer than expected
- Resolved by reading RFC 7519 specification

Decisions:
- Chose bcrypt over argon2 for password hashing
- Better Python library support

Showcasing Professional Development

Your dissertation report should demonstrate professional practices!

Include in Your Report:

  • Screenshots of project management boards
  • GitHub commit graphs showing consistent development
  • Issue tracking showing systematic problem-solving
  • Branch strategy diagrams
  • Development timeline with milestones
  • Testing coverage reports
  • Code review examples (PRs)

Markers Look For:

  • Evidence of planning and organization
  • Systematic approach to development
  • Professional tools and workflows
  • Regular, consistent progress
  • Problem-solving documentation

Common Project Management Mistakes

❌ What NOT to Do:

  • Tool Hopping: Switching tools constantly instead of committing to one
  • Over-Planning: Spending more time planning than doing
  • Ignoring Tools: Setting up boards but never updating them
  • Too Complex: Creating complicated workflows you won't maintain
  • No Updates: Forgetting to move cards or update status
  • Giant Commits: Committing weeks of work at once
  • Poor Messages: Commit messages like "updates" or "fix"

✅ What TO Do:

  • Pick one tool and stick with it
  • Keep it simple - complexity kills adoption
  • Update boards daily or weekly
  • Commit early and often
  • Write clear commit messages
  • Regular backups

Your Action Plan

Immediate Actions (Today):

  • Complete Task 1: Set up GitHub workflow
  • Complete Task 2: Create project management board
  • Create development log document

This Week (Days 1-7):

  • Move at least 3 tasks from "To Do" to "Done"
  • Make daily commits to GitHub
  • Update project board daily
  • Track time spent on development
  • Write weekly progress entry

Next Two Weeks:

  • Complete one full sprint
  • Create and merge 2-3 pull requests
  • Close 5-7 GitHub issues
  • Prepare progress demo for supervisor
  • Backup all work in multiple locations

Key Takeaways

Remember:

  • GitHub is more than storage - use its full features
  • Use branches for feature development
  • Track work with issues and project boards
  • Choose ONE project management tool and use it consistently
  • Update boards and commit code regularly
  • Document your development process
  • These tools demonstrate professionalism in your report!

🎯 Success Metrics

By end of this week, you should have:

  • Active GitHub project board
  • 5+ open/closed issues
  • At least 1 merged pull request
  • Project management tool set up
  • 10+ task cards created
  • Development log started

Contact: JWilliams@Staff.newman.ac.uk

Next Week: Doing Design Diagrams