협업 편집기와 화이트보드

Imagine multiple people editing the same document or drawing on a whiteboard simultaneously. How do their changes appear instantly to everyone else?

This lesson explores the architectural patterns and challenges behind building such multi-user, real-time collaborative applications using WebSockets.

The core problem in collaborative systems is state synchronization. If two users edit the same part of a document at the same time, whose change takes precedence?

• User A types 'Hello'.
• User B types 'Hi'.
• How do we merge these without losing data or creating inconsistencies?

Traditional request-response models aren't suitable for this constant, bidirectional flow of updates.

One powerful technique to handle concurrent edits is Operational Transformation (OT). It's used in tools like Google Docs.

OT doesn't prevent conflicts; it resolves them by transforming operations. When an operation (e.g., 'insert character at position X') arrives at the server, it might be modified before being applied to ensure consistency with other operations that have already been applied.

Think of it like this:

• User A types 'A' at index 0.
• User B types 'B' at index 0.

If B's operation arrives first, the document is 'B'. When A's operation arrives, OT transforms it to 'insert A at index 1' instead of 0, resulting in 'BA'. This preserves both changes correctly.

OT systems are complex, often requiring a central server to coordinate transformations.

An alternative to OT is Conflict-Free Replicated Data Types (CRDTs). These are data structures designed to be mergeable.

CRDTs ensure that concurrent modifications, when applied in any order on different replicas, will always converge to the same state without requiring complex transformation logic.

Examples include shared counters, sets, and text editors based on CRDTs.

• OT: Centralized (server-coordinated), complex transformation logic, strong consistency guarantee.
• CRDTs: Decentralized merging, simpler logic for merging, eventual consistency, resilient to network partitions.

Choosing between them depends on your application's specific needs, such as consistency requirements and tolerance for network issues.

A typical architecture for collaborative apps involves:

1. Clients: Each user's browser or device.
2. WebSocket Server: A central hub for all client connections.
3. Document State: The canonical version of the shared document, managed by the server.

Clients send their operations to the server, which then processes and broadcasts them.

The WebSocket server is the brain of the operation. When a client sends an 'operation' (e.g., 'insert character', 'move object'), the server:

• Receives the operation.
• Applies OT/CRDT logic to integrate it with the current document state.
• Updates the authoritative document.
• Broadcasts the (possibly transformed) operation to all other connected clients.

This ensures all clients eventually see the same, consistent state.

On the client side, when a user performs an action (e.g., types a character, drags an element):

• The client generates an 'operation' object describing the action.
• This operation is sent to the WebSocket server.
• When the client receives an operation from the server, it applies it to its local representation of the document, updating the UI.

Clients often apply changes locally immediately for responsiveness, then reconcile with server updates.

Let's say two users, A and B, are editing a text field initially showing 'Hello'.

• User A types '!' at the end. Client A sends {type: 'insert', pos: 5, char: '!'} to server.
• User B types ' World' after 'Hello'. Client B sends {type: 'insert', pos: 5, text: ' World'} to server.

The server's OT/CRDT logic processes these. If B's arrives first, A's operation might be transformed to insert '!' at position 11 (after 'Hello World'). Both clients then receive and apply the final, consistent operations.

We've explored how WebSockets power complex multi-user applications like collaborative editors and whiteboards.

• The main challenge is state synchronization.
• Operational Transformation (OT) resolves conflicts by transforming operations, often server-side.
• Conflict-Free Replicated Data Types (CRDTs) allow decentralized, mergeable updates for eventual consistency.
• The architecture involves clients sending operations to a WebSocket server, which processes and broadcasts updates.

Understanding these patterns is key to building responsive and robust collaborative experiences!