Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects," which are instances of classes. OOP allows developers to structure software in a more modular and reusable way. The four main principles of OOP are encapsulation, abstraction, inheritance, and polymorphism.

Encapsulation hides internal object details, exposing only necessary parts through methods. Abstraction simplifies complex systems by modeling classes appropriate to the problem. Inheritance allows one class to inherit properties and behaviors from another, promoting code reuse. Polymorphism enables a single function to behave differently based on the object calling it. OOP helps in managing complexity in large programs by dividing it into smaller, manageable units, making the codebase easier to develop, maintain, and scale.

A deadlock occurs when two or more processes are waiting for each other to release resources, but none ever do, causing them all to be stuck indefinitely. For deadlock to occur, four conditions must hold simultaneously: mutual exclusion, hold and wait, no preemption, and circular wait. For example, if Process A holds Resource 1 and waits for Resource 2, while Process B holds Resource 2 and waits for Resource 1, neither can proceed. Deadlocks can be prevented by avoiding one or more of the four conditions, detected through resource allocation graphs, or handled by recovering from them when they occur.

Operating systems may use strategies like timeout mechanisms, resource ordering, or a banker’s algorithm to avoid or manage deadlocks.

TCP (Transmission Control Protocol) is a connection-oriented protocol that ensures reliable communication through error checking, acknowledgments, and retransmissions. It guarantees that data is delivered in the correct order and without loss. This makes it suitable for applications like web browsing, email, and file transfers. In contrast, UDP (User Datagram Protocol) is connectionless and does not guarantee delivery, order, or error checking, making it faster and more lightweight.

It is commonly used for applications where speed is more important than reliability, such as video streaming, online gaming, and VoIP. While TCP focuses on reliability and congestion control, UDP is preferred for real-time data where occasional loss is acceptable but low latency is crucial.

A data structure is a specialized format for organizing, processing, and storing data to enable efficient access and modification. Common data structures include arrays, linked lists, stacks, queues, trees, and graphs. Each data structure has unique properties suited for specific types of operations and problems.

For instance, arrays allow fast access via indexing, while linked lists support dynamic memory allocation. Stacks and queues support LIFO and FIFO processing respectively. Trees and graphs represent hierarchical and networked data. The choice of data structure directly impacts algorithm performance in terms of time and space complexity. Understanding and choosing the right data structure is fundamental to solving computational problems effectively, optimizing system resources, and enhancing software scalability and maintainability.

Compilation and interpretation are two methods for executing programs written in high-level languages. A compiler translates the entire program into machine code before execution, producing an independent executable file. This approach results in faster execution but requires recompilation after code changes.

Examples include C and C++. An interpreter, in contrast, translates and executes code line-by-line at runtime, offering flexibility and ease of debugging. Examples include Python and JavaScript. Some languages like Java use both—first compiled into bytecode, then interpreted or run on a virtual machine. Compilation is generally better for performance, while interpretation is better for portability and development speed. The choice depends on application needs, runtime behavior, and development context.

Binary search is an efficient algorithm used to find an element in a sorted array or list. It works by repeatedly dividing the search interval in half. Initially, it compares the target value to the middle element. If the value matches, the search ends. If the target is smaller, the search continues in the left half; if larger, in the right half.

This process repeats until the element is found or the interval becomes empty. Binary search has a time complexity of O(log n), making it much faster than linear search (O(n)) for large datasets. However, it requires the data to be sorted beforehand, which can add overhead depending on the sorting algorithm used.

Recursion is a programming technique where a function calls itself to solve a problem. Each recursive call reduces the problem into smaller instances until reaching a base case, which terminates the recursion. It's widely used in problems that can be naturally divided into similar subproblems, like computing factorials, traversing trees, or solving the Tower of Hanoi. While recursion simplifies code and enhances readability, it must be used carefully to avoid infinite loops or stack overflows.

Recursive functions consume stack space for each call, making them memory-intensive. Some problems that use recursion can be optimized using techniques like memoization or converted to iteration to improve performance and reduce space complexity.

A hash table is a data structure that stores key-value pairs and provides fast access to values using a key. It uses a hash function to convert keys into indices in an underlying array, where the values are stored. This allows for average-case constant time complexity (O(1)) for search, insert, and delete operations. However, hash collisions can occur when multiple keys hash to the same index.

Collisions are handled using techniques like chaining (linked lists at each index) or open addressing (probing for the next empty slot). Hash tables are widely used in databases, caches, and associative arrays. The efficiency of a hash table depends on the quality of the hash function and the load factor.

Procedural programming focuses on procedures or routines (functions) that operate on data. It follows a top-down approach where code is executed sequentially and organized around procedures. Languages like C are procedural. In contrast, object-oriented programming (OOP) organizes code into objects that encapsulate both data and behaviors, supporting principles like inheritance, encapsulation, and polymorphism. OOP follows a bottom-up approach and promotes reusability, modularity, and maintainability. Java, Python, and C++ support OOP.

While procedural programming is simple and efficient for smaller tasks, OOP is better suited for large, complex systems that require modularity and scalability. The choice between the two depends on the problem domain, team expertise, and software design requirements.

Virtual memory is a memory management technique that gives an application the illusion of having contiguous and large memory, even if the physical memory is limited. It uses both the RAM and a section of the hard drive (called the page file or swap space) to store parts of processes. When the RAM is full, the operating system transfers inactive pages to disk, freeing up RAM for active processes.

This process is called paging. Virtual memory allows systems to run larger applications and more processes than physical memory alone would permit. However, excessive use of paging can lead to thrashing, where the system spends more time swapping than executing, degrading performance significantly.

Polymorphism is one of the key principles of object-oriented programming that allows objects of different classes to be treated as objects of a common superclass. It enables a single interface to be used for different data types or method implementations. There are two types: compile-time (method overloading) and runtime (method overriding) polymorphism. Compile-time polymorphism allows multiple methods with the same name but different parameters.

Runtime polymorphism involves subclass methods overriding superclass methods and is implemented using inheritance and dynamic method dispatch. Polymorphism enhances flexibility and reusability, allowing code to be more general and easier to maintain. It is heavily used in implementing interfaces and abstract classes in languages like Java and C++.

Caching is the process of storing frequently accessed data in a temporary storage area (cache) for faster retrieval. It improves application performance by reducing access time to slower data sources like databases, disk storage, or network responses. Caches can exist at various levels—hardware (CPU caches), software (browser or application caches), or distributed systems (web caching, CDN). When a request is made, the system checks the cache first; if the data is present (a cache hit), it returns it instantly, otherwise it fetches from the source (a cache miss).

Effective caching strategies like LRU (Least Recently Used) help manage limited cache space. Caching is vital in optimizing speed, reducing server load, and enhancing user experience in computing systems.

Multithreading is a programming technique that allows concurrent execution of two or more threads within a single process. Each thread represents a separate path of execution, sharing the process's memory space but having its own stack and execution context. This is especially useful in applications requiring parallelism, like handling multiple user requests in web servers or performing background tasks without freezing the main application. Operating systems use time-slicing or parallel processing (on multi-core CPUs) to switch between threads.

While multithreading improves resource utilization and performance, it introduces challenges like race conditions and deadlocks. Proper synchronization using locks, semaphores, or concurrent libraries is essential to ensure data consistency and avoid conflicts.

Static typing means that variable types are checked at compile-time, while dynamic typing checks types at runtime. In statically typed languages like Java, C++, or C#, variables must be declared with a type, and type-related errors are caught early during compilation. This provides better performance and reduces runtime errors. Dynamically typed languages like Python, JavaScript, or Ruby allow variables to hold values of any type and determine the type during execution.

This allows more flexibility and concise code but can lead to runtime errors if type mismatches occur. Static typing supports tools like auto-completion and refactoring more effectively, while dynamic typing facilitates rapid development and scripting. The choice depends on application needs and developer preference.

BFS (Breadth-First Search) and DFS (Depth-First Search) are graph traversal algorithms with different strategies. BFS explores neighbors level by level, using a queue data structure. It is ideal for finding the shortest path in unweighted graphs and systematically explores all vertices. DFS dives deep into one branch using a stack (or recursion) before backtracking. DFS is useful for detecting cycles, topological sorting, and solving puzzles.

BFS uses more memory in wide graphs, while DFS can get stuck in deep or infinite paths without cycle detection. Both algorithms have time complexity of O(V + E), where V is vertices and E is edges. The choice depends on the structure of the graph and the problem requirements.

An operating system (OS) is system software that manages hardware resources and provides services for application software. It acts as an intermediary between users and hardware. Key functions include process management, memory management, file systems, device control, security, and user interfaces. It schedules tasks, allocates resources, manages files and directories, and ensures secure access to data. Common types of operating systems include batch, multitasking, real-time, distributed, and embedded systems. Examples are Windows, Linux, macOS, and Android.

A well-designed OS provides abstraction layers to hide hardware complexity, allowing users and applications to interact with the system in a user-friendly way. Without an OS, it would be nearly impossible to use computers effectively.

Overloading and overriding are two techniques for achieving polymorphism in Java. Method overloading occurs when multiple methods in the same class share the same name but differ in parameters (type, number, or order). It is resolved at compile-time, making it a form of compile-time polymorphism. Method overriding happens when a subclass provides a specific implementation of a method already defined in its superclass, using the same name, return type, and parameters. It is resolved at runtime and supports dynamic polymorphism.

Overloading increases code flexibility within a class, while overriding allows customized behavior in subclassing. Both techniques enhance code reusability and maintainability in object-oriented programs, but serve distinct purposes in Java.

A compiler translates the entire source code of a program into machine code at once, generating an executable file that can be run multiple times without recompilation. It performs syntax analysis, optimization, and error checking before generating the binary output. Examples include C and C++. An interpreter, on the other hand, translates and executes the code line by line at runtime without producing a separate executable.

Python and JavaScript are interpreted languages. Interpreters offer more flexibility and ease of debugging, but are generally slower due to the lack of precompiled code. Some languages like Java use a hybrid approach: code is compiled into bytecode and then interpreted or executed by a virtual machine.

An API (Application Programming Interface) is a set of defined rules that allow software applications to communicate with each other. It provides a way for developers to access functionality from another application, service, or system without needing to know its internal implementation. APIs can be public (open to external developers) or private (used internally). RESTful APIs, based on HTTP, are common in web services, while other types include SOAP, GraphQL, and WebSocket. APIs enable modular development, integration with third-party services, and automation.

They play a crucial role in microservices architecture, mobile app backends, and cloud computing. Well-designed APIs are reusable, secure, and scalable, making them essential for building modern, distributed software systems.

Dynamic programming (DP) is an optimization technique used to solve complex problems by breaking them down into simpler overlapping subproblems and storing the results of these subproblems to avoid redundant computations. It is widely applied in problems involving optimal substructure, such as Fibonacci series, shortest path algorithms, and knapsack problems. DP uses either top-down (memoization) or bottom-up (tabulation) approaches. Memoization involves recursion with caching, while tabulation uses iteration with a table to build solutions.

DP improves time complexity significantly compared to naive recursive methods, often reducing exponential problems to polynomial time. It is essential in algorithm design and is tested frequently in coding interviews to evaluate a candidate’s problem-solving efficiency and optimization skills.

A semaphore is a synchronization primitive used in operating systems and concurrent programming to manage access to shared resources. It is an integer variable that controls access through two atomic operations: wait (also known as P or down) and signal (also known as V or up). When a process executes a wait, the semaphore value is decremented; if it becomes negative, the process blocks.

When signal is called, the value is incremented and a blocked process may resume. Semaphores can be binary (value 0 or 1) or counting (allowing multiple accesses). They prevent race conditions and ensure mutual exclusion in critical sections. Proper semaphore use avoids problems like deadlocks and starvation in concurrent environments.

Synchronous programming executes tasks sequentially—each task waits for the previous one to complete. This can lead to blocking behavior, especially in I/O operations, reducing efficiency. Asynchronous programming allows tasks to run independently of each other, enabling the program to handle other operations while waiting for a task to complete. It’s commonly used in network requests, file handling, or long-running computations to improve responsiveness and performance. Asynchronous code often uses callbacks, promises, or async/await syntax, depending on the language.

While async programming is powerful, it can introduce complexity in error handling and control flow. It’s essential in web development, real-time systems, and concurrent applications to ensure smooth and efficient execution.

A race condition occurs when two or more threads access shared data concurrently and try to change it at the same time. If the execution sequence is not properly controlled, the final outcome may vary and lead to unpredictable behavior or bugs. For example, two threads updating the same counter without synchronization might both read the same value before updating, resulting in incorrect results. Race conditions are notoriously difficult to debug due to their non-deterministic nature.

They can be prevented using synchronization mechanisms such as mutexes, semaphores, locks, or atomic variables. Ensuring thread safety in critical sections of code is crucial in multithreaded and concurrent applications to maintain data consistency.

Garbage collection is an automatic memory management process used in languages like Java, C#, and Python. It identifies and reclaims memory that is no longer in use by the program, preventing memory leaks and improving performance. In Java, the JVM periodically runs a garbage collector that tracks object references; when it finds objects that are unreachable, it frees their memory. Garbage collection relieves developers from manually deallocating memory, reducing bugs related to memory management.

However, it can introduce pauses during execution, known as "stop-the-world" events. Various garbage collection algorithms exist, such as mark-and-sweep, generational, and G1, each balancing speed and memory efficiency. Proper understanding ensures developers write efficient, memory-safe applications.

A finite state machine is a computational model consisting of a finite number of states, transitions between those states, and actions. It starts in an initial state and changes to other states based on inputs. FSMs are used to model behavior in systems with a limited number of defined conditions, such as vending machines, traffic lights, parsers, and game logic. There are two types: deterministic (each input leads to one state) and non-deterministic (inputs may lead to multiple states).

FSMs are easy to implement and visualize, making them useful in embedded systems, compilers, and user interface design. They help developers ensure predictable behavior by clearly defining how a system responds to various events.