Pair/Trio Programming Overview

This framework evaluates students in a Computer Science Project-based learning course. It focuses on planning, code, and code reviews to create a holistic profile of each student’s computer science and software engineering skills.

Note

The examples provided below are not comprehensive. Students are encouraged to identify additional strengths or areas for improvement within each category.

Evaluation Categories

1. Planning

Effective planning ensures that teams stay organized and on track. Use tools like GitHub Issues, Kanban Boards, and Burndown Lists to manage tasks and progress.

  • GitHub Issues:
    • Creates clear and descriptive issues for tasks or bugs.
    • Assigns issues to self and team members appropriately.
    • Closes issues with meaningful comments or references to commits.
  • Kanban Board:
    • Updates the board regularly to reflect task progress.
    • Moves tasks through stages (e.g., To Do, In Progress, Done).
    • Uses labels or tags to prioritize tasks effectively.
  • Burndown Lists:
    • Tracks progress toward Sprint goals.
    • Updates the list daily to reflect completed and remaining tasks.
    • Uses the list to identify blockers and adjust plans.

2. Code

Writing and managing code collaboratively is a key part of pair/trio programming. Use tools like Live Share, commits, branches, forks, and pull requests to ensure smooth collaboration.

  • Live Share:
    • Actively participates in Live Share sessions with teammates.
    • Shares the editor and communicates effectively during coding sessions.
    • Uses Live Share to debug or pair program in real time.
  • Commits:
    • Makes frequent, meaningful commits with descriptive messages.
    • Avoids committing large, unrelated changes in a single commit.
    • Pushes commits regularly to keep the repository updated.
  • Branch Management:
    • Creates branches for new features or fixes.
    • Merges branches only after testing and review.
    • Deletes branches after they are merged to keep the repository clean.
  • Forks and Pull Requests:
    • Creates forks for collaborative projects.
    • Submits pull requests with clear descriptions and references to issues.
    • Responds to feedback on pull requests and makes necessary changes.

3. Code Review

Code reviews ensure quality and help teammates learn from each other. Focus on comments, pair testing, debugging, and structured reviews.

  • Comments:
    • Leaves constructive comments on pull requests or commits.
    • Asks clarifying questions when code is unclear.
    • Suggests improvements or alternative approaches when appropriate.
  • Pair Testing:
    • Tests code written by teammates to ensure functionality.
    • Identifies edge cases and potential bugs during testing.
    • Provides feedback on test results and suggests fixes.
  • Debugging:
    • Works collaboratively to debug issues.
    • Uses tools like breakpoints, logs, or debuggers effectively.
    • Documents the debugging process and solutions.
  • Code Review:
    • Reviews pull requests thoroughly before approving.
    • Checks for adherence to coding standards and best practices.
    • Ensures that code is well-documented and maintainable.

Hacks: Pair Programming Table

Use the table below to evaluate your pair/trio programming habits. These examples are not exhaustive—students should also consider other strengths or areas for improvement.

Ranking to Ratio

  • 1 = 0.55
  • 2 = 0.75
  • 3 = 0.85
  • 4 = 0.90
Skill Mastered (Y/N) Rank (1-4) Ratio Notes
GitHub Issues [ ] 0 0.0  
Kanban Board [ ] 0 0.0  
Burndown Lists [ ] 0 0.0  
Live Share [ ] 0 0.0  
Commits [ ] 0 0.0  
Branch Mgmt [ ] 0 0.0  
Forks/PRs [ ] 0 0.0  
Comments [ ] 0 0.0  
Pair Testing [ ] 0 0.0  
Debugging [ ] 0 0.0  
Code Review [ ] 0 0.0  
Total 0 0 0.0  
Average   0.0 0.0