Requirements

Let's design a simplified Application that allows users to run pre-defined "Units of Work" and track their execution results. Think of this as a lightweight, in-memory task execution framework. The system should allow registering different Units of Work, executing them, and recording their status (success/failure) along with relevant output or error messages. We want to build this with a strong focus on testability, extensibility and thread safety. This application will mimic a simple task scheduling system. Each unit of work will represent an independent task. For simplicity, consider these units of work as in-memory operations, avoiding heavy I/O (e.g., database interactions) to keep the focus on design patterns and concurrency. The core functionality lies in managing and executing these units of work efficiently and reliably. # Requirements ## Functional Requirements 1. **Unit of Work Registration:** The application must allow registering different types of `UnitOfWork`. Each `UnitOfWork` should have a unique identifier (e.g., a name or ID) and an associated execution logic. Implement at least two distinct example `UnitOfWork` implementations (e.g., `LoggingUnitOfWork`, `CalculationUnitOfWork`). 2. **Asynchronous Execution:** The application must support asynchronous execution of `UnitOfWork`. This means that multiple `UnitOfWork` instances can run concurrently without blocking the main thread. Use a thread pool for managing the execution threads. 3. **Execution Tracking:** The application must track the execution status of each `UnitOfWork`. This includes recording whether the unit of work completed successfully or failed, along with any relevant output or error messages. 4. **Result Retrieval:** The application must provide a mechanism to retrieve the results of executed `UnitOfWork`. This should allow users to query the status, output, and error messages for a specific `UnitOfWork` based on its identifier. Results should be available *after* the execution is complete. 5. **Exception Handling:** The system should gracefully handle exceptions thrown by `UnitOfWork` implementations. Exceptions should be caught, logged, and reflected in the execution status of the `UnitOfWork` without crashing the application. 6. **Cancellation:** Provide a mechanism to cancel an already running `UnitOfWork`. 7. **Dependency Injection:** Allow injecting dependencies into `UnitOfWork` instances. ## Non-Functional Requirements 1. **Thread Safety:** The application must be thread-safe. Multiple threads should be able to register, execute, and retrieve results of `UnitOfWork` concurrently without causing data corruption or race conditions. Pay close attention to synchronization mechanisms used to protect shared resources. 2. **Extensibility:** The design must be extensible. It should be easy to add new types of `UnitOfWork` without modifying the core application logic. Consider using design patterns like Strategy or Factory to achieve this. 3. **Modularity:** The application should be modular. Different components should be loosely coupled and have well-defined responsibilities. This makes the application easier to understand, test, and maintain. 4. **Testability:** The application must be designed for testability. It should be possible to write unit tests for individual components, as well as integration tests for the entire system. Consider using dependency injection to facilitate mocking and stubbing of dependencies during testing. 5. **Resource Management:** The application must manage resources efficiently, especially threads. The thread pool should be properly sized and managed to avoid resource exhaustion. Consider using a bounded thread pool to limit the number of concurrent threads. 6. **Asynchronous Result Handling:** Should provide a way for user to define a callback or listener to receive the execution results of UnitOfWork when it's completed. 7. **Cancellation Support:** Implement a way to allow running jobs to be cancellable. ## Core Entities 1. **`UnitOfWork` (Interface):** Represents a single unit of work to be executed. It defines the `execute()` method, which contains the logic for performing the work. It should also support cancellation. 2. **`UnitOfWorkRegistry`:** A central registry for managing `UnitOfWork` instances. It provides methods for registering new `UnitOfWork` types and retrieving them by their identifier. This should be thread-safe. 3. **`UnitOfWorkExecutor`:** Responsible for executing `UnitOfWork` instances asynchronously using a thread pool. It manages the lifecycle of submitted tasks and tracks their execution status. 4. **`ExecutionResult`:** Represents the result of executing a `UnitOfWork`. It contains information about the execution status (success/failure), output, and any error messages. It also holds the `UnitOfWork`'s identifier. 5. **`ThreadPool` (or `ExecutorService`):** Manages a pool of threads for executing `UnitOfWork` instances concurrently. It should be configurable with a maximum number of threads. 6. **`UnitOfWorkFactory`:** (Optional but recommended): An abstraction for creating `UnitOfWork` instances. This decouples the `UnitOfWorkExecutor` from the concrete `UnitOfWork` implementations, making the system more extensible. 7. **`CompletionListener` (Interface): Defines a callback function to be executed when a `UnitOfWork` finishes execution.)**

Design Unit Testing Application

Requirements

Interview Simulation

Functional Requirements

💡 Interview Tip

Non-Functional Requirements

Core Entity Identification

Premium Content