IBM Interview Questions

Intermediate Level IBM Interview Questions and Answers

11. Explain the difference between abstraction & encapsulation. 

Abstraction & encapsulation are two fundamental concepts in object-oriented programming, but they serve different purposes.

12. Describe the functioning of a Content Delivery Network (CDN).

A Content Delivery Network (CDN) is a geographically distributed network of servers that work together to provide fast delivery of internet content. 

Here's how it works:

1. A user requests content (e.g., a website, video, image) from a website.
2. The request is routed to the nearest CDN server (also called an edge server).
3. If the content is already cached on the edge server, it's delivered to the user.
4. If not, the edge server requests the content from the origin server, caches it, & then delivers it to the user.

By serving content from a server close to the user, CDNs reduce latency, improve load times, & reduce the load on the origin server. They're commonly used to deliver static content like images, videos, & CSS/JavaScript files.

13. What is Docker & how is it used in software development?

Docker is a platform for developing, shipping, & running applications using containers. A container is a lightweight, standalone executable package that includes everything needed to run a piece of software, including the code, runtime, system tools, libraries, & settings.

In software development, Docker is used to:

1. Ensure consistency across environments (dev, test, prod) by packaging the app & its dependencies into a container.
2. Simplify application deployment by providing a standardized unit of deployment (the container).
3. Improve efficiency by allowing multiple containers to run on the same machine, sharing the OS kernel.
4. Facilitate microservices architecture by providing a way to package & deploy individual services as containers.

14. Explain the concept of microservices architecture.

Microservices architecture is a way of structuring an application as a collection of small, independent services. Each service runs in its own process & communicates with other services through lightweight mechanisms, often an HTTP API.

Important characteristics of microservices architecture are:

1. Services are small, focusing on doing one thing well.
2. Services are independently deployable & scalable.
3. Services are organized around business capabilities.
4. Services communicate via well-defined APIs, often HTTP/REST.
5. Services are designed for failure & can tolerate the failure of other services.

15. How does ARP work? Describe ARP spoofing.

Address Resolution Protocol (ARP) is used to map IP addresses to physical MAC addresses on a local network.

Here's how ARP works:

1. When a device needs to communicate with another device on the local network, it needs the MAC address of the target device.
2. The sender broadcasts an ARP request to all devices on the network, asking "Who has this IP address?"
3. The device with the requested IP address sends an ARP reply back to the sender with its MAC address.
4. The sender caches the IP-to-MAC mapping in its ARP table for future use & sends the packet to the target MAC address.

ARP spoofing (or ARP poisoning) is a type of attack where an attacker sends falsified ARP messages over a local network. The attacker aims to associate their MAC address with the IP address of another host, such as the default gateway, causing any traffic meant for that IP address to be sent to the attacker instead. This allows the attacker to intercept, modify, or even stop data in-transit.

16. What is Git & how does it facilitate version control?

Git is a distributed version control system that tracks changes in source code during software development. It allows multiple developers to work on the same project concurrently.

Git facilitates version control by:

1. Allowing developers to work independently on their own branches & merge changes back when ready.
2. Providing a complete history of all changes, allowing developers to revert to previous versions if needed.
3. Enabling collaboration through features like pull requests, where changes can be reviewed before being merged.
4. Providing features for resolving conflicts when the same part of a file has been changed by multiple developers.

17. Describe design patterns, its types and examples.

Design patterns are reusable solutions to common problems in software design. They provide a general template for solving a problem that can be adapted to fit specific situations. Design patterns are not specific to any programming language but are high-level strategies for structuring code. There are three main types of design patterns:

Creational patterns: These deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. Examples include:

1. Singleton: Ensures a class has only one instance & provides a global point of access to it.
2. Factory: Defines an interface for creating an object, but let subclasses decide which class to instantiate.

Structural patterns: These deal with object composition, creating relationships between objects to form larger structures. For example:

1. Adapter: Allows classes with incompatible interfaces to work together by wrapping its own interface around that of an existing class.
2. Decorator: Attaches additional responsibilities to an object dynamically, providing a flexible alternative to subclassing.

Behavioral patterns: These deal with communication between objects, assigning responsibilities between objects & encapsulating algorithms. For example:

1. Observer: Defines a one-to-many relationship between objects so that when one object changes state, all its dependents are notified & updated automatically.
2. Strategy: Defines a family of algorithms, encapsulates each one, & makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

18. Explain process synchronization & its methods.

Process synchronization is the task of coordinating the execution of processes or threads in a concurrent system, especially when they share resources (like data, files, I/O devices). It ensures that concurrent access to shared resources doesn't lead to unexpected or erroneous behavior.

Methods for process synchronization are:

1. Locks: Before accessing a shared resource, a process must acquire a lock. It releases the lock when it's done. If another process tries to acquire a locked resource, it must wait until the lock is released.
2. Semaphores: A semaphore is a variable or abstract data type used to control access to a common resource by multiple processes. It consists of a counter & a queue. If the counter is zero, any process trying to acquire the semaphore is blocked & added to the queue.
3. Monitors: A monitor is a synchronization construct that allows threads to have both mutual exclusion & the ability to wait (block) for a certain condition to become true. It consists of a mutex (lock) & condition variables.
4. Message passing: In this method, processes communicate by sending & receiving messages. A process can block when waiting for a message & can have a message queue to store incoming messages.

19. Describe the boot process of a typical operating system.

The boot process of a typical operating system can be divided into several stages:

1. Power on: The computer is powered on & the BIOS (Basic Input/Output System) initializes the hardware, including the screen & keyboard, & tests the main memory.
2. BIOS: The BIOS searches, loads, & executes the boot loader program from the boot device (hard disk, SSD, CD, USB).
3. Boot loader: The boot loader loads the kernel into memory & starts its execution. The most common boot loaders are GRUB for Linux & NTLDR for Windows.
4. Kernel: The kernel initializes devices & memory, mounts the root file system, & starts the init process.
5. Init: The init (short for initialization) is the first process started by the kernel. It continues the boot process by starting various services.
6. Runlevel: Based on the runlevel (a preset configuration), the init process starts the associated services (background processes). For example, runlevel 3 on Linux is a multiuser command-line environment, while runlevel 5 is a multiuser graphical environment.
7. Login: Once all services are started, the operating system presents a login prompt or GUI for the user to enter credentials.

Throughout the boot process, information & error messages may be logged for debugging purposes. Modern operating systems also support hibernation & fast booting where the system state is saved to disk for quicker startup.

20. Explain the concept of VLANs & its advantages.

A Virtual LAN (VLAN) is a logical subnetwork that groups together a collection of devices from different physical LANs. Devices in a VLAN communicate as if they are connected to the same wire, even if they are located on different LAN segments. VLANs work by adding a tag to each Ethernet frame that identifies which VLAN it belongs to. This tag is used by network switches to determine where to send the frame. Devices that belong to the same VLAN can communicate with each other as if they were on the same physical network, regardless of their actual location.

Advantages of VLANs:

1. Security: VLANs provide a way to logically separate network traffic, which can improve security by isolating sensitive data & limiting the impact of a security breach.
2. Reduced broadcast traffic: By dividing a network into VLANs, broadcast traffic is contained within each VLAN, reducing unnecessary traffic on the rest of the network.
3. Flexibility: VLANs allow network administrators to logically group devices based on function, department, or application, regardless of their physical location.
4. Better performance: VLANs can improve network performance by reducing the size of broadcast domains & limiting the scope of broadcasts.
5. Cost savings: VLANs can reduce the need for expensive network upgrades by making better use of existing switches & allowing the network to be segmented without buying new hardware.

Advanced Level IBM Interview Questions and Answers

21. What is a deadlock? How can it be prevented?

A deadlock is a situation where two or more processes are unable to proceed because each is waiting for the other to release a resource. The processes are stuck in a circular dependency, permanently blocking each other.

Deadlock can be prevented by below mentioned strategies:

• Resource Ordering: Make processes request resources in a specific, standardized order.
• Timeout-Based Mechanisms: Set a time limit for how long a process can wait for a resource.
• Resource Allocation Graphs: Use a directed graph to model the allocation & requests of resources.
• Banker's Algorithm: Grant a resource request only if it leaves the system in a safe state.
• Avoid Circular Wait: Ensure that a circular chain of processes, each waiting for a resource held by the next process, never forms.

22. What are the advantages & disadvantages of using RESTful APIs?

RESTful (Representational State Transfer) APIs are a popular architectural style for designing networked applications. They use HTTP requests to GET, PUT, POST & DELETE data.

Advantages of RESTful APIs:

1. Simplicity: REST uses standard HTTP methods, making it easy to understand & use.
2. Flexibility: Data is not tied to resources or methods, so REST can handle multiple types of calls & return different data formats.
3. Scalability: Stateless nature of REST allows servers to quickly free resources & further simplifies implementation.
4. Cacheable: Responses can be cached, reducing load on the server & improving performance.
5. Platform-independent: REST is not tied to any specific platform or language, making it highly adaptable.

Disadvantages of RESTful APIs:

1. Lack of Standards: While REST guidelines exist, they leave a lot of room for interpretation & can lead to inconsistencies between implementations.
2. No state management: RESTful APIs are stateless, meaning each request must contain all necessary data, leading to repetitive data transmission & increased request overhead.
3. Increased Complexity for Complex Ops: RESTful APIs can become complex when dealing with non-CRUD (Create, Read, Update, Delete) operations.
4. Lack of Built-in Security Features: REST does not enforce any specific security mechanisms, leaving it up to the developers to implement them correctly.
5. Over/under-fetching: With REST, clients often fetch more data than needed (over-fetching) or make multiple requests to fetch all needed data (under-fetching).

23. How does SSL/TLS ensure secure communication over the internet?

SSL (Secure Sockets Layer) & its successor TLS (Transport Layer Security) are cryptographic protocols designed to provide secure communication over a computer network. They operate between the application layer & the transport layer.

SSL/TLS provides three key services:

• Encryption: Data in transit is encrypted, ensuring that if intercepted, it cannot be read. This uses symmetric encryption.
• Authentication: The identity of the communicating parties is authenticated using public-key cryptography. This ensures you're communicating with the intended party.
• Integrity: Message integrity is checked using a message authentication code (MAC). This detects if the data has been tampered with.

Here's how SSL/TLS works:

1. Handshake: The client & server negotiate the version of SSL/TLS, select cryptographic algorithms & authenticate each other using public-key techniques. They also generate shared secrets to establish a uniquely secure connection.
2. Key Exchange: The client & server exchange keys for symmetric encryption. The public-key encryption is used for this key exchange.
3. Secure Communication: With the handshake complete & keys exchanged, the client & server can now communicate securely using symmetric encryption.

24. Explain Big-O notation & its significance in algorithms.

Big-O notation is a mathematical notation used to describe the performance or complexity of an algorithm. It specifically describes the worst-case scenario & can be used to describe the execution time or the space used (e.g. in memory or on disk).

In Big-O notation, 'n' represents the size of the input, & the function G(n) is an arbitrary time complexity you're comparing the algorithm to. For example:

• O(1): Constant time. The algorithm always takes the same time regardless of the size of the input.
• O(n): Linear time. The execution time increases linearly with the size of the input.
• O(log n): Logarithmic time. The execution time increases by a constant factor for each doubling of the input size.
• O(n^2): Quadratic time. The execution time is proportional to the square of the input size.

Big-O is significant in algorithms because it allows us to compare the efficiency of different algorithms. It provides a common language to describe performance, independent of machine-specific details. The concept of Big-O is crucial because it helps predict how an algorithm will perform as the input grows larger. This is especially important for large-scale systems where efficiency is critical. It also helps developers make informed decisions about which algorithms to use for a given problem.

25. Explain the concept of paging & its benefits.

Paging is a memory management technique where the computer's main memory is divided into fixed-size blocks called "frames", & the program's virtual memory is divided into blocks of the same size called "pages". When a program needs data from virtual memory, pages are loaded into frames in main memory as needed.

Benefits of paging:

1. Efficient use of memory: Paging allows the system to load only the necessary parts of a program into main memory, leaving more space for other programs or data.
2. Faster memory access: Paging reduces fragmentation & allows for faster memory access, as each page can be loaded into any available frame.
3. Isolation: Each process gets its own page table, providing a level of isolation & protection from other processes.
4. Virtual memory: Paging is the foundation for implementing virtual memory, allowing programs to use more memory than is physically available.

26. Implement a function to merge two sorted linked lists.

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    // Create a dummy node to simplify the merging process
    struct ListNode dummy;
    struct ListNode* tail = &dummy;

    // Merge nodes from the two lists in sorted order
    while (l1 && l2) {
        if (l1->val < l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }

    // Append the remaining nodes of l1 or l2
    if (l1) {
        tail->next = l1;
    } else {
        tail->next = l2;
    }

    return dummy.next;
}

You can also try this code with Online C Compiler

Run Code

27. Explain process synchronization & its methods.

Process synchronization is the coordination of multiple processes to ensure right execution avoiding race conditions. It involves mechanisms to control the access of shared resources & maintain data consistency. This is necessary when lot of processes or threads access shared data concurrently to prevent data corruption or inconsistent results.

Methods of process synchronization:

1. Locks: A lock is a synchronization primitive that allows only one process or thread to enter a critical section at a time. It provides mutual exclusion & ensures that only the process holding the lock can access the shared resource.
2. Semaphores: Semaphores are integer variables used to control access to shared resources. They have two main operations: wait (decrement) & signal (increment). Semaphores can be used for both mutual exclusion & condition synchronization.
3. Monitors: Monitors are high-level synchronization constructs that encapsulate shared data & provide a set of methods to access & manipulate the data. They ensure that only one process or thread can execute a method on the monitor object at a time.
4. Message Passing: Message passing is a synchronization mechanism where processes or threads communicate by sending & receiving messages. It allows synchronization through the exchange of messages, which can include data & control information.
5. Barriers: Barriers are synchronization points where multiple processes or threads must wait until all of them reach the barrier. Once all processes have reached the barrier, they can proceed further, allowing for synchronization & coordination.

28. Implement a queue using two stacks.

class MyQueue:
    def __init__(self):
        self.stack1 = []  # main stack
        self.stack2 = []  # temporary stack

    def push(self, x: int) -> None:
        self.stack1.append(x)

    def pop(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        if self.stack2:
            return self.stack2.pop()

    def peek(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        if self.stack2:
            return self.stack2[-1]

    def empty(self) -> bool:
        return not self.stack1 and not self.stack2

You can also try this code with Online Python Compiler

Run Code

29. What is the difference between kernel-level threads & user-level threads?

Threads are units of execution within a process. They allow a program to perform multiple tasks concurrently. There are two main types of threads: kernel-level threads & user-level threads.

30. Write a program to find the maximum subarray sum.

#include <stdio.h>
#include <limits.h>

int maxSubarraySum(int arr[], int n) {
    int maxSum = INT_MIN;
    int currentSum = 0;

    for (int i = 0; i < n; i++) {
        currentSum += arr[i];
        
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
        
        if (currentSum < 0) {
            currentSum = 0;
        }
    }

    return maxSum;
}

int main() {
    int arr[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    int n = sizeof(arr) / sizeof(arr[0]);

    int maxSum = maxSubarraySum(arr, n);
    printf("The maximum subarray sum is: %d\n", maxSum);

    return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Kadane's algorithm has a time complexity of O(n), as it makes a single pass through the array. The space complexity is O(1), as it uses only a few variables regardless of the size of the input.

Conclusion

We hope you have gained some insights on IBM Interview Questions through this article. We understand that preparing for interviews can be nerve-wracking and hope these IBM Interview Questions will help you during your interviews and you learn and grow in your role!  

You can also practice coding questions commonly asked in interviews on Coding Ninjas Code360. 

Also, check out some of the Guided Paths on topics such as Data Structure and Algorithms, Competitive Programming, Operating Systems, Computer Networks, DBMS, System Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.