Requirements

Let's design a navigation and alerts system akin to Google Maps, but focusing on the core LLD aspects. Forget the massive scale and distributed nature; we're building an in-memory simulation to showcase excellent design. Imagine you're building a system for a car's navigation unit. The system needs to: 1. Calculate routes between two points. 2. Provide turn-by-turn directions. 3. Alert the driver about upcoming events (traffic jams, accidents, speed cameras, etc.) along the route. 4. Dynamically re-route based on real-time events. This problem requires a strong understanding of OOD principles and design patterns to create a flexible, maintainable, and testable system. The heart of the challenge lies in the efficient and scalable (within memory constraints) route management and alert triggering mechanisms. # Requirements ## Functional Requirements 1. **Route Calculation:** * Given a start and end location (latitude and longitude), calculate a route. * Support different routing modes: Fastest, Shortest. * Return a route represented as a list of `NavigationPoints`. * Consider road restrictions (one-way streets, blocked roads - simulated). 2. **Turn-by-Turn Directions:** * Provide human-readable directions for each `NavigationPoint` along the route. * Directions should include distance to the next turn, type of turn (left, right, straight), and street name. 3. **Alerting:** * Register various types of alerts (TrafficJam, Accident, SpeedCamera) along specific road segments. * As the user progresses along the route, trigger alerts relevant to their current location. * Alerts should provide relevant information (severity of traffic jam, type of accident, speed limit). * Alerts should have a priority (e.g., Accident > Speed Camera). 4. **Re-routing:** * When an alert (e.g., traffic jam) significantly impacts the route, automatically calculate a new route. * The re-routing algorithm should consider the severity and duration of the alert. * Allow the user to accept or reject the re-route. 5. **Data Input:** * Provide a way to input map data (roads, intersections, points of interest). This can be simplified by loading from a file at startup. * Provide a way to add/remove alerts dynamically (e.g., through an API). ## Non-Functional Requirements 1. **Modularity:** The system should be composed of loosely coupled modules with well-defined interfaces. This allows for easy modification and extension of individual components without affecting the entire system. 2. **Extensibility:** The system should be designed to easily accommodate new types of alerts, routing modes, and map data sources. 3. **Testability:** Each module should be easily testable in isolation. Unit tests should cover all critical functionalities. 4. **Thread Safety:** The system may need to handle concurrent requests (e.g., multiple users requesting routes). Ensure that shared data structures are accessed and modified in a thread-safe manner. Pay close attention to potential race conditions and deadlocks. Focus on the data structures that store the routes, alerts, and map data. Consider thread-safe collections, locks, or atomic operations as appropriate. The route calculation itself may be multi-threaded to improve performance. 5. **Maintainability:** The code should be well-documented, and easy to understand and maintain. Use meaningful variable names, comments, and consistent coding style. 6. **Performance:** Route calculation should be reasonably fast (within a few seconds for typical routes). Alert triggering should be instantaneous. ## Core Entities 1. **`NavigationPoint`:** Represents a point on the route (latitude, longitude). 2. **`Route`:** Represents a sequence of `NavigationPoints`. Includes methods for calculating distance, getting directions, and checking for alerts. 3. **`Router`:** Interface responsible for calculating routes. Implementations include `FastestRoute` and `ShortestRoute`. 4. **`Alert`:** Base class for different types of alerts (TrafficJam, Accident, SpeedCamera). Includes properties like location, severity, and message. 5. **`AlertManager`:** Responsible for managing alerts and triggering them when the user is near an alert location. 6. **`MapData`:** Represents the underlying map data (roads, intersections). Could be loaded from a file or a database. This class must be thread-safe. 7. **`DirectionService`:** Responsible for converting `NavigationPoint`s into human-readable directions. 8. **`RoadSegment`**: Represents a road segment between two NavigationPoints. Contains information like speed limit, one-way restrictions, etc. This is the smallest unit of the map that can have an Alert.

Design Navigation Alerts System. (Similar like Google Map Functionality.)

Requirements

Interview Simulation

Functional Requirements

💡 Interview Tip

Non-Functional Requirements

Core Entity Identification

Premium Content