State vs Strategy

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

// Strategies are independent algorithms
// They don't know or care about the context's state
 
interface CompressionStrategy {
    compress(data: Buffer): Buffer;
    decompress(data: Buffer): Buffer;
}
 
class GzipStrategy implements CompressionStrategy {
    compress(data: Buffer): Buffer {
        // Pure algorithm - no context needed
        return zlib.gzipSync(data);
    }
    
    decompress(data: Buffer): Buffer {
        return zlib.gunzipSync(data);
    }
}
 
class LzmaStrategy implements CompressionStrategy {
    compress(data: Buffer): Buffer {
        return lzma.compress(data);
    }
    
    decompress(data: Buffer): Buffer {
        return lzma.decompress(data);
    }
}
 
// Strategies are interchangeable—any can replace any
// No transitions, no state machine, no context coupling
class FileArchiver {
    private strategy: CompressionStrategy;
    
    // Client explicitly sets strategy
    setCompressionStrategy(strategy: CompressionStrategy) {
        this.strategy = strategy;
    }
    
    archive(files: File[]): Buffer {
        const combined = this.combineFiles(files);
        return this.strategy.compress(combined);
    }
}

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

// States are deeply coupled to context
// They access context data and trigger transitions
 
interface ConnectionState {
    open(conn: Connection): void;
    send(conn: Connection, data: Buffer): void;
    close(conn: Connection): void;
    receive(conn: Connection, data: Buffer): void;
}
 
class ClosedState implements ConnectionState {
    open(conn: Connection): void {
        // Access context, trigger transition
        conn.initiateHandshake();
        conn.setState(new OpeningState());
    }
    
    send(conn: Connection, data: Buffer): void {
        throw new Error("Cannot send: connection closed");
    }
    
    close(conn: Connection): void {
        // Already closed—no-op or error
    }
    
    receive(conn: Connection, data: Buffer): void {
        // Ignore data in closed state
    }
}
 
class EstablishedState implements ConnectionState {
    open(conn: Connection): void {
        // Already open—no-op
    }
    
    send(conn: Connection, data: Buffer): void {
        conn.writeToSocket(data);
        // May transition to error state on failure
    }
    
    close(conn: Connection): void {
        conn.sendCloseFrame();
        conn.setState(new ClosingState());
    }
    
    receive(conn: Connection, data: Buffer): void {
        conn.enqueueReceivedData(data);
        
        if (isCloseFrame(data)) {
            conn.setState(new ClosingState());
        }
    }
}
 
// States form a constrained graph
// CLOSED → OPENING → ESTABLISHED → CLOSING → CLOSED
// Not all states reachable from all states

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

// Different ways to calculate price - client chooses
interface PricingStrategy {
    calculateTotal(basePrice: number, quantity: number): number;
    getDescription(): string;
}
 
class RegularPricing implements PricingStrategy {
    calculateTotal(basePrice: number, quantity: number): number {
        return basePrice * quantity;
    }
    
    getDescription(): string {
        return "Standard pricing";
    }
}
 
class BulkDiscountPricing implements PricingStrategy {
    calculateTotal(basePrice: number, quantity: number): number {
        const discount = quantity >= 100 ? 0.2 : quantity >= 50 ? 0.1 : 0;
        return basePrice * quantity * (1 - discount);
    }
    
    getDescription(): string {
        return "Bulk discount: 10% off 50+, 20% off 100+";
    }
}
 
class SubscriberPricing implements PricingStrategy {
    private discountRate: number;
    
    constructor(subscriptionTier: string) {
        this.discountRate = tier === "GOLD" ? 0.25 : tier === "SILVER" ? 0.15 : 0.05;
    }
    
    calculateTotal(basePrice: number, quantity: number): number {
        return basePrice * quantity * (1 - this.discountRate);
    }
    
    getDescription(): string {
        return `Subscriber discount: ${this.discountRate * 100}% off`;
    }
}
 
// Usage: Client selects strategy based on customer type
const cart = new ShoppingCart();
 
if (customer.isSubscriber()) {
    cart.setPricingStrategy(new SubscriberPricing(customer.subscriptionTier));
} else if (cart.totalQuantity >= 50) {
    cart.setPricingStrategy(new BulkDiscountPricing());
} else {
    cart.setPricingStrategy(new RegularPricing());
}
 
const total = cart.checkout(); // Uses selected strategy

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

// Document moves through lifecycle states
interface DocumentState {
    edit(doc: Document, content: string): string;
    submit(doc: Document): string;
    approve(doc: Document, approver: User): string;
    reject(doc: Document, reason: string): string;
    publish(doc: Document): string;
}
 
class DraftState implements DocumentState {
    edit(doc: Document, content: string): string {
        doc.setContent(content);
        doc.setLastModified(new Date());
        return "Content updated.";
    }
    
    submit(doc: Document): string {
        if (doc.getContent().length < 100) {
            return "Document too short for review.";
        }
        doc.setState(new PendingReviewState());
        doc.notifyReviewers();
        return "Document submitted for review.";
    }
    
    approve(doc: Document, approver: User): string {
        return "Cannot approve a draft. Submit for review first.";
    }
    
    reject(doc: Document, reason: string): string {
        return "Cannot reject a draft.";
    }
    
    publish(doc: Document): string {
        return "Cannot publish a draft. It must be approved first.";
    }
}
 
class PendingReviewState implements DocumentState {
    edit(doc: Document, content: string): string {
        return "Cannot edit during review. Withdraw and edit in draft.";
    }
    
    submit(doc: Document): string {
        return "Already submitted for review.";
    }
    
    approve(doc: Document, approver: User): string {
        if (!approver.hasApprovalAuthority()) {
            return "You don't have approval authority.";
        }
        doc.setApprover(approver);
        doc.setState(new ApprovedState());
        return "Document approved!";
    }
    
    reject(doc: Document, reason: string): string {
        doc.setRejectionReason(reason);
        doc.setState(new DraftState()); // Back to draft
        doc.notifyAuthor(reason);
        return "Document rejected. Author notified.";
    }
    
    publish(doc: Document): string {
        return "Cannot publish without approval.";
    }
}
 
class ApprovedState implements DocumentState {
    edit(doc: Document, content: string): string {
        return "Cannot edit approved document.";
    }
    
    submit(doc: Document): string {
        return "Already approved.";
    }
    
    approve(doc: Document, approver: User): string {
        return "Already approved.";
    }
    
    reject(doc: Document, reason: string): string {
        return "Cannot reject after approval.";
    }
    
    publish(doc: Document): string {
        doc.setPublishedAt(new Date());
        doc.setState(new PublishedState());
        doc.distributeToSubscribers();
        return "Document published!";
    }
}
 
// States manage their own transitions
// DRAFT → PENDING_REVIEW → APPROVED → PUBLISHED
//          ↓ (reject)
//         DRAFT

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

// WRONG: Using Strategy for lifecycle states
// This is awkward because states need to transition
 
class OrderProcessor {
    private strategy: OrderStrategy;
    
    setStrategy(strategy: OrderStrategy) {
        this.strategy = strategy;
    }
    
    process() {
        this.strategy.process(this);
    }
}
 
// Problem 1: Who changes the strategy?
// With Strategy, the client should... but the client doesn't know 
// when payment completes!
 
// Problem 2: Strategies need context access for transitions
class PendingPaymentStrategy implements OrderStrategy {
    process(processor: OrderProcessor) {
        // Wait for payment...
        if (paymentReceived()) {
            // Awkward! Strategy is changing strategy!
            processor.setStrategy(new ProcessingStrategy());
        }
    }
}
 
// Problem 3: The naming is wrong
// These aren't strategies (alternatives), they're phases (sequence)
// Calling it "strategy" obscures the actual behavior
 
// Problem 4: Testing is confusing
// "Given a PendingPaymentStrategy, when ..."
// No! It's not a strategy, it's a state!

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

// WRONG: Using State for algorithm selection
// This is awkward because algorithms don't transition
 
interface CompressionState {
    compress(ctx: Compressor, data: Buffer): Buffer;
    switchToGzip(ctx: Compressor): void;  // Awkward!
    switchToLzma(ctx: Compressor): void;  // Awkward!
}
 
class GzipState implements CompressionState {
    compress(ctx: Compressor, data: Buffer): Buffer {
        return zlib.gzipSync(data);
    }
    
    // These methods are meaningless!
    // Compression algorithms don't "transition"
    switchToGzip(ctx: Compressor): void {
        // Already gzip... no-op?
    }
    
    switchToLzma(ctx: Compressor): void {
        // Why would gzip "transition" to lzma?
        // This isn't a lifecycle!
        ctx.setState(new LzmaState());
    }
}
 
// Problem 1: No natural transition graph
// Any algorithm can "transition" to any other—there's no constraint
 
// Problem 2: Forced context coupling
// States require context reference, but compression doesn't need it
 
// Problem 3: Lifecycle semantics don't fit
// onEnter/onExit for compression? That doesn't make sense
 
// Problem 4: State machine overhead for simple selection
// All we need is "client picks an algorithm"