Dependency injection framework in LLD - Scalability & System Analysis

Scalability Analysis - Dependency injection framework

Growth Table: Dependency Injection Framework

Users/Requests	What Changes?
100 requests/sec	Simple DI container in memory, no concurrency issues, fast object creation.
10,000 requests/sec	Need thread-safe DI container, caching of created instances, reduce reflection overhead.
1,000,000 requests/sec	Distribute DI container across multiple app servers, use ahead-of-time code generation, minimize runtime overhead.
100,000,000 requests/sec	Use microservice architecture with local DI containers, service mesh for communication, aggressive caching, and load balancing.

First Bottleneck

The first bottleneck is the object creation and dependency resolution in the DI container. At low scale, this is fast and simple. As requests grow, the container's reflection or runtime analysis slows down, causing CPU overhead and latency.

Scaling Solutions

• Code Generation: Generate dependency wiring code at compile time to avoid runtime reflection.
• Caching: Cache created instances (singletons) to avoid repeated creation.
• Thread Safety: Make DI container thread-safe for concurrent requests.
• Horizontal Scaling: Run multiple app servers each with its own DI container to distribute load.
• Microservices: Split large apps into smaller services each with simpler DI needs.

Back-of-Envelope Cost Analysis

• At 10,000 requests/sec, if each DI resolution takes 1ms CPU, total CPU needed is 10 CPU cores (assuming 1 core ~1000ms/sec).
• Caching singletons reduces CPU by 70% as fewer objects are created.
• Memory usage grows with number of cached instances; plan for 100MB-500MB RAM per app server.
• Network bandwidth is minimal for DI itself but grows with app traffic.

Interview Tip

Start by explaining what a DI framework does simply. Then discuss how it handles object creation and wiring. Identify the bottleneck as runtime overhead. Suggest caching and code generation. Finally, mention horizontal scaling and microservices for very large scale.

Self Check

Your DI framework handles 1000 QPS. Traffic grows 10x to 10,000 QPS. What do you do first?

Answer: Implement caching of created instances and use code generation to reduce runtime overhead before scaling horizontally.

Key Result

Dependency injection frameworks scale by reducing runtime overhead through caching and code generation, then horizontally scaling app servers to handle increased requests.

Practice

1. What is the main purpose of a dependency injection framework?

easy

A. To store data permanently on disk

B. To automatically provide parts (dependencies) to your code

C. To make your code run faster by compiling it

D. To write all code manually without any helpers

Solution

1. Step 1: Understand what dependency injection means

   Dependency injection means giving the parts your code needs automatically instead of creating them inside the code.

2. Step 2: Identify the role of the framework

   A dependency injection framework helps by managing and providing these parts for you, making your code easier to change and test.

3. Final Answer:

   To automatically provide parts (dependencies) to your code -> Option B

4. Quick Check:

   Dependency injection = automatic parts supply [OK]

Hint: Think: Who gives parts to your code? The injector does! [OK]

Common Mistakes:

• Confusing dependency injection with data storage
• Thinking it speeds up code execution directly
• Believing it replaces manual coding completely

2. Which of the following is the correct way to register a service in a dependency injection framework?

easy

A. injector.register(ServiceClass)

B. ServiceClass.inject()

C. register.injector(ServiceClass)

D. ServiceClass.register()

Solution

1. Step 1: Recall the registration syntax

   In most dependency injection frameworks, you register a service by calling a method on the injector object and passing the service class.

2. Step 2: Match the correct syntax

   The correct syntax is injector.register(ServiceClass), which tells the injector to manage that service.

3. Final Answer:

   injector.register(ServiceClass) -> Option A

4. Quick Check:

   Register service = injector.register() [OK]

Hint: Register services by calling register on the injector [OK]

Common Mistakes:

• Calling register on the service class instead of injector
• Mixing method order or names
• Using non-existent methods like inject() on service

3. Given the code below, what will serviceA.getName() output?

class ServiceA {
  getName() { return 'Service A'; }
}

injector.register(ServiceA);
const serviceA = injector.get(ServiceA);
console.log(serviceA.getName());

medium

A. null

B. undefined

C. Error: Service not found

D. Service A

Solution

1. Step 1: Understand registration and retrieval

   The code registers ServiceA with the injector, then asks the injector to give an instance of ServiceA.

2. Step 2: Check the method call on the instance

   The instance has a method getName() that returns the string 'Service A'. So calling serviceA.getName() returns 'Service A'.

3. Final Answer:

   Service A -> Option D

4. Quick Check:

   Registered service returns its name [OK]

Hint: Registered services return their methods normally [OK]

Common Mistakes:

• Assuming injector.get returns undefined or null
• Forgetting to register before getting
• Expecting an error without registration

4. Identify the error in the following code snippet using a dependency injection framework:

class ServiceB {}

const serviceB = injector.get(ServiceB);
injector.register(ServiceB);

medium

A. ServiceB is registered after trying to get it

B. ServiceB class is missing a constructor

C. injector.get should be injector.fetch

D. injector.register should be called twice

Solution

1. Step 1: Check the order of registration and retrieval

   The code tries to get ServiceB from the injector before registering it, which causes an error because the injector doesn't know about ServiceB yet.

2. Step 2: Confirm correct usage order

   Services must be registered before they can be retrieved from the injector.

3. Final Answer:

   ServiceB is registered after trying to get it -> Option A

4. Quick Check:

   Register before get = correct order [OK]

Hint: Always register before getting a service [OK]

Common Mistakes:

• Trying to get service before registration
• Confusing method names like get vs fetch
• Thinking constructor is required for registration

5. You want to inject a Logger service into a UserService using a dependency injection framework. Which approach correctly applies dependency injection to make UserService easier to test?

class Logger {
  log(msg) { console.log(msg); }
}

class UserService {
  constructor(logger) {
    this.logger = logger;
  }
  createUser(name) {
    this.logger.log(`User ${name} created`);
  }
}

injector.register(Logger);
injector.register(UserService);

How should you get UserService with Logger injected?

hard

A. const userService = injector.get(Logger);

B. const userService = new UserService(new Logger());

C. const userService = injector.get(UserService);

D. const userService = UserService();

Solution

1. Step 1: Understand constructor injection

   UserService expects a Logger instance in its constructor. The injector knows how to create Logger and UserService because both are registered.

2. Step 2: Use injector to get UserService with dependencies

   Calling injector.get(UserService) lets the injector create UserService and automatically provide Logger to it.

3. Final Answer:

   const userService = injector.get(UserService); -> Option C

4. Quick Check:

   Injector provides dependencies via constructor [OK]

Hint: Get the service from injector to auto-inject dependencies [OK]

Common Mistakes:

• Manually creating dependencies instead of using injector
• Getting Logger instead of UserService
• Calling UserService without new keyword