# Debug Round-Robin and Consistent-Hash Routing You are given two load-balancer implementations that produce incorrect routing: one uses round robin and the other uses consistent hashing. Describe how you would debug each implementation, state the invariants it must satisfy, and design tests that separate algorithm defects from simple implementation mistakes. For round robin, cover membership changes and index updates. For consistent hashing, cover ring construction, wraparound lookup, virtual nodes, and adding or removing a server. You do not need to guess one hidden typo; present a repeatable debugging method that would expose it. ### Constraints & Assumptions - The backend set may change while requests are being routed. - The same hash function and byte encoding must be used consistently for server tokens and request keys. - Tests must not depend on a particular language's unordered-map iteration order. ### Clarifying Questions to Ask - Are membership updates concurrent with routing calls? - Does round robin need equal request counts or weighted capacity? - How much key movement is acceptable when a server joins or leaves the hash ring? ```hint Write invariants before tracing code For round robin the chosen index must always be valid; for a hash ring lookup must choose the first token clockwise and wrap to the first token when needed. ``` ```hint Reduce the failing state Use two or three named servers and fixed hash outputs so every expected route can be reasoned about by hand. ``` ### What a Strong Answer Covers - Minimal deterministic reproductions and inspection of state transitions. - Round-robin modulo, empty-set, removal, and concurrency edge cases. - Sorted-ring construction, successor lookup, wraparound, collisions, and virtual-node ownership. - Property-based or table-driven tests for distribution and limited remapping. - Complexity for routing and membership changes in both algorithms. ### Follow-up Questions - How would you update membership without exposing a partially rebuilt router to readers? - What test distinguishes consistent hashing from simple modulo hashing during a node addition? - How would weighted backends change each algorithm?