Question 1

Describe the Node.js event loop and how it handles asynchronous operations. Provide an example of using callbacks and Promises.

Accepted Answer

The Node.js event loop is a single-threaded model that allows the execution of non-blocking I/O operations. It uses an event-driven architecture to handle asynchronous operations, making it efficient for I/O-heavy applications.

When an asynchronous operation like a file read is initiated, it is sent to the system kernel. Node.js continues execution while waiting for the operation to complete, and once it's done, the callback is added to the event queue. The event loop checks the queue and executes the callback when the call stack is empty.

Using Callbacks:
```javascript
const fs = require('fs');

console.log('Start reading file...');
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log('File contents:', data);
});
console.log('File read initiated...');
```

In the above example, `readFile` is non-blocking, and the console will show 'File read initiated...' before the contents of the file are printed.

Using Promises:
```javascript
const fs = require('fs').promises;

console.log('Start reading file...');
fs.readFile('example.txt', 'utf8')
    .then(data => console.log('File contents:', data))
    .catch(err => console.error(err));
console.log('File read initiated...');
```
Here, we use `fs.promises` which returns a Promise, allowing us to handle the result with `then` and `catch`, making the code cleaner and easier to read.

Question 2

What are the key differences between REST and GraphQL API design, and when would you choose one over the other in a project?

Accepted Answer

REST (Representational State Transfer) APIs are designed around resources and use standard HTTP methods like GET, POST, PUT, and DELETE. Each endpoint corresponds to a specific resource, leading to multiple endpoints for different data needs. For example:

```javascript
// REST API endpoint for fetching user data
GET /api/users/1
```

In contrast, GraphQL allows clients to request only the data they need through a single endpoint. This flexibility reduces over-fetching and under-fetching of data. For example:

```graphql
query {
  user(id: "1") {
    name
    email
  }
}
```

You would choose REST when your application requirements are straightforward and the resource structure is stable. GraphQL is preferred for complex applications with varied data requirements, as it allows clients to tailor their requests. However, consider the learning curve, caching, and tooling available for each approach in your decision.

Question 3

How would you create a progressive web application (PWA) that can work offline and has push notification capabilities? Provide a sample service worker code.

Accepted Answer

To create a Progressive Web Application (PWA) with offline capabilities and push notifications, you need to set up a service worker and integrate a push notification service.

1. **Service Worker Registration**: First, register the service worker in your main JavaScript file:
   ```javascript
   if ('serviceWorker' in navigator) {
       window.addEventListener('load', () => {
           navigator.serviceWorker.register('/service-worker.js')
               .then(reg => console.log('Service Worker registered:', reg))
               .catch(err => console.log('Service Worker registration failed:', err));
       });
   }
   ```

2. **Service Worker Implementation**: Create a `service-worker.js` file to handle caching and offline capabilities:
   ```javascript
   const CACHE_NAME = 'my-pwa-cache';
   const urlsToCache = ['/index.html', '/styles.css', '/app.js'];

self.addEventListener('install', (event) => {
       event.waitUntil(
           caches.open(CACHE_NAME)
               .then(cache => {
                   return cache.addAll(urlsToCache);
               })
       );
   });

self.addEventListener('fetch', (event) => {
       event.respondWith(
           caches.match(event.request)
               .then(response => {
                   return response || fetch(event.request);
               })
       );
   });
   ```

3. **Push Notification**: Use the Push API to send notifications.
   Example of subscribing to push notifications:
   ```javascript
   navigator.serviceWorker.ready.then(function(registration) {
       registration.pushManager.subscribe({
           userVisibleOnly: true,
           applicationServerKey: 'YOUR_PUBLIC_VAPID_KEY'
       }).then(function(subscription) {
           console.log('User is subscribed:', subscription);
       }).catch(function(err) {
           console.log('Failed to subscribe the user: ', err);
       });
   });
   ```

With these steps, you create a PWA that can work offline and send push notifications, enhancing user engagement and experience.

Question 4

How would you implement a serverless architecture for a real-time chat application using AWS Lambda and API Gateway?

Accepted Answer

To implement a serverless architecture for a real-time chat application, you can use AWS Lambda for the backend logic and API Gateway to expose your APIs. Here’s how:

1. **Set Up API Gateway**: Create a new API in the AWS API Gateway console. Define resources and methods (e.g., POST for sending messages, GET for fetching messages). Enable CORS for frontend accessibility.

2. **Create Lambda Functions**:
   - **Send Message Function**: This function will save messages to a DynamoDB table.
   ```python
   import json
   import boto3
   from datetime import datetime

dynamodb = boto3.resource('dynamodb')
   table = dynamodb.Table('ChatMessages')

def lambda_handler(event, context):
       body = json.loads(event['body'])
       message = body['message']
       user = body['user']
       timestamp = str(datetime.now())
       table.put_item(Item={'user': user, 'message': message, 'timestamp': timestamp})
       return {
           'statusCode': 200,
           'body': json.dumps('Message sent!')
       }
   ```
   - **Get Messages Function**: This function retrieves messages from DynamoDB.
   ```python
   def lambda_handler(event, context):
       response = table.scan()
       messages = response['Items']
       return {
           'statusCode': 200,
           'body': json.dumps(messages)
       }
   ```

3. **DynamoDB Table**: Create a DynamoDB table named `ChatMessages` with a primary key.

4. **Frontend**: Use WebSockets for real-time communication. You can use a library like Socket.IO to connect to the backend API.

5. **Deployment**: Use AWS SAM or Serverless Framework to deploy your application effectively.

By leveraging serverless architecture, you can scale automatically based on demand, reduce operational overhead, and focus on writing code instead of managing servers.

Question 5

Discuss the concepts of Flexbox and CSS Grid. How would you decide which layout model to use for a specific design requirement?

Accepted Answer

Flexbox and CSS Grid are both powerful layout models in CSS, each suited for different use cases.

### Flexbox Overview
Flexbox is designed for one-dimensional layouts, allowing items in a container to align and distribute space along a single axis (either row or column). It's ideal for simple layouts like navigation bars or aligning items in a row.

Example of a Flexbox layout:
```css
.container {
  display: flex;
  justify-content: space-between;
}
.item {
  flex: 1;
  margin: 10px;
}
```

### CSS Grid Overview
CSS Grid, on the other hand, is a two-dimensional layout system that allows for more complex layouts involving both rows and columns. It's ideal for layouts where you need to control both dimensions.

Example of a CSS Grid layout:
```css
.grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-gap: 10px;
}
.item {
  grid-column: span 2;
}
```

### Deciding Between Flexbox and CSS Grid
- Use Flexbox when:
  - You need a one-dimensional layout (either row or column).
  - You want to align items in a single direction.
  - You are managing space distribution among items.

- Use CSS Grid when:
  - You need a two-dimensional layout (both rows and columns).
  - You want to create complex layouts with overlapping items.
  - You need precise control over the placement of items in both dimensions.

In conclusion, choose Flexbox for simpler, linear layouts and CSS Grid for more complex, two-dimensional designs.

SarthiQ

Interview Preparation Guide

Cognizant
Questions & Answers

Document Details

Need Help?

Top Cognizant Interview Questions

Cognizant Interview Questions

A Backend Developer was asked

A Software Engineer was asked

Frontend Developer

Software Engineer