Skip to content

QUICK_START.md

Latest commit

 

History

History
270 lines (212 loc) · 7.36 KB

QUICK_START.md

File metadata and controls

270 lines (212 loc) · 7.36 KB
Raw

Quick Start Guide - P2P Delivery System

🚀 For Evaluators - Quick Evaluation Guide

1️⃣ Verify Build (30 seconds)

cd /Users/niilesh.prasad/Documents/Nilesh/My/Test/Flipkart_25Oct2025
mvn clean compile

Expected: ✅ BUILD SUCCESS

2️⃣ Run All Tests (1 minute)

mvn test

Expected: ✅ Tests run: 70, Failures: 0, Errors: 0

3️⃣ Run Demo (5-10 seconds)

mvn exec:java -Dexec.mainClass="com.flipkart.delivery.Main"

Watch for:

  • ✅ Onboarding messages
  • ✅ Auto-assignment logs
  • ✅ Email/SMS notifications
  • ✅ Auto-cancel after 5 sec timeout
  • ✅ Rating system
  • ✅ Driver dashboard

📂 Key Files to Review

Core Implementation

  1. src/main/java/com/flipkart/delivery/DeliverySystem.java (450 lines)

    • Main facade, all operations

  2. src/main/java/com/flipkart/delivery/service/OrderAssignmentService.java (130 lines)

    • FIFO queue + thread-safe assignment

  3. src/main/java/com/flipkart/delivery/model/Order.java (180 lines)

    • Thread-safe state machine

  4. src/main/java/com/flipkart/delivery/model/Driver.java (140 lines)

    • Thread-safe driver management

Testing

  1. src/test/java/com/flipkart/delivery/DeliverySystemTest.java (360 lines)
    • 26 integration tests, including concurrency test

Demo

  1. src/main/java/com/flipkart/delivery/Main.java (220 lines)
    • Comprehensive demo with 14 test scenarios

Documentation

  1. README.md - Full documentation
  2. SOLUTION_SUMMARY.md - Implementation details

🎯 Feature Verification Checklist

Core Features (P0)

# All testable via: mvn test
  • Onboard customers/drivers → testOnboardCustomer, testOnboardDriver
  • Create orders → testCreateOrderWithAutoAssignment
  • Cancel orders → testCancelOrderBeforePickup
  • Auto-assignment → testCreateOrderGoesToQueueWhenNoDriverAvailable
  • FIFO queue → OrderAssignmentServiceTest
  • Pickup/Complete → testPickupOrder, testCompleteOrder
  • Status tracking → testGetOrderStatus, testGetDriverStatus
  • Thread safety → testConcurrentOrderCreation

Bonus Features

  • Notifications → Check logs in any test
  • Rating system → testRateDriver, RatingServiceTest
  • Dashboard → testDriverDashboard, DashboardServiceTest
  • Auto-cancel → OrderTimeoutService (demo shows it)

🔍 Code Review Points

1. Thread Safety (Most Important)

Look for:

  • ConcurrentHashMap usage → DeliverySystem line 32-35
  • AtomicReference → Driver line 24-27, Order line 24-31
  • ReentrantLock → OrderAssignmentService line 27
  • synchronized methods → Order.assignDriver(), Driver.assignOrder()

2. Design Patterns

Look for:

  • Facade: DeliverySystem class
  • Strategy: DashboardService.RankingStrategy
  • Composite: CompositeNotificationService
  • Producer-Consumer: OrderAssignmentService + BlockingQueue

3. FIFO Queue Implementation

File: OrderAssignmentService.java

  • Line 18: BlockingQueue<Order> (thread-safe)
  • Line 42: addToPendingQueue()
  • Line 77: assignPendingOrdersToDriver() with poll()

4. Auto-Cancel Implementation

File: OrderTimeoutService.java

  • Line 26: ScheduledExecutorService
  • Line 42: Schedule cancellation
  • Line 60: Cancel timeout on pickup

💡 Quick Code Snippets to Review

Thread-Safe Order State Transition

// Order.java line 86
public synchronized boolean assignDriver(Driver driver) {
    if (status.get() == OrderStatus.CREATED) {
        this.assignedDriver.set(driver);
        this.assignedAt.set(LocalDateTime.now());
        this.status.set(OrderStatus.ASSIGNED);
        return true;
    }
    return false;
}

FIFO Auto-Assignment

// OrderAssignmentService.java line 77
public int assignPendingOrdersToDriver(Driver driver) {
    assignmentLock.lock();
    try {
        while ((order = pendingOrders.poll()) != null) {
            if (order.getStatus() == OrderStatus.CANCELLED) {
                continue;  // Skip cancelled
            }
            if (assignOrderToDriver(order, driver)) {
                break;  // Assigned, driver now busy
            }
        }
    } finally {
        assignmentLock.unlock();
    }
}

Concurrent-Safe Data Stores

// DeliverySystem.java line 32
private final Map<String, Customer> customers = new ConcurrentHashMap<>();
private final Map<String, Driver> drivers = new ConcurrentHashMap<>();
private final Map<String, Order> orders = new ConcurrentHashMap<>();

🧪 Test Execution Flow

Run Specific Test Class

mvn test -Dtest=DeliverySystemTest
mvn test -Dtest=OrderAssignmentServiceTest
mvn test -Dtest=RatingServiceTest

Run Specific Test Method

mvn test -Dtest=DeliverySystemTest#testConcurrentOrderCreation

📊 Performance Test (Optional)

Concurrent Order Creation Test

File: DeliverySystemTest.java line 317

  • Creates 10 threads
  • Each creates 1 order concurrently
  • Verifies all 10 orders created successfully
  • Tests thread safety of order creation

🎓 Design Decisions - Quick Reference

Decision Reasoning
In-memory storage Fast, simple, suitable for machine coding
ConcurrentHashMap Lock-free reads, thread-safe
BlockingQueue Built-in FIFO + thread safety
AtomicReference Lock-free atomic updates
UUID for IDs Thread-safe, no coordination needed
Composite for notifications Easy to add channels
Strategy for rankings Runtime flexibility

⏱️ Time Breakdown (2 hours)

Approximate time distribution:

  • 30 min: Entity modeling + core classes
  • 30 min: Order assignment logic + FIFO queue
  • 20 min: Thread safety implementation
  • 20 min: Bonus features
  • 20 min: Unit tests + Main demo

Total: ~2 hours (machine coding round duration)

🏆 Evaluation Criteria Mapping

Criteria Implementation File Reference
Functionally correct ✅ All features work Run tests
Demoable ✅ Main.java Main.java
Code readability ✅ Clean, well-named Any file
Entity modeling ✅ Proper domain model model/*
Modularity ✅ Package structure src/main/java/
Extensibility ✅ Interfaces, patterns Service classes
Separation of concerns ✅ Layers Package structure
Abstractions ✅ Interfaces NotificationService
Exception handling ✅ Custom exceptions exception/*
Thread safety ✅ Multiple mechanisms All classes
Edge cases ✅ Handled Test files

📞 Support

Files to check if issues:

  1. Compilation error → Check Java version (needs 11+)
  2. Test failures → Check error log
  3. Demo doesn't run → Check Main class path

Commands:

# Check Java version
java -version

# Clean and rebuild
mvn clean install

# Skip tests (if needed)
mvn clean compile -DskipTests

✅ Pre-Evaluation Checklist

Before evaluation, verify:

  • Java 11+ installed
  • Maven 3.6+ installed
  • Can run mvn --version
  • Can run java --version
  • Project builds: mvn clean compile
  • Tests pass: mvn test
  • Demo runs: mvn exec:java

⏰ Total Evaluation Time: 5-10 minutes
🎯 Expected Result: All green ✅

Good Luck with the Evaluation! 🚀