Question 1

Can you explain how the Node.js event loop works? Illustrate your explanation with an example that includes asynchronous code execution.

Accepted Answer

The Node.js event loop is a crucial part of its non-blocking architecture, allowing it to handle multiple operations simultaneously. The event loop processes events from the event queue and executes callbacks. Here’s a breakdown:

1. Phases of the Event Loop: It consists of several phases: timers, I/O callbacks, idle, poll, check, and close callbacks.
2. Execution: It picks events from the queue and executes their callbacks, enabling asynchronous operations.

Here’s an example demonstrating the event loop in action:
```javascript
console.log('Start');

setTimeout(() => {
  console.log('Timeout 1');
}, 0);

setImmediate(() => {
  console.log('Immediate 1');
});

Promise.resolve().then(() => {
  console.log('Promise 1');
});

console.log('End');
```

Output:
```
Start
End
Promise 1
Timeout 1
Immediate 1
```

In this example:
- The synchronous logs 'Start' and 'End' execute first.
- The promise resolution is handled next, demonstrating how microtasks (like promises) are executed before the next event loop tick.
- The `setTimeout` and `setImmediate` callbacks are executed afterward, showing how the event loop manages asynchronous operations.

Question 2

What is the syllabus for TCS NQT 2025, and how can one prepare for the coding section effectively? Provide example coding questions and their solutions.

Accepted Answer

### Syllabus Overview for TCS NQT 2025
The coding section typically covers:
- Data Structures (Arrays, Strings, Trees, Graphs)
- Algorithms (Sorting, Searching, Recursion)
- Basic programming concepts (Loops, Functions, OOP principles)

### Example Coding Question 1: Reverse a Linked List
Problem Statement: Given the head of a singly linked list, reverse the list and return the reversed list.

Solution:
To reverse a linked list, we can use three pointers: previous, current, and next.

```python
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        next_temp = current.next  # Store next node
        current.next = prev       # Reverse the link
        prev = current            # Move prev to current
        current = next_temp       # Move to next node
    return prev  # New head of the reversed list

# Example Usage
head = ListNode(1, ListNode(2, ListNode(3)))
reversed_head = reverse_linked_list(head)
```

### Example Coding Question 2: Find First Unique Character in a String
Problem Statement: Given a string, find the first non-repeating character in it and return its index. If it does not exist, return -1.

Solution:
We can use a dictionary to count the occurrences of each character and then identify the first unique character.

```python
def first_unique_char(s):
    count = {}
    for char in s:
        count[char] = count.get(char, 0) + 1
    for i, char in enumerate(s):
        if count[char] == 1:
            return i
    return -1

# Example Usage
print(first_unique_char("leetcode"))  # Output: 0
```

Question 3

How do you approach system design for microservices architecture, especially for a TCS project?

Accepted Answer

Designing a microservices architecture involves several key principles and considerations. Here’s a structured approach:

1. Understand Requirements: Begin by gathering requirements. For example, if designing an e-commerce application, identify services such as User Management, Product Catalog, and Order Processing.

2. Define Microservices: Decompose the application into microservices based on business capabilities. Each service should focus on a single responsibility.
   - User Service: Handles user registration and authentication.
   - Product Service: Manages product details and inventory.
   - Order Service: Processes orders and payments.

3. Database Design: Choose databases for each microservice based on data needs. For instance:
   - Use a relational database (e.g., PostgreSQL) for the User Service.
   - Use a NoSQL database (e.g., MongoDB) for the Product Service due to flexible data structure.

4. Communication: Define how services communicate. Use RESTful APIs or message brokers (e.g., RabbitMQ, Kafka) for asynchronous communication.
   - For synchronous calls, REST APIs can be designed as follows:
   ```python
   from flask import Flask, jsonify, request
   app = Flask(__name__)

@app.route('/products', methods=['GET'])
   def get_products():
       products = [...]  # Fetch from the database
       return jsonify(products)
   ```

5. Service Discovery: Implement service discovery to allow services to find and communicate with each other dynamically. Tools like Eureka or Consul can be used.

6. API Gateway: Use an API Gateway to route requests to appropriate microservices, handle authentication, and aggregate responses. This can be implemented using tools like Nginx or AWS API Gateway.

7. Monitoring and Logging: Incorporate monitoring (using Prometheus) and centralized logging (using ELK stack) to track service performance and errors.

8. Deployment: Consider containerization with Docker and orchestration with Kubernetes for deployment.

### Example Microservice Deployment:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: user-service:latest
        ports:
        - containerPort: 5000
```

By following these steps, you can effectively design and implement a microservices architecture suitable for TCS projects.

Question 4

What is the event loop in Node.js, and how does it handle asynchronous operations?

Accepted Answer

The event loop in Node.js is a mechanism that allows the execution of non-blocking I/O operations, despite JavaScript being single-threaded. It uses a call stack and a message queue. Here’s a brief explanation:

1. Call Stack: It executes the top function in the stack and removes it once complete.
2. Message Queue: Asynchronous function callbacks are pushed here after their respective operations complete.

To illustrate, consider the following example:

```javascript
console.log('First');
setTimeout(() => {
    console.log('Second');
}, 0);
console.log('Third');
```
Output:
```
First
Third
Second
```
In this example, `setTimeout` is non-blocking and is added to the message queue. The event loop picks it up only after the call stack is empty, demonstrating how asynchronous operations are handled in Node.js.

Question 5

What are the fundamental differences between HTTP and TCP/IP? How does the OSI model relate to these protocols?

Accepted Answer

HTTP (Hypertext Transfer Protocol) and TCP/IP (Transmission Control Protocol/Internet Protocol) are critical components of internet communication. Understanding their differences is essential for network programming and web development.

### TCP/IP Overview
TCP/IP is a suite of protocols that governs how data is transmitted over the internet. It includes the TCP for reliable data transfer and IP for addressing and routing packets.

### HTTP Overview
HTTP is an application layer protocol used for transmitting hypermedia documents, such as HTML. It operates on top of TCP, relying on it for the reliable transmission of requests and responses.

### Key Differences
- Layer: TCP is at the Transport Layer (Layer 4) of the OSI model, while HTTP is at the Application Layer (Layer 7).
- Functionality: TCP ensures reliable delivery of packets by establishing a connection and managing packet loss, while HTTP defines how requests and responses between clients and servers are structured.

### OSI Model Relation
The OSI model consists of seven layers, with TCP/IP primarily operating on the lower layers (Transport and Network) and HTTP functioning on the Application layer. Here's a simplified representation:

| OSI Layer | Protocols   |
| ---------- | ----------- |
| 7          | HTTP        |
| 6          | Presentation |
| 5          | Session     |
| 4          | TCP         |
| 3          | IP          |
| 2          | Data Link   |
| 1          | Physical    |

### Conclusion
In summary, while TCP/IP provides the fundamental capabilities for data transport, HTTP leverages these capabilities to facilitate specific interactions between web clients and servers. Understanding the interplay between these protocols is essential for developing robust network applications.

SarthiQ

Interview Preparation Guide

TCS
Questions & Answers

Document Details

Need Help?

Top TCS Interview Questions

TCS Interview Questions

A Backend Developer was asked

A Software Engineer was asked

Backend Developer

Backend Developer

Interview Preparation Guide

TCSQuestions & Answers

Document Details

Need Help?

Top TCS Interview Questions

TCS Interview Questions

A Backend Developer was asked

A Software Engineer was asked

Backend Developer

Backend Developer

TCS
Questions & Answers