Using GitHub & Project Management Tools

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

GitHub: More Than Just Storage

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

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]

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

Project Management Tools Overview

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

Additional Project Management Tools

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

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

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

Backup & Version Control Strategy

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

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