Revolutionize strategies with interview and system design: Results

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "os"
    "strings"
)

// RubricCriterion defines a single evaluation metric for system design interviews
// Weight is a value between 0.0 and 1.0, summing to 1.0 across all criteria
type RubricCriterion struct {
    ID          string  `json:"id"`
    Name        string  `json:"name"`
    Weight      float64 `json:"weight"`
    PassThreshold float64 `json:"pass_threshold"` // Minimum score (0-10) to pass this criterion
}

// InterviewResponse holds the candidate's system design submission
type InterviewResponse struct {
    CandidateID string `json:"candidate_id"`
    ScenarioID  string `json:"scenario_id"`
    // DiagramURL links to the candidate's architecture diagram, stored in S3/GCS
    DiagramURL  string                 `json:"diagram_url"`
    // TradeoffNotes captures explicit tradeoff discussions from the candidate
    TradeoffNotes map[string]string    `json:"tradeoff_notes"`
    // ComponentScores maps criterion ID to 0-10 score assigned by reviewer
    ComponentScores map[string]float64 `json:"component_scores"`
}

// Evaluator validates and scores system design interview responses
type Evaluator struct {
    rubric []RubricCriterion
    // strictMode rejects responses with any criterion below pass threshold
    strictMode bool
}

// NewEvaluator initializes an evaluator with a predefined rubric
// Rubric weights must sum to 1.0, else returns an error
func NewEvaluator(rubric []RubricCriterion, strictMode bool) (*Evaluator, error) {
    var totalWeight float64
    for _, c := range rubric {
        if c.Weight < 0 || c.Weight > 1 {
            return nil, fmt.Errorf("criterion %s has invalid weight %f: must be 0-1", c.ID, c.Weight)
        }
        if c.PassThreshold < 0 || c.PassThreshold > 10 {
            return nil, fmt.Errorf("criterion %s has invalid pass threshold %f: must be 0-10", c.ID, c.PassThreshold)
        }
        totalWeight += c.Weight
    }
    // Allow for floating point rounding errors up to 0.001
    if totalWeight < 0.999 || totalWeight > 1.001 {
        return nil, fmt.Errorf("total rubric weight is %f: must sum to 1.0", totalWeight)
    }
    return &Evaluator{
        rubric:     rubric,
        strictMode: strictMode,
    }, nil
}

// Evaluate scores a candidate's response against the rubric
// Returns total weighted score (0-10) and a list of failed criteria
func (e *Evaluator) Evaluate(resp InterviewResponse) (float64, []string, error) {
    // Validate response has scores for all rubric criteria
    criterionIDs := make(map[string]bool)
    for _, c := range e.rubric {
        criterionIDs[c.ID] = true
    }
    for id := range resp.ComponentScores {
        if !criterionIDs[id] {
            return 0, nil, fmt.Errorf("response includes score for unknown criterion %s", id)
        }
    }
    var totalScore float64
    var failedCriteria []string

    for _, criterion := range e.rubric {
        score, exists := resp.ComponentScores[criterion.ID]
        if !exists {
            return 0, nil, fmt.Errorf("response missing score for criterion %s (%s)", criterion.ID, criterion.Name)
        }
        if score < 0 || score > 10 {
            return 0, nil, fmt.Errorf("criterion %s has invalid score %f: must be 0-10", criterion.ID, score)
        }
        weightedScore := score * criterion.Weight
        totalScore += weightedScore

        if score < criterion.PassThreshold {
            failedCriteria = append(failedCriteria, fmt.Sprintf("%s: scored %f (threshold %f)", criterion.Name, score, criterion.PassThreshold))
        }
    }

    // Strict mode: auto-fail if any criterion is below threshold
    if e.strictMode && len(failedCriteria) > 0 {
        return totalScore, failedCriteria, errors.New("strict mode: response failed one or more criteria")
    }

    return totalScore, failedCriteria, nil
}

func main() {
    // Example rubric for a distributed cache system design question
    rubric := []RubricCriterion{
        {ID: "scalability", Name: "Horizontal Scalability", Weight: 0.3, PassThreshold: 7.0},
        {ID: "consistency", Name: "Data Consistency Model", Weight: 0.25, PassThreshold: 6.0},
        {ID: "fault_tolerance", Name: "Fault Tolerance & Recovery", Weight: 0.25, PassThreshold: 6.0},
        {ID: "tradeoffs", Name: "Explicit Tradeoff Discussion", Weight: 0.2, PassThreshold: 8.0},
    }

    evaluator, err := NewEvaluator(rubric, false)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Failed to initialize evaluator: %v\n", err)
        os.Exit(1)
    }

    // Example candidate response
    candidateResp := InterviewResponse{
        CandidateID: "cand_1234",
        ScenarioID:  "dist_cache_v1",
        DiagramURL:  "https://s3.amazonaws.com/interview-diagrams/cand_1234_dist_cache.png",
        TradeoffNotes: map[string]string{
            "consistency": "Chose eventual consistency over strong to reduce write latency by 40ms",
            "scalability": "Used consistent hashing to avoid full cache rebuild on node addition",
        },
        ComponentScores: map[string]float64{
            "scalability":    8.5,
            "consistency":    7.0,
            "fault_tolerance": 6.5,
            "tradeoffs":      9.0,
        },
    }

    score, failed, err := evaluator.Evaluate(candidateResp)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Evaluation error: %v\n", err)
    }
    fmt.Printf("Candidate %s total score: %.2f/10\n", candidateResp.CandidateID, score)
    if len(failed) > 0 {
        fmt.Println("Failed criteria:")
        for _, f := range failed {
            fmt.Printf("- %s\n", f)
        }
    }
}

import csv
import json
import os
from dataclasses import dataclass
from typing import List, Tuple
import statistics

try:
    import matplotlib.pyplot as plt
    MATPLOTLIB_AVAILABLE = True
except ImportError:
    MATPLOTLIB_AVAILABLE = False

# Data class to store interview strategy configuration
@dataclass
class InterviewStrategy:
    name: str
    # Type of interview: "whiteboard_algo", "paired_system_design", "scenario_based"
    interview_type: str
    # Average hours spent per candidate
    time_per_candidate: float
    # Cost per candidate in USD
    cost_per_candidate: float
    # Percentage of candidates who pass the interview
    pass_rate: float

# Data class to store team performance metrics post-hire
@dataclass
class TeamPerformance:
    strategy_name: str
    team_id: str
    # Months since team formation
    months_active: int
    # Number of senior engineers on team
    senior_count: int
    # p99 latency of primary service in ms
    p99_latency_ms: float
    # Cloud spend per month in USD
    monthly_cloud_spend: float
    # Number of architectural rewrites in first 12 months
    arch_rewrites: int

def load_strategy_data(filepath: str) -> List[InterviewStrategy]:
    """Load interview strategy configurations from a JSON file"""
    if not os.path.exists(filepath):
        raise FileNotFoundError(f"Strategy data file not found at {filepath}")
    try:
        with open(filepath, 'r') as f:
            raw_data = json.load(f)
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in strategy file: {e}")

    strategies = []
    for item in raw_data:
        required_fields = ["name", "interview_type", "time_per_candidate", "cost_per_candidate", "pass_rate"]
        for field in required_fields:
            if field not in item:
                raise KeyError(f"Missing required field {field} in strategy data")
        strategies.append(InterviewStrategy(**item))
    return strategies

def load_performance_data(filepath: str) -> List[TeamPerformance]:
    """Load team performance data from CSV"""
    if not os.path.exists(filepath):
        raise FileNotFoundError(f"Performance data file not found at {filepath}")
    performances = []
    try:
        with open(filepath, 'r') as f:
            reader = csv.DictReader(f)
            required_cols = ["strategy_name", "team_id", "months_active", "senior_count", "p99_latency_ms", "monthly_cloud_spend", "arch_rewrites"]
            if not reader.fieldnames:
                raise ValueError("Empty CSV file")
            for col in required_cols:
                if col not in reader.fieldnames:
                    raise KeyError(f"Missing required column {col} in performance data")
            for row in reader:
                performances.append(TeamPerformance(
                    strategy_name=row["strategy_name"],
                    team_id=row["team_id"],
                    months_active=int(row["months_active"]),
                    senior_count=int(row["senior_count"]),
                    p99_latency_ms=float(row["p99_latency_ms"]),
                    monthly_cloud_spend=float(row["monthly_cloud_spend"]),
                    arch_rewrites=int(row["arch_rewrites"])
                ))
    except Exception as e:
        raise ValueError(f"Failed to read performance CSV: {e}")
    return performances

def calculate_roi(strategies: List[InterviewStrategy], performances: List[TeamPerformance]) -> dict:
    """
    Calculate ROI for each interview strategy:
    Returns dict mapping strategy name to (cost_saved_per_month, latency_improvement_pct, rewrite_reduction_pct)
    """
    # Group performances by strategy
    strategy_perf = {}
    for perf in performances:
        if perf.strategy_name not in strategy_perf:
            strategy_perf[perf.strategy_name] = []
        strategy_perf[perf.strategy_name].append(perf)

    # Get baseline strategy (whiteboard algo) metrics
    baseline_strategy = next(s for s in strategies if s.interview_type == "whiteboard_algo")
    baseline_perf = strategy_perf[baseline_strategy.name]
    baseline_avg_latency = statistics.mean([p.p99_latency_ms for p in baseline_perf])
    baseline_avg_spend = statistics.mean([p.monthly_cloud_spend for p in baseline_perf])
    baseline_avg_rewrites = statistics.mean([p.arch_rewrites for p in baseline_perf])

    roi_results = {}
    for strategy in strategies:
        if strategy.name not in strategy_perf:
            continue
        perf_list = strategy_perf[strategy.name]
        avg_latency = statistics.mean([p.p99_latency_ms for p in perf_list])
        avg_spend = statistics.mean([p.monthly_cloud_spend for p in perf_list])
        avg_rewrites = statistics.mean([p.arch_rewrites for p in perf_list])

        # Calculate cost saved vs baseline (lower spend is better)
        cost_saved = baseline_avg_spend - avg_spend
        # Calculate latency improvement (lower is better)
        latency_improvement = ((baseline_avg_latency - avg_latency) / baseline_avg_latency) * 100
        # Rewrite reduction
        rewrite_reduction = ((baseline_avg_rewrites - avg_rewrites) / baseline_avg_rewrites) * 100

        roi_results[strategy.name] = (cost_saved, latency_improvement, rewrite_reduction)

    return roi_results

def main():
    try:
        # Load sample data (in production, these would be S3/GCS paths)
        strategies = load_strategy_data("interview_strategies.json")
        performances = load_performance_data("team_performance.csv")
    except Exception as e:
        print(f"Failed to load data: {e}")
        return

    roi = calculate_roi(strategies, performances)

    print("Interview Strategy ROI (vs Whiteboard Algo Baseline):")
    print("-" * 60)
    for strategy_name, (cost_saved, lat_improve, rewrite_red) in roi.items():
        print(f"Strategy: {strategy_name}")
        print(f"  Monthly cloud cost saved: ${cost_saved:.2f}")
        print(f"  p99 latency improvement: {lat_improve:.1f}%")
        print(f"  Architectural rewrite reduction: {rewrite_red:.1f}%")
        print()

    # Generate comparison plot if matplotlib is available
    if MATPLOTLIB_AVAILABLE:
        strategy_names = list(roi.keys())
        cost_saved = [v[0] for v in roi.values()]
        lat_improve = [v[1] for v in roi.values()]

        fig, ax1 = plt.subplots(figsize=(10, 6))
        ax1.bar(strategy_names, cost_saved, color='skyblue', label='Monthly Cost Saved ($)')
        ax1.set_xlabel('Interview Strategy')
        ax1.set_ylabel('Monthly Cost Saved ($)', color='skyblue')
        ax1.tick_params(axis='y', labelcolor='skyblue')

        ax2 = ax1.twinx()
        ax2.plot(strategy_names, lat_improve, color='coral', marker='o', label='Latency Improvement (%)')
        ax2.set_ylabel('Latency Improvement (%)', color='coral')
        ax2.tick_params(axis='y', labelcolor='coral')

        plt.title('Interview Strategy Performance vs Baseline')
        fig.tight_layout()
        plt.savefig('strategy_roi.png')
        print("Saved ROI plot to strategy_roi.png")
    else:
        print("Matplotlib not installed, skipping plot generation")

if __name__ == "__main__":
    main()

import { EventEmitter } from 'events';
import { createServer, IncomingMessage, ServerResponse } from 'http';
import { URL } from 'url';

// Configuration for the rate limiter system design simulation
interface RateLimiterConfig {
    // Maximum requests per window
    maxRequests: number;
    // Window size in milliseconds
    windowMs: number;
    // Strategy: "fixed_window", "sliding_window", "token_bucket"
    strategy: string;
    // Number of nodes in the distributed cluster
    clusterNodes: number;
}

// Simulated request object for testing
interface SimulatedRequest {
    ip: string;
    timestamp: number;
    path: string;
}

// Metrics collected during simulation
interface SimulationMetrics {
    totalRequests: number;
    allowedRequests: number;
    blockedRequests: number;
    // Average latency added by rate limiter in ms
    avgLatencyMs: number;
    // Percentage of requests that had consistency issues across nodes
    consistencyErrorPct: number;
}

// DistributedRateLimiter simulates a cluster of rate limiter nodes
class DistributedRateLimiter extends EventEmitter {
    private config: RateLimiterConfig;
    // In-memory store: maps node ID to request counts per IP
    private nodeStores: Map>;
    private nodes: string[];
    private metrics: SimulationMetrics;

    constructor(config: RateLimiterConfig) {
        super();
        this.config = config;
        this.nodes = Array.from({ length: config.clusterNodes }, (_, i) => `node-${i}`);
        this.nodeStores = new Map();
        this.nodes.forEach(node => {
            this.nodeStores.set(node, new Map());
        });
        this.metrics = {
            totalRequests: 0,
            allowedRequests: 0,
            blockedRequests: 0,
            avgLatencyMs: 0,
            consistencyErrorPct: 0
        };
    }

    // Simulate a request to a random node in the cluster
    async handleRequest(req: SimulatedRequest): Promise {
        const startTime = Date.now();
        this.metrics.totalRequests++;
        // Pick a random node to handle the request (simulates load balancer)
        const targetNode = this.nodes[Math.floor(Math.random() * this.nodes.length)];
        const nodeStore = this.nodeStores.get(targetNode)!;
        const now = req.timestamp;

        let allowed = false;
        try {
            switch (this.config.strategy) {
                case 'fixed_window':
                    allowed = this.handleFixedWindow(nodeStore, req.ip, now);
                    break;
                case 'sliding_window':
                    allowed = this.handleSlidingWindow(nodeStore, req.ip, now);
                    break;
                case 'token_bucket':
                    allowed = this.handleTokenBucket(nodeStore, req.ip, now);
                    break;
                default:
                    throw new Error(`Unsupported rate limiter strategy: ${this.config.strategy}`);
            }

            if (allowed) {
                this.metrics.allowedRequests++;
            } else {
                this.metrics.blockedRequests++;
            }
        } catch (err) {
            this.emit('error', err);
            allowed = false;
            this.metrics.blockedRequests++;
        }

        // Simulate network latency between nodes (1-5ms)
        const latency = Math.random() * 4 + 1;
        this.metrics.avgLatencyMs = (this.metrics.avgLatencyMs * (this.metrics.totalRequests - 1) + latency) / this.metrics.totalRequests;

        // Simulate consistency check: 5% chance of cross-node sync error
        if (Math.random() < 0.05) {
            this.metrics.consistencyErrorPct = (this.metrics.consistencyErrorPct * (this.metrics.totalRequests - 1) + 100) / this.metrics.totalRequests;
        } else {
            this.metrics.consistencyErrorPct = (this.metrics.consistencyErrorPct * (this.metrics.totalRequests - 1)) / this.metrics.totalRequests;
        }

        const endTime = Date.now();
        this.emit('requestProcessed', {
            ip: req.ip,
            allowed,
            node: targetNode,
            processingTimeMs: endTime - startTime
        });

        return allowed;
    }

    private handleFixedWindow(store: Map, ip: string, now: number): boolean {
        const record = store.get(ip);
        if (!record || now > record.resetTime) {
            // Reset window
            store.set(ip, { count: 1, resetTime: now + this.config.windowMs });
            return true;
        }
        if (record.count >= this.config.maxRequests) {
            return false;
        }
        record.count++;
        return true;
    }

    private handleSlidingWindow(store: Map, ip: string, now: number): boolean {
        // Simplified sliding window: resets count if window has passed
        // In real implementation, this would track individual request timestamps
        return this.handleFixedWindow(store, ip, now);
    }

    private handleTokenBucket(store: Map, ip: string, now: number): boolean {
        // Simplified token bucket: refills tokens at 1 per 100ms
        const record = store.get(ip);
        const refillRate = this.config.windowMs / this.config.maxRequests; // ms per token
        if (!record) {
            store.set(ip, { count: this.config.maxRequests - 1, resetTime: now + refillRate });
            return true;
        }
        if (now > record.resetTime) {
            // Refill tokens
            const tokensToAdd = Math.floor((now - record.resetTime) / refillRate);
            record.count = Math.min(this.config.maxRequests, record.count + tokensToAdd);
            record.resetTime = now;
        }
        if (record.count <= 0) {
            return false;
        }
        record.count--;
        return true;
    }

    getMetrics(): SimulationMetrics {
        return { ...this.metrics };
    }
}

// Simulate an HTTP server using the rate limiter
async function startSimulation() {
    const config: RateLimiterConfig = {
        maxRequests: 100,
        windowMs: 60 * 1000, // 1 minute
        strategy: 'token_bucket',
        clusterNodes: 3
    };

    const rateLimiter = new DistributedRateLimiter(config);
    rateLimiter.on('error', (err) => console.error('Rate limiter error:', err));
    rateLimiter.on('requestProcessed', (data) => {
        if (Math.random() < 0.01) { // Log 1% of requests
            console.log(`Request from ${data.ip}: ${data.allowed ? 'ALLOWED' : 'BLOCKED'} (node ${data.node})`);
        }
    });

    // Simulate 1000 requests over 1 minute
    const totalRequests = 1000;
    const requests: SimulatedRequest[] = [];
    for (let i = 0; i < totalRequests; i++) {
        const ip = `192.168.1.${Math.floor(Math.random() * 10)}`; // 10 unique IPs
        const timestamp = Date.now() + i * 60; // Spread over 60 seconds
        requests.push({ ip, timestamp, path: '/api/test' });
    }

    console.log(`Starting simulation: ${totalRequests} requests, ${config.clusterNodes} nodes, ${config.strategy} strategy`);
    for (const req of requests) {
        await rateLimiter.handleRequest(req);
    }

    const metrics = rateLimiter.getMetrics();
    console.log('\nSimulation Results:');
    console.log(`Total requests: ${metrics.totalRequests}`);
    console.log(`Allowed: ${metrics.allowedRequests} (${(metrics.allowedRequests / metrics.totalRequests * 100).toFixed(1)}%)`);
    console.log(`Blocked: ${metrics.blockedRequests} (${(metrics.blockedRequests / metrics.totalRequests * 100).toFixed(1)}%)`);
    console.log(`Average latency: ${metrics.avgLatencyMs.toFixed(2)}ms`);
    console.log(`Consistency error rate: ${metrics.consistencyErrorPct.toFixed(2)}%`);
}

startSimulation().catch(console.error);

// Example rubric for paired checkout system design session
[]RubricCriterion{
    {ID: "scalability", Name: "Handles 50k RPM", Weight: 0.3, PassThreshold: 7.0},
    {ID: "tradeoffs", Name: "Explicitly discusses Redis vs DynamoDB", Weight: 0.25, PassThreshold: 6.0},
    {ID: "fault_tolerance", Name: "Handles Redis node failure", Weight: 0.25, PassThreshold: 6.0},
    {ID: "communication", Name: "Updates diagram based on feedback", Weight: 0.2, PassThreshold: 8.0},
}

# Sample Async Deliverable Prompt
## Scenario: Distributed Product Catalog Cache
- 1M daily active users, 10k RPM peak
- Data set: 500k products, 2KB per product
- SLA: 99.9% availability, p99 read latency <50ms
## Deliverables
1. Mermaid architecture diagram (commit to repo)
2. 500-word tradeoff analysis (Redis vs Memcached vs CDN)
3. 200-word failure mode analysis (what happens if cache cluster fails)
## Evaluation Rubric
See [interview-evaluator rubric v2.1](https://github.com/yourusername/interview-evaluator/blob/main/rubric_v2.1.json)

# Prometheus query to correlate interview scores with p99 latency
# interview_score: 0-10 score from system design interview
# p99_latency_ms: p99 latency of engineer's primary service
interview_score_p99_correlation = corr(
    interview_score{team="checkout"},
    p99_latency_ms{team="checkout"}
)
# Ideal correlation is negative: higher interview scores = lower latency