Fallacies of Distributed Computing

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

/**
 * Example: Bandwidth-optimized API endpoint
 * Demonstrates multiple optimization techniques
 */
 
import { Request, Response } from 'express';
import { compress } from 'compression';
 
interface ListOptions {
    cursor?: string;
    limit?: number;
    fields?: string[];  // Sparse fieldsets
    format?: 'json' | 'protobuf';
}
 
interface PaginatedResponse<T> {
    items: T[];
    nextCursor?: string;
    hasMore: boolean;
}
 
class ProductController {
    // Maximum items per request to bound response size
    private readonly MAX_LIMIT = 50;
    
    // Fields allowed to be requested
    private readonly ALLOWED_FIELDS = new Set([
        'id', 'name', 'price', 'thumbnail', 'category', 
        'rating', 'stock', 'description', 'images'
    ]);
    
    // Default fields for minimal response
    private readonly DEFAULT_FIELDS = ['id', 'name', 'price', 'thumbnail'];
 
    async listProducts(req: Request, res: Response): Promise<void> {
        const options = this.parseOptions(req);
        
        // Check ETag for conditional request
        const etag = await this.calculateETag(options);
        if (req.headers['if-none-match'] === etag) {
            res.status(304).end();  // Not Modified - saves bandwidth!
            return;
        }
        
        // Fetch data with pagination
        const data = await this.fetchProducts(options);
        
        // Project to requested fields only (sparse fieldsets)
        const projected = this.projectFields(data.items, options.fields);
        
        // Set caching headers
        res.set({
            'ETag': etag,
            'Cache-Control': 'public, max-age=60',
            'Vary': 'Accept-Encoding'  // For compression variants
        });
        
        // Response automatically compressed by middleware
        if (options.format === 'protobuf') {
            res.type('application/x-protobuf');
            res.send(this.toProtobuf({ items: projected, ...data }));
        } else {
            res.json({ items: projected, ...data });
        }
    }
 
    private parseOptions(req: Request): ListOptions {
        const requestedFields = req.query.fields as string | undefined;
        const fields = requestedFields
            ? requestedFields.split(',').filter(f => this.ALLOWED_FIELDS.has(f))
            : this.DEFAULT_FIELDS;
            
        return {
            cursor: req.query.cursor as string | undefined,
            limit: Math.min(
                parseInt(req.query.limit as string) || 20,
                this.MAX_LIMIT
            ),
            fields,
            format: req.accepts(['json', 'application/x-protobuf']) === 
                'application/x-protobuf' ? 'protobuf' : 'json'
        };
    }
 
    private projectFields<T extends Record<string, unknown>>(
        items: T[], 
        fields: string[]
    ): Partial<T>[] {
        return items.map(item => {
            const projected: Partial<T> = {};
            for (const field of fields) {
                if (field in item) {
                    projected[field as keyof T] = item[field as keyof T];
                }
            }
            return projected;
        });
    }
 
    // Placeholder implementations
    private async fetchProducts(options: ListOptions): 
        Promise<PaginatedResponse<Record<string, unknown>>> {
        return { items: [], hasMore: false };
    }
    
    private async calculateETag(options: ListOptions): Promise<string> {
        return '"abc123"';
    }
    
    private toProtobuf(data: unknown): Buffer {
        return Buffer.from([]);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/**
 * Example: Bounded buffer with backpressure
 * Producer blocks when buffer is full
 */
 
class BoundedBuffer<T> {
    private buffer: T[] = [];
    private waitingProducers: Array<() => void> = [];
    private waitingConsumers: Array<(item: T) => void> = [];
    
    constructor(private readonly maxSize: number) {}
    
    async put(item: T): Promise<void> {
        // If buffer is full, wait for space
        if (this.buffer.length >= this.maxSize) {
            await new Promise<void>(resolve => {
                this.waitingProducers.push(resolve);
            });
        }
        
        // Check if consumer is waiting
        const waitingConsumer = this.waitingConsumers.shift();
        if (waitingConsumer) {
            // Hand off directly to consumer
            waitingConsumer(item);
        } else {
            // Add to buffer
            this.buffer.push(item);
        }
    }
    
    async take(): Promise<T> {
        // If buffer is empty, wait for item
        if (this.buffer.length === 0) {
            return new Promise<T>(resolve => {
                this.waitingConsumers.push(resolve);
            });
        }
        
        // Get item from buffer
        const item = this.buffer.shift()!;
        
        // Wake up a waiting producer if any
        const waitingProducer = this.waitingProducers.shift();
        if (waitingProducer) {
            waitingProducer();
        }
        
        return item;
    }
    
    get size(): number {
        return this.buffer.length;
    }
}
 
// Usage: Producer-Consumer with backpressure
async function producerConsumerExample() {
    const buffer = new BoundedBuffer<number>(100);
    const processedItems: number[] = [];
    
    // Fast producer (will be slowed by backpressure)
    const producer = async () => {
        for (let i = 0; i < 10000; i++) {
            await buffer.put(i);  // Blocks when buffer full
            console.log(`Produced: ${i}, Buffer size: ${buffer.size}`);
        }
    };
    
    // Slow consumer (processes at its own pace)
    const consumer = async () => {
        for (let i = 0; i < 10000; i++) {
            const item = await buffer.take();
            await simulateProcessing(100);  // 100ms per item
            processedItems.push(item);
            console.log(`Consumed: ${item}`);
        }
    };
    
    await Promise.all([producer(), consumer()]);
}
 
function simulateProcessing(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
}