1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// MINIMAL VIABLE DESIGN: Parking Lot System
 
// ============================================
// CORE USE CASE: Vehicle parks and pays
// ============================================
// 1. Vehicle arrives at parking lot
// 2. System assigns a spot based on vehicle size
// 3. Ticket is issued with entry time
// 4. Vehicle parks in assigned spot
// 5. When leaving, fee is calculated based on duration
// 6. Payment is processed
// 7. Vehicle exits
 
// ESSENTIAL ENTITIES (required for core use case):
// ✅ ParkingLot - the aggregate, knows its spots
// ✅ Floor - organizes spots, tracks per-floor availability
// ✅ ParkingSpot - the fundamental unit, has size and status
// ✅ Vehicle - the entity being parked, has size
// ✅ Ticket - tracks the parking session, links vehicle to spot
// ✅ Payment - records the transaction
 
// OPTIONAL ENTITIES (enhance but not required):
// 🔸 DisplayBoard - shows availability (user convenience)
// 🔸 Admin - manages lot (operational feature)
// 🔸 ChargingStation - EV charging (special feature)
// 🔸 Reservation - advanced booking (future feature)
// 🔸 MembershipCard - loyalty program (business feature)
// 🔸 Notification - alerts (engagement feature)
 
// MVD focuses on essential entities:
 
class ParkingLot {
    id: string;
    floors: Floor[];
    
    findAvailableSpot(vehicle: Vehicle): ParkingSpot | null {
        for (const floor of this.floors) {
            const spot = floor.findSpotFor(vehicle);
            if (spot) return spot;
        }
        return null;
    }
    
    issueTicket(vehicle: Vehicle): Ticket {
        const spot = this.findAvailableSpot(vehicle);
        if (!spot) throw new Error("No available spots");
        return Ticket.create(vehicle, spot);
    }
}
 
class Floor {
    id: string;
    floorNumber: number;
    spots: ParkingSpot[];
    
    findSpotFor(vehicle: Vehicle): ParkingSpot | null {
        return this.spots.find(spot => 
            spot.isAvailable() && spot.canFit(vehicle)
        ) || null;
    }
}
 
class ParkingSpot {
    id: string;
    size: SpotSize;
    status: SpotStatus;
    
    isAvailable(): boolean { return this.status === SpotStatus.AVAILABLE; }
    canFit(vehicle: Vehicle): boolean { return vehicle.size <= this.size; }
    occupy(): void { this.status = SpotStatus.OCCUPIED; }
    release(): void { this.status = SpotStatus.AVAILABLE; }
}
 
class Vehicle {
    licensePlate: string;
    size: VehicleSize;
}
 
class Ticket {
    id: string;
    vehicle: Vehicle;
    spot: ParkingSpot;
    entryTime: Date;
    exitTime: Date | null;
    
    static create(vehicle: Vehicle, spot: ParkingSpot): Ticket {
        spot.occupy();
        return new Ticket(vehicle, spot, new Date());
    }
    
    calculateFee(rateCard: RateCard): Money {
        const duration = this.getDurationHours();
        return rateCard.calculateFee(this.vehicle.size, duration);
    }
}
 
class Payment {
    id: string;
    ticketId: string;
    amount: Money;
    method: PaymentMethod;
    status: PaymentStatus;
    paidAt: Date;
}
 
// These entities are complete enough for MVD.
// Optional entities are noted but not designed in detail.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

// TIERED ENTITY ANALYSIS: Library Management System
 
/**
 * TIER 1: CORE ENTITIES
 * Required for: Members can borrow and return books
 */
 
class Book {
    isbn: string;
    title: string;
    author: string;
    // Core functionality: what's in the library
}
 
class BookCopy {
    id: string;
    bookIsbn: string;
    status: CopyStatus;  // AVAILABLE, BORROWED, LOST
    // Core functionality: track individual copies for lending
}
 
class Member {
    id: string;
    name: string;
    membershipStatus: MembershipStatus;
    // Core functionality: who can borrow
}
 
class Loan {
    id: string;
    copyId: string;
    memberId: string;
    borrowDate: Date;
    dueDate: Date;
    returnDate: Date | null;
    // Core functionality: tracks what's borrowed by whom
}
 
 
/**
 * TIER 2: SUPPORTING ENTITIES
 * Required for: Practical library operations
 */
 
class Librarian {
    id: string;
    name: string;
    permissions: Permission[];
    // Supporting: manages library, not required for lending
}
 
class Fine {
    id: string;
    loanId: string;
    amount: Money;
    status: FineStatus;
    // Supporting: enforces return policy
}
 
class LibraryCard {
    cardNumber: string;
    memberId: string;
    issueDate: Date;
    expiryDate: Date;
    // Supporting: physical/digital identification
}
 
 
/**
 * TIER 3: ENHANCEMENT ENTITIES  
 * Improve experience but not essential
 */
 
class Reservation {
    id: string;
    bookIsbn: string;
    memberId: string;
    requestDate: Date;
    status: ReservationStatus;
    // Enhancement: allows queuing for unavailable books
}
 
class Notification {
    id: string;
    recipientId: string;
    type: NotificationType;
    sentAt: Date;
    // Enhancement: reminders and alerts
}
 
class Review {
    id: string;
    bookIsbn: string;
    memberId: string;
    rating: number;
    comment: string;
    // Enhancement: social/discovery features
}
 
 
/**
 * TIER 4: FUTURE ENTITIES
 * Anticipated but not in current scope
 */
 
// class ReadingList { }   // Members save books to read later
// class BookClub { }      // Groups of members with shared reading
// class Recommendation { } // ML-based book suggestions
// class DigitalCopy { }   // E-book lending integration
// class InterLibraryLoan { } // Borrowing from other libraries
 
// These are noted in design documents but not designed yet.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# Elevator System - Requirements Analysis
 
## Requirement Analysis for Entity Prioritization
 
### REQUIREMENT 1 (Core - Tier 1)
"The system **must** move elevators between floors to transport passengers."
 
Entities involved:
- Elevator ✓ Tier 1
- Floor ✓ Tier 1
- (Passenger implied but may be out of scope - just requests)
 
### REQUIREMENT 2 (Core - Tier 1)  
"Passengers **will** request elevators by pressing call buttons on each floor."
 
Entities involved:
- FloorCallButton (or CallRequest) ✓ Tier 1
- Reinforces Floor as Tier 1
 
### REQUIREMENT 3 (Core - Tier 1)
"Passengers inside the elevator **shall** select destination floors."
 
Entities involved:
- ElevatorPanel / Destination Request ✓ Tier 1
- Destination selection mechanism
 
### REQUIREMENT 4 (Supporting - Tier 2)
"The system **should** optimize elevator movement to minimize wait times."
 
Entities involved:
- Scheduler / Algorithm (not an entity, but a component)
- Metrics / Statistics ✓ Tier 2
- May not need entity if embedded in Elevator logic
 
### REQUIREMENT 5 (Enhancement - Tier 3)
"The system **may** support VIP floors with priority access."
 
Entities involved:
- VIPConfiguration ✓ Tier 3
- AccessControl ✓ Tier 3
 
### REQUIREMENT 6 (Future - Tier 4)
"In **phase 2**, the system will support smart scheduling based on historical patterns."
 
Entities involved:
- UsageHistory ✓ Tier 4
- PredictionModel ✓ Tier 4
- Not designed now
 
---
 
## Resulting Entity Tiers
 
| Tier | Entities | Justification |
|------|----------|---------------|
| 1 | Elevator, Floor, Request, ElevatorController | Core movement functionality |
| 2 | MaintenanceMode, EmergencyProtocol | Operational safety |
| 3 | VIPAccess, DisplayScreen | Enhanced features |
| 4 | UsageAnalytics, SmartScheduler | Phase 2 features |

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Sample Interview Dialogue: Prioritizing Entities
 
INTERVIEWER: "Design a movie ticket booking system."
 
CANDIDATE: "Before I start designing, let me identify the core entities I'll focus on first.
 
For a ticket booking system, the essential entities are:
1. Movie - what's being shown
2. Theatre/Screen - where it's shown  
3. Show - specific showing (movie + screen + time)
4. Seat - what's being booked
5. Booking - the customer's reservation
6. Payment - the transaction
 
Secondary entities I'm aware of but will park for now:
- User accounts and authentication
- Reviews and ratings
- Loyalty programs
- Promotions and discounts
 
Is this scope appropriate, or should I include any of the secondary features?"
 
INTERVIEWER: "Focus on the core booking flow for now."
 
CANDIDATE: "Perfect. Let me design these core entities in detail, 
starting with their relationships and key behaviors..."
 
---
 
This approach demonstrates:
✓ Clear thinking about priorities
✓ Explicit about what's included and excluded
✓ Seeks confirmation before diving deep
✓ Shows awareness of broader system

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// DESIGNING WITH EXTENSION POINTS
 
// CORE ENTITY: Payment
// Designing with future payment methods in mind
 
// ❌ Without extension thinking
class PaymentBad {
    processCash(amount: number): void {
        // Cash logic
    }
    
    processCreditCard(cardNumber: string, amount: number): void {
        // Credit card logic
    }
    
    // Adding mobile payment requires modifying this class
    // Adding crypto payment requires modifying this class
    // Violates OCP
}
 
// ✅ With extension thinking: Strategy Pattern
interface PaymentProcessor {
    process(payment: Payment): PaymentResult;
    supports(method: PaymentMethod): boolean;
}
 
class CashPaymentProcessor implements PaymentProcessor {
    process(payment: Payment): PaymentResult {
        // Cash logic
    }
    supports(method: PaymentMethod): boolean {
        return method === PaymentMethod.CASH;
    }
}
 
class CreditCardProcessor implements PaymentProcessor {
    process(payment: Payment): PaymentResult {
        // Credit card logic
    }
    supports(method: PaymentMethod): boolean {
        return method === PaymentMethod.CREDIT_CARD;
    }
}
 
// Future: Add new processor without modifying existing code
class MobilePayProcessor implements PaymentProcessor {
    process(payment: Payment): PaymentResult { /* ... */ }
    supports(method: PaymentMethod): boolean {
        return method === PaymentMethod.MOBILE;
    }
}
 
class PaymentService {
    private processors: PaymentProcessor[];
    
    processPayment(payment: Payment): PaymentResult {
        const processor = this.processors.find(p => 
            p.supports(payment.method)
        );
        if (!processor) throw new Error("Unsupported payment method");
        return processor.process(payment);
    }
}
 
 
// CORE ENTITY: Notification (noted as optional, designed minimally)
// Leave extension point for when it becomes needed
 
// ❌ Without extension thinking: hardcoded to email
class TicketBad {
    complete(): void {
        this.status = TicketStatus.COMPLETED;
        this.sendEmail();  // Hardcoded, hard to extend
    }
}
 
// ✅ With extension thinking: Event-based
interface DomainEvent {
    type: string;
    payload: any;
    occurredAt: Date;
}
 
class TicketCompletedEvent implements DomainEvent {
    type = 'TicketCompleted';
    constructor(
        public payload: { ticketId: string; amount: Money },
        public occurredAt: Date = new Date()
    ) {}
}
 
class Ticket {
    private events: DomainEvent[] = [];
    
    complete(): void {
        this.status = TicketStatus.COMPLETED;
        // Raise event instead of direct action
        this.events.push(new TicketCompletedEvent({ 
            ticketId: this.id, 
            amount: this.totalAmount 
        }));
    }
    
    getUncommittedEvents(): DomainEvent[] {
        return this.events;
    }
}
 
// Later, when Notification entity is implemented:
class NotificationListener {
    handle(event: TicketCompletedEvent): void {
        // Send notification
        // No changes to Ticket class needed!
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# E-Commerce Platform Requirements
 
## Core Requirements (MVP)
1. Customers browse products organized in categories
2. Customers add products to a shopping cart
3. Customers checkout with shipping and payment information
4. Orders are placed and customers receive confirmation
5. Inventory is updated when orders are placed
 
## Secondary Requirements
6. Customers can create accounts to save information
7. Customers can view order history
8. Sellers can list and manage their products
9. Products have reviews and ratings
 
## Nice-to-Have Features
10. Wishlist functionality
11. Product recommendations based on browsing
12. Promotional discounts and coupon codes
13. Multiple shipping options with different speeds/prices
 
## Future Considerations
14. Subscription products (monthly boxes)
15. Digital product delivery
16. Seller analytics dashboard
17. Fraud detection system

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// E-COMMERCE: TIER 1 ENTITIES (Detailed Design)
 
class Product {
    id: ProductId;
    sellerId: SellerId;
    name: string;
    description: string;
    price: Money;
    categoryId: CategoryId;
    status: ProductStatus;  // DRAFT, ACTIVE, DISCONTINUED
    
    isAvailable(): boolean {
        return this.status === ProductStatus.ACTIVE;
    }
}
 
class Category {
    id: CategoryId;
    name: string;
    parentId: CategoryId | null;
    
    isRoot(): boolean { return this.parentId === null; }
}
 
class Cart {
    id: CartId;
    customerId: CustomerId | null;  // Null for guest carts
    items: CartItem[];
    createdAt: Date;
    updatedAt: Date;
    
    addItem(product: Product, quantity: number): void {
        const existing = this.items.find(i => i.productId === product.id);
        if (existing) {
            existing.updateQuantity(existing.quantity + quantity);
        } else {
            this.items.push(new CartItem(product.id, quantity, product.price));
        }
        this.updatedAt = new Date();
    }
    
    removeItem(productId: ProductId): void {
        this.items = this.items.filter(i => i.productId !== productId);
    }
    
    calculateTotal(): Money {
        return this.items.reduce(
            (sum, item) => sum.add(item.subtotal()),
            Money.zero()
        );
    }
    
    toOrder(shippingAddress: Address, paymentDetails: PaymentDetails): Order {
        return Order.createFromCart(this, shippingAddress, paymentDetails);
    }
}
 
class CartItem {
    productId: ProductId;
    quantity: number;
    unitPrice: Money;  // Captured at add time
    
    subtotal(): Money {
        return this.unitPrice.multiply(this.quantity);
    }
    
    updateQuantity(newQuantity: number): void {
        if (newQuantity < 1) throw new Error("Quantity must be at least 1");
        this.quantity = newQuantity;
    }
}
 
class Order {
    id: OrderId;
    customerId: CustomerId;
    items: OrderItem[];
    shippingAddress: Address;
    totalAmount: Money;
    status: OrderStatus;
    placedAt: Date;
    
    static createFromCart(
        cart: Cart, 
        shippingAddress: Address,
        paymentDetails: PaymentDetails
    ): Order {
        // Transform cart to order
        // Capture snapshot of prices
        // Set status to PENDING
    }
    
    confirm(): void {
        this.status = OrderStatus.CONFIRMED;
        // Trigger inventory reservation
    }
    
    ship(trackingNumber: string): void {
        this.status = OrderStatus.SHIPPED;
    }
}
 
class InventoryItem {
    id: InventoryId;
    productId: ProductId;
    quantity: number;
    reservedQuantity: number;
    
    availableQuantity(): number {
        return this.quantity - this.reservedQuantity;
    }
    
    reserve(amount: number): void {
        if (amount > this.availableQuantity()) {
            throw new Error("Insufficient inventory");
        }
        this.reservedQuantity += amount;
    }
    
    confirmReservation(amount: number): void {
        this.reservedQuantity -= amount;
        this.quantity -= amount;
    }
    
    releaseReservation(amount: number): void {
        this.reservedQuantity -= amount;
    }
}