Algorithm Development with GitHub Copilot

Taxonomy Dimensions

Primary Purpose: Skill Development, Process Augmentation
Integration Depth: Embedded Practice
Student Agency: Guided Exploration
Assessment Alignment: Comparative Analysis, Critical Evaluation
Technical Implementation: Tool Selection, Prompt Engineering
Ethics & Professional Development: Professional Norms, Attribution Practices

Course Context

Data Structures and Algorithms course for sophomore/junior computer science students where students often struggle with implementing algorithms from pseudocode, understanding algorithm efficiency, and developing testing strategies.

Implementation Description

Activity Overview

Students use GitHub Copilot to explore multiple implementations of classic algorithms, focusing on algorithm design patterns, efficiency analysis, and testing rather than syntax details. They progressively develop the ability to direct AI tools for increasingly complex algorithmic tasks.

Step-by-Step Implementation

Fundamentals Phase (Weeks 1-3):
- Introduction to algorithm design without AI assistance
- Manual implementation of basic algorithms
- Analysis techniques for algorithm efficiency
- Development of robust testing strategies
Copilot Introduction (Week 4):
- Introduction to GitHub Copilot capabilities and limitations
- Practice with effective prompting techniques
- Guided exercises comparing manual and AI-assisted implementations
- Critical evaluation of generated code
Comparative Implementation (Weeks 5-7):
- Students design algorithms conceptually first
- Implement using traditional approach and with Copilot
- Compare different implementations for readability and efficiency
- Analyze how Copilot's suggestions influence design choices
- Identify and correct potential errors in AI-generated code
Algorithmic Optimization (Weeks 8-10):
- Use Copilot to generate multiple algorithm implementations
- Analyze trade-offs in time and space complexity
- Benchmark different approaches
- Document optimization decisions with justifications
- Develop a personal approach to AI-assisted optimization
Complex Algorithm Implementation (Weeks 11-14):
- Students tackle advanced algorithms with Copilot assistance
- Break down complex problems into manageable components
- Direct Copilot with increasingly sophisticated prompting
- Integrate and test multiple algorithm components
- Document development process and AI contributions

Example Prompts

Algorithm Comparison Prompt

# I need to implement three different sorting algorithms and compare their performance:
# 1. Merge sort
# 2. Quick sort
# 3. Heap sort
# 
# For each algorithm I need:
# - A clear implementation with good documentation
# - Time complexity analysis (best, average, worst case)
# - Space complexity analysis
# - Implementation of a benchmark function to compare performance on different input sizes and distributions
# 
# Let's start with merge sort:

def merge_sort(arr):
    # Implementation of merge sort

Algorithm Optimization Prompt

# I've implemented this graph traversal algorithm for finding all paths between two nodes,
# but it's inefficient for large graphs. Help me optimize it considering:
# 1. Time complexity
# 2. Space complexity
# 3. Early termination possibilities
# 4. Memoization opportunities

def find_all_paths(graph, start, end, path=[]):
    path = path + [start]
    if start == end:
        return [path]
    if start not in graph:
        return []
    paths = []
    for node in graph[start]:
        if node not in path:
            new_paths = find_all_paths(graph, node, end, path)
            for new_path in new_paths:
                paths.append(new_path)
    return paths

# Please provide an optimized version with comments explaining the improvements

Testing Strategy Prompt

# I've implemented a Red-Black Tree with the following operations:
# - insert(key, value)
# - delete(key)
# - search(key)
# - get_min(), get_max()
#
# Help me create a comprehensive testing strategy that:
# 1. Tests edge cases
# 2. Verifies red-black tree properties are maintained
# 3. Benchmarks performance against Python's built-in dictionaries
# 4. Includes property-based testing to find potential bugs
#
# Start by implementing test functions for each of these aspects

import unittest
from red_black_tree import RedBlackTree

class TestRedBlackTree(unittest.TestCase):
    def setUp(self):
        self.tree = RedBlackTree()
    
    # Unit tests for basic functionality

Assessment Strategies

Algorithm Development Portfolio (35%):
- Students document multiple algorithm implementations
- Include comparative analysis of different approaches
- Document the evolution of their Copilot prompting technique
- Provide critical evaluation of AI-generated code
- Include reflection on optimal human-AI collaboration for different algorithm types
Optimization Challenge (25%):
- Students receive inefficient algorithm implementations
- Use Copilot to explore optimization strategies
- Document the optimization process and decisions
- Benchmark and analyze performance improvements
- Justify final implementation choices with technical analysis
Algorithm Design and Testing (20%):
- Students design algorithms to solve novel problems
- Develop comprehensive test suites with Copilot assistance
- Implement edge case handling strategies
- Document testing approach and coverage
- Demonstrate bug detection and resolution
Independent Implementation (20%):
- Closed-book, no-AI implementation of algorithm variations
- Focus on core algorithm concepts rather than syntax
- Demonstrate understanding of algorithm design patterns
- Apply optimization techniques learned through AI collaboration
- Explain implementation decisions based on efficiency considerations

Implementation Considerations

Required Resources

GitHub Copilot licenses for all students
IDE integration for Copilot (VS Code, JetBrains)
Version control system to track implementation evolution
Performance benchmarking framework
Code quality analysis tools

Common Challenges

Students may over-rely on Copilot without understanding
Copilot may generate incorrect or inefficient implementations
Varying levels of student experience with directing AI tools
Attribution and academic integrity considerations
Managing student expectations about Copilot capabilities

Integration Tips

Start with simpler algorithms where correctness is easily verified
Require pseudocode or algorithm design before Copilot use
Implement pair programming with designated "navigator" and "driver" roles
Focus grading on analysis and justification rather than implementation
Use code reviews to encourage critical evaluation of Copilot-generated code

Faculty Experience Required

Strong understanding of algorithm design principles
Familiarity with GitHub Copilot capabilities and limitations
Experience with effective prompting techniques for code generation
Understanding of academic integrity considerations for AI-assisted programming
Ability to evaluate students' critical analysis of generated code

This example was developed as part of the "Strategies for Integrating Generative AI in Engineering Education" workshop materials.

Algorithm Development with Copilot