Question 1

How can you effectively manage state in a React application? Discuss the pros and cons of using Context API versus Redux for state management.

Accepted Answer

In a React application, state management is crucial for maintaining the app's data flow. Two popular methods are Context API and Redux. ### Context API The Context API allows us to share state across the component tree without passing props down manually at every level. Here’s a basic example: ```javascript import React, { createContext, useContext, useState } from 'react'; const MyContext = createContext(); const MyProvider = ({ children }) => { const [state, setState] = useState({ user: null }); return ( {children} ); }; const ChildComponent = () => { const { state, setState } = useContext(MyContext); return

User: {state.user}

; }; const App = () => ( ); ``` Pros: - Simplicity and ease of use. - No additional libraries required. Cons: - Not suitable for complex state management and can lead to performance issues with frequent re-renders. ### Redux Redux is a more powerful state management library that uses a centralized store. Here’s a basic example: ```javascript import React from 'react'; import { createStore } from 'redux'; import { Provider, useDispatch, useSelector } from 'react-redux'; const initialState = { user: null }; const reducer = (state = initialState, action) => { switch (action.type) { case 'SET_USER': return { ...state, user: action.payload }; default: return state; } }; const store = createStore(reducer); const ChildComponent = () => { const user = useSelector(state => state.user); const dispatch = useDispatch(); const setUser = (user) => { dispatch({ type: 'SET_USER', payload: user }); }; return

User: {user}

; }; const App = () => ( ); ``` Pros: - Predictable state management and easier debugging with tools like Redux DevTools. - More maintainable for larger applications. Cons: - More boilerplate code required. - Learning curve can be steep for beginners. In summary, for small applications, Context API may suffice, but for larger applications where performance and maintainability are a concern, Redux is often the better choice.

Question 2

What strategies would you use to ensure container orchestration with Kubernetes is reliable and fault-tolerant?

Accepted Answer

To ensure reliability and fault tolerance in a Kubernetes environment, several strategies must be implemented:

1. **Pod Disruption Budgets (PDB):** Define PDBs to limit the number of concurrent disruptions to your pods. This ensures that a certain number always remain available during upgrades or maintenance:
```yaml
apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
  name: my-app-pdb
spec:
  minAvailable: 2
  selector:
    matchLabels:
      app: my-app
```

2. **Horizontal Pod Autoscaler (HPA):** Use HPA to automatically scale your pods based on CPU/memory usage or custom metrics. This maintains performance during traffic spikes:
```yaml
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80
```

3. **Health Checks:** Implement readiness and liveness probes to ensure that pods are running healthy and can handle traffic.
```yaml
livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
```

4. **Use of StatefulSets:** For applications that need stable storage and unique network identities, use StatefulSets for better management of stateful applications.

5. **Backup and Disaster Recovery:** Regularly back up your etcd data and have a disaster recovery plan in place to restore your cluster quickly.

By following these strategies, you can ensure your Kubernetes deployment is robust, scalable, and fault-tolerant, which is essential in today's microservices-driven architectures.

Question 3

Explain how you would implement a progressive web application (PWA) and what benefits this brings in 2026?

Accepted Answer

To implement a Progressive Web Application (PWA), you would follow these key steps:

1. **Service Workers:** Create a service worker to cache assets and enable offline functionality. Add the following code in a service-worker.js file:
```javascript
self.addEventListener('install', (event) => {
    event.waitUntil(
        caches.open('my-pwa-cache').then((cache) => {
            return cache.addAll([
                '/',
                '/index.html',
                '/styles.css',
                '/script.js'
            ]);
        })
    );
});
self.addEventListener('fetch', (event) => {
    event.respondWith(
        caches.match(event.request).then((response) => {
            return response || fetch(event.request);
        })
    );
});
```

2. **Manifest File:** Create a manifest.json file to describe your app and enable installation on mobile devices:
```json
{
  "name": "My PWA",
  "short_name": "PWA",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#000000",
  "icons": [
    {
      "src": "icon.png",
      "sizes": "192x192",
      "type": "image/png"
    }
  ]
}
```

3. **HTTPS:** Serve your application over HTTPS to ensure security, as service workers only run on secure origins.

**Benefits of PWAs in 2026:**
- **Enhanced Performance:** Caching allows for fast loading times, even on slow networks.
- **Offline Access:** Users can access your app without an internet connection, increasing engagement.
- **Cross-Platform Compatibility:** PWAs run on any device with a web browser, reducing development costs.
- **Installable:** Users can install PWAs on their devices, providing a native app-like experience without app store constraints.

Implementing a PWA ensures your application is modern, accessible, and user-friendly, aligning with current trends in web development.

Question 4

Explain the fundamentals of HTTP and TCP/IP protocols. How do they interact in web communication?

Accepted Answer

HTTP (Hypertext Transfer Protocol) and TCP/IP (Transmission Control Protocol/Internet Protocol) are foundational protocols in web communication. TCP/IP Fundamentals: TCP/IP is a suite of protocols governing how data is sent over the internet. It consists of: - IP: Responsible for addressing and routing packets between devices. Each device on a network has a unique IP address. - TCP: Ensures reliable transmission of data. It breaks down messages into packets, sends them, and reassembles them on the receiving end. TCP also manages error-checking and ensures that packets are received in the correct order. HTTP Fundamentals: HTTP is an application-layer protocol built on top of TCP/IP. It defines how messages are formatted and transmitted. A simple HTTP request can look like: ```http GET /index.html HTTP/1.1 Host: www.example.com ``` The server processes the request and sends back an HTTP response, which might look like: ```http HTTP/1.1 200 OK Content-Type: text/html Hello World ``` Interaction: When a client (like a web browser) wants to fetch a resource: 1. It initiates a TCP connection to the server using the server's IP address and a specific port (usually port 80 for HTTP or 443 for HTTPS). 2. Once the connection is established, the client sends an HTTP request to the server over this TCP connection. 3. The server processes the request and sends back an HTTP response, also over the TCP connection. 4. After the data transfer, the TCP connection may be closed, but persistent connections can keep it open for additional requests. In summary, HTTP operates on top of TCP/IP, providing a standardized way for clients and servers to communicate over the internet. Understanding these protocols is crucial for web development and troubleshooting communication issues.

Question 5

Can you explain dynamic programming and provide a code example to solve the Fibonacci sequence using a dynamic programming approach?

Accepted Answer

Dynamic programming is a technique used to solve complex problems by breaking them down into simpler subproblems and storing the results to avoid redundant calculations. It's particularly effective for optimization problems.

Here's how you can solve the Fibonacci sequence using dynamic programming:

```javascript
function fibonacci(n) {
  const memo = new Array(n + 1);
  memo[0] = 0;
  memo[1] = 1;

for (let i = 2; i <= n; i++) {
    memo[i] = memo[i - 1] + memo[i - 2];
  }
  return memo[n];
}

console.log(fibonacci(10)); // Output: 55
```

In this example, we create an array `memo` to store Fibonacci numbers as we compute them. This way, instead of recalculating Fibonacci values, we simply look them up in our `memo` array, significantly improving performance from exponential to linear time complexity, O(n). Dynamic programming is especially useful in problems where overlapping subproblems exist, such as knapsack or shortest path problems.

SarthiQ

Interview Preparation Guide

Infosys
Questions & Answers

Document Details

Need Help?

Top Infosys Interview Questions

Infosys Interview Questions

A Frontend Developer was asked

A Backend Developer was asked

Frontend Developer

Software Engineer