Requirements

Imagine you're building a collaborative document editing service, similar to Google Docs. A key feature is the ability to track and manage who currently has the document open for viewing or editing. We need to design a system that allows us to efficiently: 1. Add a viewer to a document's active viewers list. 2. Remove a viewer from the document's active viewers list. 3. Retrieve the current list of viewers for a document. This problem focuses on the core domain model and concurrency aspects, rather than the complexities of distributed systems. We will assume an in-memory data structure to manage the viewer lists for each document. # Requirements ## Functional Requirements 1. **Adding Viewers:** * The system must allow adding a viewer to a specific document. * Each viewer should be uniquely identified (e.g., by a user ID). * The system should handle duplicate viewer additions gracefully (e.g., by preventing redundant entries). * Adding a viewer should be an atomic operation with respect to other operations on the same document. * The add operation should return a boolean indicating whether the viewer was newly added (true) or was already present (false). 2. **Removing Viewers:** * The system must allow removing a viewer from a specific document. * The removal operation should handle cases where the viewer is not currently in the list gracefully (e.g., by doing nothing or returning a status indicating that the viewer wasn't found). * The remove operation should return a boolean indicating whether the viewer was successfully removed (true) or not found (false). * The remove operation should be atomic with respect to other operations on the same document. 3. **Listing Viewers:** * The system must provide a way to retrieve a list of all current viewers for a specific document. * The list should be a consistent snapshot of the viewers at the time of the request. * The listing operation should be efficient, even for documents with a large number of viewers. * The order of viewers in the returned list is not a strict requirement. 4. **Document Identification:** * The system must support associating viewers with specific documents, using a document identifier (e.g., a document ID). * The document ID should be used to correctly route viewer add/remove/list operations to the appropriate document's viewer list. 5. **Concurrency:** * Multiple users should be able to add, remove, and list viewers concurrently for different documents. * Multiple users should be able to add, remove, and list viewers concurrently for the *same* document safely and consistently. ## Non-Functional Requirements 1. **Thread Safety:** The core data structures managing viewers must be thread-safe to handle concurrent operations. We should avoid race conditions and ensure data consistency. 2. **Extensibility:** The design should be extensible to support future features, such as: * Different types of viewers (e.g., editors, commenters). * Additional viewer properties (e.g., last active timestamp). * Auditing of viewer changes. 3. **Modularity:** The code should be well-organized and modular, with clear separation of concerns. This will make it easier to maintain, test, and extend. 4. **Testability:** The classes and methods should be designed to be easily testable, using unit tests and integration tests. Mocking dependencies should be straightforward. 5. **Performance:** The add, remove, and list operations should be reasonably performant, even for documents with a large number of viewers. The choice of data structure for storing the viewers will impact performance. We should aim for O(1) or O(log n) complexity for add and remove operations if possible. List operations should be reasonably efficient. Consider potential bottlenecks during concurrent access. 6. **Error Handling:** The system should handle invalid inputs and unexpected errors gracefully, providing informative error messages or exceptions. ## Core Entities 1. **Document:** Represents a document in the system. Contains a unique identifier (documentId) and the associated list of viewers. 2. **Viewer:** Represents a viewer of a document. Contains a unique identifier (viewerId), and potentially other relevant information (e.g., viewer type, last active timestamp). 3. **DocumentViewerManager:** A central component responsible for managing the viewers for all documents. It provides methods to add, remove, and list viewers for a specific document. This class is responsible for thread safety. 4. **ViewerList:** (Potentially an interface). Abstraction for how the list of viewers is stored and managed for each document. This allows flexibility in choosing the underlying data structure and implementing specific concurrency strategies. A concrete implementation could be `ConcurrentHashSetViewerList`.

Design a service to view/add/remove viewers of a document (like the feature in google doc).

Requirements

Interview Simulation

Functional Requirements

💡 Interview Tip

Non-Functional Requirements

Core Entity Identification

Premium Content