Grading Rubric

Total Points: 100 + 10 Bonus

Part 1: Basic RPC Implementation (30 points)

Criterion	Points	Requirements
Protocol Buffer Definition	5	- Correct syntax and structure - All 4 operations defined - Proper message types
Server Implementation	10	- All operations work correctly - Proper return values - Server starts without errors - Handles concurrent requests
Error Handling	5	- Division by zero handled - Appropriate gRPC status codes - Error messages clear and helpful
Client Implementation	5	- Successfully connects to server - Makes RPC calls correctly - Displays results properly
Code Quality	3	- Clean, readable code - Proper naming conventions - Basic documentation
Demo Video	2	- Shows all operations - Includes error cases - Clear narration

Part 2: Failure Handling (35 points)

Criterion	Points	Requirements
Timeout Implementation	8	- Configurable timeout (2s default) - Properly propagated to RPC calls - Logged appropriately
Retry Logic	12	- Exponential backoff implemented - Jitter added (random 0-1s) - Maximum 3 attempts - Each retry logged
Failure Simulation	5	- Server simulates crashes - Server simulates delays - Configurable failure rates
Retry Selectivity	5	- Only retries timeout errors - Does NOT retry invalid input - Proper error categorization
Logging	3	- Clear retry messages - Timestamps included - Easy to follow flow
Demo Video	2	- Shows timeout scenarios - Shows retry succeeding - Shows all retries failing

Part 3: Idempotency (20 points)

Criterion	Points	Requirements
Request ID Generation	4	- Uses UUIDs - Generated before first attempt - Same ID for all retries
Deduplication Logic	8	- Server caches processed requests - Detects duplicates correctly - Returns cached results - Flags duplicates in response
Cache Management	3	- Size limit enforced - TTL implemented - LRU eviction working
Testing	3	- Normal operation tested - Duplicate detection tested - Retry scenario tested - Multiple clients tested
Demo Video	2	- Shows duplicate detection - Shows retry not double-incrementing - Clear explanation

Part 4: Circuit Breaker (15 points)

Criterion	Points	Requirements
State Transitions	5	- CLOSED → OPEN working - OPEN → HALF_OPEN working - HALF_OPEN → CLOSED working - Proper state logging
Failure Detection	3	- Tracks consecutive failures - Opens after threshold (3 failures) - Resets counter on success
Recovery Testing	3	- Half-open after timeout (5s) - Tests recovery with single request - Reopens if test fails
Thread Safety	2	- Uses locks properly - No race conditions - Safe for concurrent access
Demo Video	2	- Shows all state transitions - Shows fast-fail behavior - Shows recovery

Bonus: RPC vs REST (+10 points)

Criterion	Points	Requirements
REST Implementation	3	- Working REST API - Same operations as gRPC - Proper HTTP methods
Benchmark Script	3	- Measures latency correctly - Measures throughput - Fair comparison methodology
Performance Data	2	- Valid measurements - Multiple iterations - Statistical analysis
Analysis Report	2	- Insightful comparison - Trade-offs discussed - Use case recommendations

Code Quality (Throughout)

Code quality is assessed across all parts:

Excellent (90-100%)

Clean, well-organized code
Comprehensive docstrings
Type hints throughout
Proper error handling
Follows PEP 8
Easy to understand

Good (75-89%)

Generally clean code
Some documentation
Basic error handling
Mostly readable
Minor style issues

Acceptable (60-74%)

Works but messy
Minimal documentation
Basic error handling
Harder to follow
Style inconsistencies

Poor (<60%)

Difficult to read
No documentation
Poor error handling
Doesn't follow conventions
Hard to understand

Report Quality (Throughout)

The written report is assessed on:

Content (60%)

Correctness: Answers are accurate and demonstrate understanding
Depth: Shows deep thinking, not just surface-level answers
Analysis: Provides insights, not just descriptions
Examples: Uses concrete examples from implementation

Presentation (40%)

Clarity: Easy to read and understand
Organization: Logical structure and flow
Formatting: Professional appearance, proper citations
Writing: Grammar, spelling, punctuation

Demo Videos (Throughout)

Videos are assessed on:

Content (70%)

Completeness: Shows all required scenarios
Correctness: Demonstrates features working properly
Clarity: Easy to follow what's happening

Production (30%)

Audio: Clear narration, good microphone quality
Visual: Screen is readable, good resolution
Length: Within suggested time limits
Pacing: Not too fast or too slow

Deductions

Common reasons for point deductions:

Issue	Deduction
Code doesn't run	-20 to -50 points
Modified proto file	-10 to -20 points
Missing required component	-5 to -15 points
Plagiarism detected	0 points + academic integrity violation
Late submission (per policy)	Variable
Missing test cases	-2 to -5 points
Poor code quality	-3 to -10 points
Incomplete documentation	-2 to -5 points
Video issues (broken links, etc.)	-2 to -5 points

Grade Scale

Points	Grade	Description
95-110	A+	Outstanding work, bonus completed
90-94	A	Excellent work, all requirements exceeded
85-89	A-	Very good work, most requirements exceeded
80-84	B+	Good work, all requirements met well
75-79	B	Solid work, all requirements met
70-74	B-	Acceptable work, most requirements met
65-69	C+	Passing, some requirements not fully met
60-64	C	Minimum passing
<60	F	Does not meet minimum requirements

Self-Assessment Checklist

Before submitting, rate yourself honestly:

Part 1

[ ] All operations work without errors
[ ] Error handling is comprehensive
[ ] Code is clean and documented
[ ] Demo shows all features

Part 2

[ ] Timeouts work correctly
[ ] Retry logic includes exponential backoff and jitter
[ ] Only appropriate errors are retried
[ ] Demo shows various failure scenarios

Part 3

[ ] Request IDs generated correctly
[ ] Duplicate requests are detected
[ ] Counter only increments once despite retries
[ ] Demo clearly shows idempotency

Part 4

[ ] Circuit breaker transitions between states
[ ] Fast-fail behavior works
[ ] Recovery testing works
[ ] Demo shows complete state cycle

Overall

[ ] All code runs without errors
[ ] All videos are accessible
[ ] Report answers all questions thoroughly
[ ] Submission is complete and organized

Feedback Categories

You will receive feedback in these areas:

Technical Implementation

Correctness of core functionality
Error handling robustness
Code efficiency and design

Understanding

Depth of concept understanding
Quality of analysis in report
Ability to explain trade-offs

Presentation

Code readability and organization
Documentation quality
Video clarity and completeness

Professionalism

Meeting deadlines
Following submission requirements
Overall quality and polish

Example Grade Breakdown

Student A (Total: 95/100)

Part	Earned	Possible	Notes
Part 1	28	30	Missing some docstrings (-2)
Part 2	33	35	Jitter implementation unclear (-2)
Part 3	19	20	Cache TTL not tested (-1)
Part 4	15	15	Perfect implementation
Total	95	100	Excellent work overall

Student B (Total: 82/100)

Part	Earned	Possible	Notes
Part 1	26	30	Error handling basic (-4)
Part 2	30	35	No jitter in backoff (-3), logging sparse (-2)
Part 3	16	20	No cache size limit (-2), testing incomplete (-2)
Part 4	10	15	Half-open state buggy (-3), no thread safety (-2)
Total	82	100	Good work, room for improvement

Getting Full Credit

To maximize your grade:

Start early - Don't leave everything to the last minute
Test thoroughly - Make sure everything works before submitting
Document well - Explain your design decisions
Ask questions - Use office hours if confused
Watch requirements - Follow submission guidelines exactly
Proofread - Check for typos and errors
Test submission - Verify all links work and files are included

Questions About Grading?

Review detailed part rubrics in each Part's documentation
Attend office hours for clarification
Email instructor/TA with specific questions