Question 1

What is the purpose of the GROUP BY clause in SQL? Provide an example using aggregated functions.

Accepted Answer

The GROUP BY clause in SQL is used to arrange identical data into groups and is often used with aggregate functions like COUNT, SUM, AVG, MAX, and MIN.

Example:
```sql
SELECT department_id, COUNT(*) AS employee_count
FROM employees
GROUP BY department_id;
```

This query counts the number of employees in each department. If you want to get the average salary per department, you can do:
```sql
SELECT department_id, AVG(salary) AS average_salary
FROM employees
GROUP BY department_id;
```

This will give you the average salary for each department, demonstrating how GROUP BY can be used effectively with aggregate functions.

Question 2

Can you explain how the Node.js event loop works and provide an example of its execution flow?

Accepted Answer

The Node.js event loop is a core component that enables non-blocking I/O operations, allowing JavaScript to handle multiple operations concurrently without multithreading. The event loop works by executing code, collecting events, and executing queued sub-tasks. Here’s a simplified flow of how the event loop operates:

1. Initialization: Node.js initializes the environment and starts the event loop.
2. Execute Stack: The event loop first processes the execution stack of synchronous code.
3. Event Queue: Next, it checks the event queue for any messages or callbacks that need to be executed.
4. I/O Operations: If there are any pending I/O operations, the event loop will handle those by delegating them to the system’s kernel.

Here’s an example demonstrating the event loop:

```javascript
console.log('Start');

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

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

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

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

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

In this example, 'Start' and 'End' are logged synchronously. The promise is resolved and pushed to the microtask queue, which gets executed before the next event loop iteration, hence 'Promise 1' appears before the timeouts. This showcases how Node.js efficiently handles tasks using the event loop.

Question 3

Design a microservice architecture for a simple e-commerce application. Include considerations for service communication, data storage, and scalability.

Accepted Answer

When designing a microservice architecture for an e-commerce application, we need to consider several aspects:

### Microservices Breakdown:
1. User Service: Handles user registration, authentication, and profile management.
2. Product Service: Manages product listings, inventory, and details.
3. Order Service: Handles order creation, payment processing, and order history.
4. Cart Service: Manages shopping cart operations.
5. Review Service: Manages user reviews and ratings for products.

### Communication:
- REST API: Each service exposes a RESTful API for communication.
- Message Broker: Use a message broker like RabbitMQ or Kafka for asynchronous communication, especially for events like order creation and inventory updates.

### Data Storage:
- Database per Service: Each microservice should have its own database to ensure loose coupling. For example:
  - User Service: PostgreSQL for structured data.
  - Product Service: MongoDB for flexible product attributes.
  - Order Service: MySQL for transactional support.

### Scalability:
- Load Balancer: Use a load balancer to distribute incoming requests across multiple instances of each service.
- Containerization: Deploy services in Docker containers for easy scaling and orchestration with Kubernetes.

### Example Service Communication:
```yaml
services:
  user:
    image: user-service:latest
    ports:
      - "8081:80"
  product:
    image: product-service:latest
    ports:
      - "8082:80"
  order:
    image: order-service:latest
    ports:
      - "8083:80"
```

### Conclusion:
This architecture offers flexibility and scalability while allowing individual services to be developed, deployed, and scaled independently.

Question 4

Can you explain the differences between stacks and queues? Provide code examples for implementing both data structures in JavaScript.

Accepted Answer

Stacks and queues are fundamental data structures with different principles of operation. A stack follows the Last In First Out (LIFO) principle, while a queue follows the First In First Out (FIFO) principle.

Example of Stack Implementation in JavaScript:
```javascript
class Stack {
    constructor() {
        this.items = [];
    }
    push(element) {
        this.items.push(element);
    }
    pop() {
        return this.items.pop();
    }
    peek() {
        return this.items[this.items.length - 1];
    }
    isEmpty() {
        return this.items.length === 0;
    }
}

const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
console.log(queue.dequeue()); // Outputs: 1
```
In these examples, the `Stack` class implements LIFO behavior, allowing elements to be added and removed from the end of the array, while the `Queue` class implements FIFO behavior, removing elements from the front of the array.

Edge Cases:
- Ensure that operations like `pop` and `dequeue` handle empty states gracefully to avoid errors.
- Consider performance implications of using arrays for these implementations, as operations can have varying time complexities based on the data structure's characteristics.

Question 5

Explain how you would implement a caching mechanism using Redis for a high-traffic service at Adobe. What strategies would you use for cache invalidation?

Accepted Answer

To implement a caching mechanism using Redis, we can use it to store frequently accessed data such as user sessions, configuration settings, or API responses. Here’s a basic implementation in Node.js:

```javascript
const redis = require('redis');
const client = redis.createClient();

// Function to get data with caching
async function getDataWithCache(key) {
    return new Promise((resolve, reject) => {
        client.get(key, async (err, data) => {
            if (err) reject(err);
            if (data) {
                // Cache hit
                return resolve(JSON.parse(data));
            }
            // Cache miss - fetch from DB
            const freshData = await fetchDataFromDatabase(key);
            client.setex(key, 3600, JSON.stringify(freshData)); // Cache for 1 hour
            resolve(freshData);
        });
    });
}

// Invalidation strategy example
function invalidateCache(key) {
    client.del(key); // Delete the specific key from cache
}

async function fetchDataFromDatabase(key) {
    // Simulating a database fetch operation
    return { id: key, name: 'Sample Data' };
}
```

For cache invalidation strategies, we can use:
1. Time-based expiration using `setex`, as shown above.
2. Event-based invalidation where we clear cache when the underlying data changes, e.g., after an update operation.
3. Manual invalidation using an admin interface to clear specific keys.
This approach ensures we balance between performance and data consistency, crucial for high-traffic services at Adobe.

SarthiQ

Interview Preparation Guide

Adobe
Questions & Answers

Document Details

Need Help?

Top Adobe Interview Questions

Adobe Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Backend Developer

Full Stack Developer