42 items
Feature Module Dependency Inversion Leak
Code QuizDependency Inversion Across Feature Modules
QuizMemoized Selector Reference Trap
Code QuizState Architecture Tradeoffs at Scale
QuizRedux Reducer State Mutation Bug
Code QuizState Patterns Across Platforms
QuizState Management Tradeoffs At Scale
Slides / VideoState Patterns: Context, Redux, Zustand
Slides / VideoState Management Tradeoffs at Scale
FlashcardState Management Patterns in Apps
FlashcardLocal State That Won't Update
Code QuizLocal vs Global State Basics
QuizReusable Component Ignores Its Input
Code QuizSeparation of Concerns in MVC
QuizLocal vs Global State Basics
FlashcardState Management Basics in iOS
Slides / VideoBridge Boundary Sync Call Bug
Code QuizBridge vs JSI Architecture Trade-offs
QuizMVVM ViewModel State Mutation Bug
Code QuizLayered Architecture and State Ownership
QuizNative vs JS Boundary: Bridge vs JSI
FlashcardNative vs JS Boundary Trade-offs
Slides / VideoZustand Selector Causing Re-renders
Code QuizState Ownership & Navigation in SwiftUI
QuizLayer Dependency Violation in MVVM
Code QuizLayered Architecture: Domain Layer Role
QuizState & Navigation Architecture
Slides / VideoLayered Architecture: Presentation, Domain, Data
Slides / VideoState Management & Navigation Architecture
FlashcardLayered Architecture: Presentation, Domain, Data
FlashcardViewModel Breaks Separation of Concerns
Code QuizSeparating UI, State & Data Layers
QuizRedux Store Never Updates
Code QuizContext vs Redux State Management
QuizState Patterns: Context vs Redux
Slides / VideoSeparation of Concerns in iOS
Slides / VideoState Management: Environment vs Redux
FlashcardSeparation of Concerns in iOS Architecture
FlashcardState Management Patterns
FlashcardState Management Patterns Compared
Slides / VideoComponent UI & Separation of Concerns
Slides / VideoSeparation of Concerns in UI Architecture
FlashcardFeature Module Dependency Inversion Leak
A React Native feature module quietly couples its domain logic to a concrete infrastructure class, breaking the architectural boundary.
// features/cart/domain/CartService.ts
import { StripePaymentApi } from '../../payment/infrastructure/StripePaymentApi';
export interface PaymentGateway {
charge(amount: number): Promise<void>;
}
export class CartService {
private readonly payment: PaymentGateway;
// Domain service accepts an abstraction so it can be tested/swapped
constructor(payment: PaymentGateway = new StripePaymentApi()) {
this.payment = payment;
}
async checkout(total: number): Promise<void> {
if (total <= 0) throw new Error('Invalid total');
await this.payment.charge(total);
}
}This domain service is meant to depend only on abstractions. What breaks the layered/modular architecture here?