Ontwerp een GitHub Copilot-gebaseerde debugassistent voor mijn codebase
description
Met deze prompt kunnen gebruikers een efficiënte debugassistent bouwen met GitHub Copilot, die helpt bugs snel te identificeren en op te lossen, afgestemd op hun specifieke project en programmeertaal. Het pakt veelvoorkomende en unieke debuguitdagingen aan en verbetert de codekwaliteit terwijl het de handmatige inspanning vermindert ten opzichte van traditionele methoden.
prompt
Help me een GitHub Copilot-ondersteunde debugassistent te ontwerpen die is afgestemd op mijn project. Beschrijf hoe ik Copilot kan gebruiken om fouten te detecteren, fixes voor te stellen en de oorzaken van bugs in mijn codebase te begrijpen. Projecttype: <voer het type ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een stapsgewijze aanpak om een GitHub Copilot-ondersteunde debugassistent te ontwerpen voor jouw Python-webapplicatie, gericht op het detecteren en oplossen van null-referentie fouten en incidentele crashes tijdens API-aanroepen:
1. Integratie en setup:
- Zorg dat je project in een IDE werkt die GitHub Copilot ondersteunt (bijvoorbeeld Visual Studio Code).
- Installeer en activeer GitHub Copilot volgens de officiële instructies.
2. Fouten detecteren met Copilot:
- Gebruik code-annotaties en commentaar om Copilot te begeleiden. Bijvoorbeeld:
# Controleer op null-referenties voor API-aanroepen
- Vraag Copilot om suggesties voor het toevoegen van null-waarde checks vóór API-calls.
- Analyseer runtime logs om crashes te identificeren en markeer deze codegebieden.
3. Fouten oplossen:
- Laat Copilot suggesties geven voor het afhandelen van null-waarden:
# Voeg null-check toe voor variabele api_response
- Vraag bijvoorbeeld: "Hoe kan ik deze API-aanroep robuuster maken tegen null-waarden?"
- Gebruik Copilot om fallback- of foutafhandelingscode te genereren.
4. Oorzaken van bugs begrijpen:
- Voeg commentaren toe die vragen om uitleg:
# Waarom crasht de API-aanroep soms?
- Vraag Copilot om uitleg of mogelijke oorzaken te genereren.
- Bestudeer de gegenereerde suggesties om inzicht te krijgen in de codeflow en potentiële problemen.
5. Debugging en testing:
- Maak testcases met verschillende scenario’s, inclusief randgevallen.
- Vraag Copilot om voorbeeldtests te genereren die null-waarden en andere edge cases simuleren.
6. Automatisering en optimalisatie:
- Integreer static analysis tools (bijv. pylint, mypy) samen met Copilot voor een uitgebreide bugdetectie.
- Gebruik Copilot om documentatie en uitleg te genereren over best practices voor null-afhandeling en API-error handling.
Door deze werkwijze te combineren met Copilot’s code-voorstellen, maak je je debugproces efficiënter en krijg je meer inzicht in de oorzaken van bugs. Vergeet niet om de suggesties kritisch te beoordelen en te testen voordat je ze in productie gebruikt.
provider: deepseek
model: deepseek-chat
Hier is een praktisch ontwerp voor een GitHub Copilot-ondersteunde debugassistent voor je Python webapplicatie:
## Configuratie van Copilot voor Debuggen
### 1. Context-specifieke prompts instellen
```python
# DEBUG CONTEXT - NULL REFERENCE PREVENTIE
# Project: Webapplicatie met API-aanroepen
# Veelvoorkomende fouten: null references, API crashes
# Doel: Defensief programmeren met exception handling
```
### 2. Debug-specifieke code patterns leren
```python
# Copilot training voor API error handling
def safe_api_call(self, url, params=None):
"""
VEILIGE API AANROEP - COPILOT DEBUG PATTERN
Voorkomt crashes door: null references, timeout, network errors
Returns: tuple (success, data, error_message)
"""
try:
response = requests.get(url, params=params, timeout=10)
response.raise_for_status()
# Null-check voor JSON response
if response.text.strip():
data = response.json()
return True, data, None
else:
return False, None, "Lege API response"
except requests.exceptions.Timeout:
return False, None, "API timeout"
except requests.exceptions.ConnectionError:
return False, None, "Netwerkfout"
except ValueError as e: # JSON decode error
return False, None, f"Ongeldig JSON formaat: {str(e)}"
except Exception as e:
return False, None, f"Onverwachte fout: {str(e)}"
```
## Debug Workflow met Copilot
### Foutdetectie Patterns
```python
# COPILOT: Genereer null-check voor object chain
user_data = api_response.get('user', {})
# Copilot suggestie:
if user_data and user_data.get('profile') and user_data['profile'].get('email'):
email = user_data['profile']['email']
else:
email = "default@example.com"
logger.warning("Null reference in user profile chain")
# COPILOT: Valideer API response structuur
def validate_api_structure(response_data):
"""
Valideert API response op vereiste velden
Copilot: genereer validation checks voor nested structuren
"""
required_fields = ['user', 'timestamp', 'data']
for field in required_fields:
if field not in response_data:
raise ValueError(f"Ontbrekend veld: {field}")
# Null-safe nested checking
if response_data.get('user', {}).get('id'):
# Veilig verder verwerken
pass
```
### Automatische Fix Suggesties
Wanneer Copilot een potentiële null reference ziet:
```python
# VOOR (gevaarlijk):
username = api_data['user']['profile']['name']
# COPILOT SUGGESTIE (veilig):
username = api_data.get('user', {}).get('profile', {}).get('name', 'Gast')
```
### Bug Analysis Prompts
```python
# COPILOT DEBUG ANALYSE PROMPT:
"""
ANALYSE POTENTIËLE CRASH:
- Code: {problematic_code_snippet}
- Context: API response verwerking
- Risico's: null references, type errors, missing keys
- Suggest preventieve maatregelen:
1. Defensive programming patterns
2. Uitgebreide logging
3. Fallback values
4. Exception handling
"""
```
## Praktische Implementatie
### 1. Debug Helper Class
```python
class APIDebugAssistant:
def __init__(self):
self.logger = logging.getLogger('api_debug')
@staticmethod
def null_safe_get(data, keys, default=None):
"""
COPILOT-OPTIMALISATIE: Veilige nested dict access
"""
current = data
for key in keys:
if isinstance(current, dict) and key in current:
current = current[key]
else:
return default
return current
def debug_api_flow(self, api_call_func, *args, **kwargs):
"""
COPILOT-GESTANDAARDISEERDE DEBUG FLOW
"""
try:
result = api_call_func(*args, **kwargs)
self.logger.info(f"API call succesvol: {result}")
return result
except Exception as e:
self.logger.error(f"API crash: {str(e)}")
# Copilot: analyse crash pattern en suggereer fix
self.analyze_crash_pattern(e, api_call_func.__name__)
raise
```
### 2. Copilot Training met Common Patterns
```python
# COPILOT TRAINING - COMMON BUG FIXES
# Pattern 1: Null reference in API chains
# VOOR: user['address']['city']
# NA: user.get('address', {}).get('city', 'Onbekend')
# Pattern 2: Missing error handling
# VOOR: response.json()
# NA:
# try:
# data = response.json() if response.text else {}
# except JSONDecodeError:
# data = {}
# Pattern 3: Timeout protection
# VOOR: requests.get(url)
# NA: requests.get(url, timeout=10)
```
## Integratie in Development Workflow
1. **Pre-commit Copilot Check**:
```python
# Copilot: Scan voor common bug patterns
def pre_commit_bug_scan(code_snippet):
risk_patterns = [
"['", # Direct dictionary access
".json()", # Direct JSON parsing
"requests.get(" # Unprotected API calls
]
# Copilot suggereert veilige alternatieven
```
2. **Real-time Debug Suggesties**:
- Gebruik Copilot Chat: "Hoe kan ik null references in deze API call voorkomen?"
- Copilot: genereert defensive code patterns
3. **Post-mortem Analyse**:
```python
# Copilot help bij crash analysis
"""
CRASH ANALYSIS REQUEST:
Fout: NullReferenceError in user data processing
Locatie: models.py regel 45
Context: API response van externe service
Vraag: Welke defensive programming technieken mis ik hier?
"""
```
Deze aanpak transformeert Copilot van een code-assistent naar een proactieve debug-partner die je helpt crashes te voorkomen voordat ze gebeuren.