Top 30 Technical interview questions

C
O
D
E
R
S
.
S
T
O
P
Ace Your Next
Interview:
Top 30 Technical Interview
Questions
to Master
By
CODERS.STOP

C
O
D
E
R
S
.
S
T
O
P
1. What is object-oriented programming?
Object-oriented programming (OOP) is a programming paradigm that uses
objects, which are instances of classes, to represent and manipulate data.
OOP emphasises on organising code into reusable and modular
components, which can interact with each other through defined interfaces.
In OOP, classes define the attributes (data) and methods (functions) that an
object can have. Objects can then be created from these classes, allowing
the code to operate on the data and execute the methods. OOP provides
encapsulation, inheritance, and polymorphism to enable developers to write
efficient and modular code that can be easily maintained and extended.
Encapsulation refers to the process of hiding the complexity of the internal
workings of an object and exposing only the necessary features to the
outside world. Inheritance enables the creation of new classes by
inheriting properties and methods from existing classes. Polymorphism
allows multiple objects to share the same interface or method name, but
each object may have its own unique implementation.
OOP has become a popular approach to software development because of
its ability to create code that is flexible, modular, and easy to maintain.
Many programming languages, including Java, C++, and Python, support
OOP.
2. What is the difference between an abstract class and an
interface?
Both abstract classes and interfaces are used to define contracts that
concrete classes must follow, but they have some key differences in their
design and usage:
Implementation: An abstract class can have some implementation details,
while an interface cannot have any implementation. Abstract classes can
have both abstract and non-abstract methods, whereas interfaces can only
have abstract methods.

C
O
D
E
R
S
.
S
T
O
P
Inheritance: A class can inherit only one abstract class, while it can
implement multiple interfaces. Inheritance is a "is-a" relationship, whereas
interface implementation is a "has-a" relationship.
Access modifiers: Abstract classes can have public, protected, and
private members, while interfaces can only have public members.
Constructors: Abstract classes can have constructors, while interfaces
cannot.
Extension: Abstract classes can be extended to add new functionality,
while interfaces cannot be extended. Instead, new interfaces must be
created to add new functionality.
Use cases: Abstract classes are used when creating a class hierarchy,
where concrete classes inherit from a common abstract class. Interfaces
are used when defining contracts that multiple classes can implement,
even if they are unrelated by inheritance.
In summary, abstract classes are used when creating a class hierarchy and
providing a partial implementation, while interfaces are used when defining
contracts for unrelated classes to implement.
3. What is polymorphism?
Polymorphism is the ability of objects of different types to be treated as if
they are the same type, through a common interface or method. It allows
multiple objects of different classes to be treated as if they were of the
same class, which can make code more flexible, modular, and reusable.
Polymorphism can take different forms, including method overloading,
method overriding, and interface implementation.
Method overloading occurs when a class has multiple methods with the
same name, but different parameters. This allows the programmer to use
the same method name with different arguments, which can improve
readability and reduce the number of method names needed.

C
O
D
E
R
S
.
S
T
O
P
Method overriding occurs when a subclass provides its own implementation
of a method that is already defined in its superclass. This allows the
subclass to change or extend the behaviour of the method, while still
maintaining the same interface.
Interface implementation occurs when a class implements one or more
interfaces, which requires the class to define all the methods declared in
the interface. This allows multiple classes to implement the same interface
and be treated as if they are of the same type.
Polymorphism is a fundamental concept in object-oriented programming
and is essential for creating code that is reusable, modular, and easy to
maintain.
4. What is inheritance, and how does it work?
Inheritance is a mechanism in object-oriented programming that allows a
class (called the "subclass" or "derived class") to inherit properties and
methods from another class (called the "superclass" or "base class"). The
subclass can then extend or modify the inherited properties and methods or
add new ones.
Inheritance works by creating a class hierarchy, where the subclasses
inherit from the superclass. The superclass is declared first, and then the
subclasses are declared with the "extends" keyword followed by the
superclass name. The subclass automatically inherits all the non-private
properties and methods of the superclass.
For example, consider a superclass "Animal" with properties like "name"
and "age" and methods like "eat" and "sleep". A subclass "Cat" can inherit
these properties and methods from the Animal class and add its own
properties and methods like "purr" and "meow". Similarly, a subclass "Dog"
can inherit from the Animal class and add its own methods like "bark" and
"fetch".

C
O
D
E
R
S
.
S
T
O
P
Inheritance provides code reusability and helps to organize classes into a
hierarchy of related classes. It also helps to reduce code duplication and
makes code more maintainable and extensible. However, it should be used
judiciously, as excessive use of inheritance can lead to complex class
hierarchies and make code harder to understand and maintain.
5. What is a design pattern and give an example?
A design pattern is a general repeatable solution to a commonly occurring
problem in software design. It represents the best practices evolved over
time by experienced software developers.
Design patterns provide a common vocabulary, a shared set of concepts
and guidelines, and a framework for designing reusable and maintainable
software systems. By following design patterns, developers can reduce the
time and effort required to design and implement software solutions,
improve the quality of the software, and make the software more flexible
and adaptable to changing requirements.
Some examples of design patterns include:
Singleton pattern: This pattern ensures that a class has only one instance
and provides a global point of access to it. This can be useful in situations
where only one instance of a class is required, such as a configuration
manager or a database connection.
Factory pattern: This pattern provides an interface for creating objects, but
allows subclasses to decide which classes to instantiate. This can be useful
when there are many classes that implement a common interface, and the
exact class to be used is determined at runtime.
Observer pattern: This pattern defines a one-to-many relationship
between objects, where one object (the subject) notifies other objects (the
observers) when its state changes. This can be useful when there are
multiple objects that need to be notified when a change occurs, such as a
user interface that needs to be updated when data changes.

C
O
D
E
R
S
.
S
T
O
P
Decorator pattern: This pattern allows behaviour to be added to an
individual object, either statically or dynamically, without affecting the
behaviour of other objects from the same class. This can be useful when
there are many variations of a class, and it is not practical to create a
subclass for each variation.
These are just a few examples of the many design patterns available.
Design patterns are an important tool for software developers, as they
provide a proven approach to solving common problems in software
design.
6. What is data normalisation and why is it important?
Data normalisation is the process of organising data in a database in a way
that reduces redundancy and improves data integrity. It involves breaking
down larger tables into smaller, more specialised tables and defining
relationships between them.
Normalisation is important for several reasons:
Reducing data redundancy: When data is duplicated across multiple
tables, it can lead to inconsistencies and errors. By normalising data, each
piece of information is stored only once, reducing the risk of errors and
making it easier to update data.
Improving data integrity: Normalisation helps to ensure that data is
accurate and consistent by enforcing rules and constraints on how data is
stored and updated.
Simplifying queries: When data is normalised, queries can be simpler and
more efficient. Instead of searching through large, complex tables, queries
can be focused on specific tables with a smaller set of data.
Improving database performance: Normalisation can also improve
database performance by reducing the amount of data that needs to be
queried and stored. This can lead to faster search times and more efficient
use of storage resources.

C
O
D
E
R
S
.
S
T
O
P
There are several levels of data normalisation, with each level introducing
more rules and constraints on how data is stored. The most commonly
used levels are first normal form (1NF), second normal form (2NF), and
third normal form (3NF).
Overall, data normalisation is an important step in creating a well-designed
database that is efficient, accurate, and easy to use.
7. What is SQL injection and how can it be prevented?
SQL injection is a type of cyber attack in which an attacker uses malicious
SQL code to gain unauthorised access to a database. It typically involves
exploiting vulnerabilities in a web application that allows an attacker to
inject SQL code into the application's input fields.
SQL injection attacks can have serious consequences, including theft of
sensitive data, unauthorised access to systems, and potential damage to
the reputation of an organisation.
To prevent SQL injection attacks, it is important to take the following steps:
Use parameterized queries: Parameterized queries use placeholders for
user input and separate the SQL code from the user input, making it harder
for attackers to inject malicious code.
Validate user input: Input validation is an important step in preventing
SQL injection attacks. Applications should validate user input to ensure that
it conforms to expected data types and lengths.
Limit user privileges: It is important to limit the privileges of users and
applications to prevent unauthorised access to the database.
Use a web application firewall: A web application firewall can help detect
and prevent SQL injection attacks by monitoring incoming traffic and
blocking suspicious activity.

C
O
D
E
R
S
.
S
T
O
P
Keep software up-to-date: It is important to keep software up-to-date with
the latest security patches and updates to reduce the risk of vulnerabilities
that can be exploited by attackers.
By taking these steps, organisations can reduce the risk of SQL injection
attacks and protect their data and systems from unauthorised access.
8. What is a primary key and foreign key in a database?
A primary key is a field in a database table that uniquely identifies each row
in that table. It is used to enforce the integrity of the data by ensuring that
each row has a unique identifier. A primary key can be made up of one or
more fields, and it cannot contain null values.
A foreign key is a field in one table that refers to the primary key in another
table. It is used to establish a relationship between two tables, and it is
used to enforce referential integrity. This means that the foreign key in one
table must match a primary key in another table, or the operation will fail.
For example, if you have two tables in a database, one for customers and
one for orders, you might use a customer ID field as the primary key in the
customers table. In the orders table, you would use a foreign key that
references the customer ID field in the customers table. This establishes a
relationship between the two tables, so you can easily retrieve all orders for
a given customer.
Primary keys and foreign keys are important for maintaining the integrity of
data in a database. They help ensure that data is entered correctly and
consistently, and they make it easier to retrieve and update data.
9. What is a linked list and how does it work?
A linked list is a data structure used in computer science to store a
collection of elements. It consists of a sequence of nodes, each containing
a value and a pointer to the next node in the list.

C
O
D
E
R
S
.
S
T
O
P
The first node in the list is called the head node, and the last node is called
the tail node. Each node contains a value and a pointer to the next node in
the list. If a node does not have a next node, its pointer value is null.
To add a new element to a linked list, you create a new node with the
element's value and set the pointer of the previous node to point to the new
node. If the new node is the first node in the list, you set the head node to
point to the new node. To remove an element from a linked list, you update
the pointers of the previous and next nodes to point to each other,
effectively removing the node from the list.
Linked lists have several advantages and disadvantages. One advantage is
that they can grow and shrink dynamically, making them efficient for certain
types of operations. Another advantage is that they can be easily
manipulated with pointer operations. However, linked lists can be slower
than arrays for accessing individual elements, and they require more
memory due to the overhead of storing pointers.
Overall, linked lists are a useful data structure for certain types of
operations, such as inserting and deleting elements, and they are
commonly used in programming languages and computer science
applications.
10. What is the difference between stack and queue data
structures?
Stack and queue are two common data structures used in computer
science to store collections of elements. The main difference between
stack and queue is the order in which elements are added and removed
from the data structure.
In a stack, elements are added and removed from the top of the stack. This
means that the last element added to the stack is the first one to be
removed. This is commonly referred to as a last-in, first-out (LIFO)

C
O
D
E
R
S
.
S
T
O
P
structure. Stacks are often used to implement undo/redo functionality, or for
parsing expressions and evaluating them in reverse order.
In contrast, in a queue, elements are added to the back of the queue and
removed from the front of the queue. This means that the first element
added to the queue is the first one to be removed. This is commonly
referred to as a first-in, first-out (FIFO) structure. Queues are often used in
situations where the order of processing is important, such as in job
scheduling or message processing systems.
To summarise, the main difference between stack and queue data
structures is the order in which elements are added and removed. Stacks
are LIFO structures where elements are added and removed from the top,
while queues are FIFO structures where elements are added to the back
and removed from the front.
11. What is recursion and how does it work?
Recursion is a technique in computer programming where a function calls
itself to solve a problem by breaking it down into smaller and simpler
subproblems.
The general idea behind recursion is to solve a problem by breaking it
down into smaller, simpler versions of the same problem. The function
continues to call itself with the smaller subproblem until the subproblem
becomes simple enough to be solved directly. Then the function returns the
solution for the subproblem to the calling function, which combines it with
other solutions to solve the original problem.
Recursion has two main parts: the base case and the recursive case.
The base case is the simplest version of the problem that can be solved
directly without calling the function again. The recursive case is where the
function calls itself with a smaller version of the original problem.
It is important to have a base case to avoid an infinite loop where the
function keeps calling itself without making any progress toward the

C
O
D
E
R
S
.
S
T
O
P
solution. Without a base case, the function would continue to call itself
indefinitely and eventually lead to a stack overflow error.
Some common examples of recursive algorithms include calculating
factorial, computing Fibonacci numbers, and traversing binary trees.
Recursion can be a powerful tool in programming, but it can also be difficult
to debug and understand. It is important to use it judiciously and make sure
to include a base case and check for potential stack overflow errors.
12. What is a binary search algorithm and how does it work?
A binary search algorithm is a method for finding the position of a target
value in a sorted array or list of elements. It works by repeatedly dividing
the search interval in half until the target value is found or determined to be
not in the list.
The binary search algorithm works as follows:
● Given a sorted array or list of elements, start with the middle element.
● If the middle element is equal to the target value, the search is
complete, and the position of the target value is returned.
● If the target value is less than the middle element, discard the right
half of the list and repeat step 1 with the left half of the list.
● If the target value is greater than the middle element, discard the left
half of the list and repeat step 1 with the right half of the list.
● If the target value is not found, the algorithm returns a special value
indicating that the target value is not in the list.
● This process of dividing the search interval in half is repeated until the
target value is found or the search interval is empty. The binary
search algorithm has a time complexity of O(log n), which makes it
much more efficient than linear search for large arrays or lists.
However, binary search requires that the array or list be sorted beforehand,
which can take additional time and space. Additionally, the algorithm may
not be suitable for certain types of data structures, such as linked lists.

C
O
D
E
R
S
.
S
T
O
P
13. What is the difference between a compiler and an
interpreter?
A compiler and an interpreter are two different types of software programs
used in computer programming to convert source code into executable
code that can be run on a computer.
A compiler is a program that converts the entire source code into an
executable file all at once. It translates the source code into machine code,
which can be executed directly by the computer's processor. Once
compiled, the executable file can be run multiple times without the need for
recompilation unless changes are made to the source code. Examples of
compiled languages include C, C++, and Java.
An interpreter, on the other hand, is a program that reads and executes the
source code line by line. It translates each line of code into machine code
and executes it immediately. This means that the program does not need to
be compiled before it can be run, but it also means that the interpreter
needs to do the translation and execution for each line of code every time
the program is run. Examples of interpreted languages include Python,
JavaScript, and Ruby.
The main difference between a compiler and an interpreter is in how they
translate and execute the source code. A compiler translates the entire
source code into machine code before the program is run, while an
interpreter translates and executes each line of code as the program runs.
This can result in differences in performance, with compiled programs
generally running faster than interpreted programs. However, interpreted
programs offer greater flexibility and ease of use, as they do not require
compilation and can be run on any platform with an interpreter installed.
14. What is the difference between a thread and a process?
A process and a thread are both ways to execute code in a computer
program, but they differ in several important ways.
A process is a container for a set of resources needed to execute a
program, including memory space, system resources, and other operating

C
O
D
E
R
S
.
S
T
O
P
system resources. A process can be thought of as an instance of a
program that is being executed. Each process has its own memory space,
and processes communicate with each other through inter-process
communication mechanisms such as shared memory or message passing.
Each process has its own unique process ID (PID), which is used to
manage and track it by the operating system. Processes are heavy-weight
entities and require more resources to be created and managed.
A thread, on the other hand, is a lightweight unit of execution within a
process. A process can have multiple threads, and each thread shares the
same memory space as the other threads in the process. Threads are used
to perform multiple tasks simultaneously within a single process. Each
thread has its own program counter, stack, and register set, but shares the
same memory space as other threads in the process. Threads are
light-weight entities and require less resources to be created and managed.
Some key differences between threads and processes include:
Memory space: Processes have their own memory space, while threads
share the same memory space within a process.
Resource usage: Processes require more resources to be created and
managed, while threads are lightweight and require less resources.
Communication: Processes communicate with each other through
inter-process communication mechanisms, while threads can communicate
with each other directly within the same process.
Protection: Processes are protected from each other and cannot access
each other's memory directly, while threads share the same memory space
and can access each other's memory directly.
Overall, processes and threads are both important concepts in computer
programming and are used to achieve different goals. Processes are used
to isolate and protect different instances of a program, while threads are
used to perform multiple tasks simultaneously within a single program.

C
O
D
E
R
S
.
S
T
O
P
15. What is a deadlock and how can it be prevented?
Deadlock is a situation in computer programming where two or more
processes or threads are blocked and unable to proceed because they are
waiting for each other to release resources that they need. This can lead to
a situation where the processes or threads are effectively stuck and unable
to make any further progress, causing the program to become
unresponsive.
There are several conditions that must be met for a deadlock to occur,
including mutual exclusion, hold and wait, no preemption, and circular wait.
These conditions can be prevented or eliminated through various
techniques, including:
Resource allocation: One way to prevent deadlock is to use resource
allocation techniques such as bankers' algorithm, which ensures that
resources are allocated in a way that prevents deadlock from occurring.
Avoidance: Another way to prevent deadlock is to use avoidance
techniques that identify potential deadlocks before they occur and take
steps to avoid them. This can be done by carefully managing resource
allocation and scheduling to prevent conflicting requests for resources.
Detection and recovery: Another technique is to detect deadlocks when
they occur and take steps to recover from them. This can involve releasing
resources, aborting processes or threads, or taking other corrective
actions.
Preemption: Another way to prevent deadlock is to use preemption
techniques, which allow resources to be forcibly taken away from
processes or threads that are holding them. This can be done in a
controlled way to ensure that deadlock does not occur.
Overall, preventing and managing deadlocks requires careful planning and
management of resources and processes within a program. By taking
proactive steps to prevent deadlock, such as using resource allocation,
avoidance, detection, recovery, or preemption techniques, developers can

C
O
D
E
R
S
.
S
T
O
P
ensure that their programs remain stable and responsive, even when faced
with complex resource allocation challenges.
16. What is an API and how does it work?
An API (Application Programming Interface) is a set of protocols, routines,
and tools used to build software applications. It defines the rules and
standards for communication between different software components,
enabling them to interact and exchange information.
APIs typically provide a set of functions or methods that other software
components can call or use to perform certain tasks. For example, a social
media platform may offer an API that allows third-party developers to
access user data and perform certain actions on behalf of the user, such as
posting updates or retrieving information.
When a software component wants to use an API, it sends a request to the
API specifying what action it wants to perform. The API then processes the
request, retrieves the necessary data or resources, and sends a response
back to the requesting component. The requesting component can then
use the data or resources returned by the API to perform its intended task.
APIs can be used to integrate different software systems, provide access to
data and functionality to third-party developers, or create more modular and
flexible software architectures. They are an essential part of modern
software development and enable developers to build complex applications
more quickly and efficiently by leveraging existing resources and services.
17. What is a RESTful API?
A RESTful API is a type of API that uses HTTP requests to access and use
web services. REST stands for Representational State Transfer, which is a
set of architectural principles that are used to create web services.
In a RESTful API, the server provides access to resources using a
standard set of HTTP methods such as GET, POST, PUT, DELETE, etc.
These methods are used to create, read, update, and delete resources

C
O
D
E
R
S
.
S
T
O
P
over the web. The resources are represented by URLs, which can be
accessed using standard HTTP requests.
One of the key principles of RESTful APIs is that they are stateless,
meaning that each request contains all the information needed to complete
the request, and no additional context or state is stored on the server. This
makes RESTful APIs highly scalable and easy to maintain.
Another important principle of RESTful APIs is that they use a uniform
interface, meaning that they use standard HTTP methods, status codes,
and message formats. This makes it easier for developers to understand
and use the API.
Overall, RESTful APIs are widely used for web services and are a popular
way to build APIs due to their simplicity, scalability, and flexibility.
18. What is the difference between TCP and UDP protocols?
TCP (Transmission Control Protocol) and UDP (User Datagram Protocol)
are both transport layer protocols that are used to send data over the
internet. However, they have some fundamental differences in their
operation and functionality.
TCP is a connection-oriented protocol that ensures reliable data transfer. It
establishes a connection between the sender and receiver and uses a
three-way handshake to establish the connection before data is
transmitted. Once the connection is established, data is sent in packets that
are reassembled in the correct order at the receiving end. TCP ensures
that all packets are received and retransmits any lost packets, making it
reliable but slower than UDP. TCP is commonly used for applications that
require reliable data transfer, such as email, file transfers, and web
browsing.
UDP is a connectionless protocol that does not establish a connection
before transmitting data. Instead, data is sent in packets or datagrams that
are not guaranteed to arrive at their destination or arrive in the correct
order. UDP is faster and more efficient than TCP, making it suitable for

C
O
D
E
R
S
.
S
T
O
P
applications that require speed and efficiency over reliability, such as online
gaming, streaming, and voice and video chat.
In summary, TCP is a reliable protocol that establishes a connection and
ensures all data is received, while UDP is faster and more efficient but not
as reliable since it does not establish a connection and does not guarantee
all data will be received. The choice between TCP and UDP depends on
the specific needs of the application, with reliability being the main trade-off
against speed and efficiency.
19. What is the difference between a web server and
application server?
A web server and an application server are both types of server software
used to serve content and applications over the internet, but they have
different functions and capabilities.
A web server is a software program that handles HTTP requests from web
clients such as browsers and serves web pages or other content in
response. Its primary function is to serve static content, such as HTML
pages, images, and other files, from a file system or a cache. Examples of
web servers include Apache, Nginx, and Microsoft IIS.
An application server, on the other hand, is a software platform that
provides a runtime environment for applications, allowing them to run and
execute code in response to requests. Application servers are designed to
handle dynamic content and provide features such as load balancing,
clustering, and failover. They can also handle database access, transaction
management, security, and other advanced features required by enterprise
applications. Examples of application servers include JBoss, WebSphere,
and WebLogic.
In summary, a web server is focused on serving static content over the
web, while an application server is designed to handle dynamic content and
provide a runtime environment for applications. Both types of servers are
important in web development and are often used together to provide a
complete solution.

C
O
D
E
R
S
.
S
T
O
P
20. What is caching and how does it work?
Caching is a technique used to store frequently accessed data or resources
in a temporary storage area or cache, which can be accessed more quickly
than retrieving the data or resources from their original source. The
purpose of caching is to reduce the time and resources required to access
and deliver data, resulting in faster and more efficient performance.
Caching works by storing a copy of the data or resource in a cache when it
is first accessed. When subsequent requests are made for the same data
or resource, the cache is checked first, and if the data is found in the
cache, it is retrieved from the cache rather than from the original source.
This reduces the time and resources required to access and deliver the
data.
There are several types of caching, including:
Browser caching: where a browser stores frequently accessed web pages
and resources locally on the user's device.
Server caching: where a server stores frequently accessed data or
resources in a cache on the server itself.
Content Delivery Network (CDN) caching: where a network of servers
distributed around the world caches frequently accessed web pages and
resources to deliver them more quickly to users.
Caching is used extensively in web development to improve performance
and reduce server load. However, it is important to implement caching
carefully and intelligently to avoid issues such as stale content, inconsistent
data, and security vulnerabilities.
21. What is cloud computing and its types?
Cloud computing is a technology that enables users to access computing
resources such as servers, storage, applications, and services over the
internet. Rather than maintaining their own physical infrastructure, users

C
O
D
E
R
S
.
S
T
O
P
can rent or lease resources from a cloud service provider on a
pay-as-you-go basis, scaling up or down as needed.
There are three main types of cloud computing:
Infrastructure as a Service (IaaS): In this type of cloud computing, the
cloud service provider offers virtualized computing resources such as
servers, storage, and networking to users over the internet. Users can rent
or lease these resources and install their own operating systems,
applications, and software. Examples of IaaS providers include Amazon
Web Services (AWS), Microsoft Azure, and Google Cloud Platform.
Platform as a Service (PaaS): In this type of cloud computing, the cloud
service provider offers a platform or environment for users to build,
develop, and deploy their own applications without worrying about the
underlying infrastructure. The provider manages the infrastructure and
operating systems, and users can focus on developing and deploying their
own applications. Examples of PaaS providers include Heroku, Google App
Engine, and Microsoft Azure.
Software as a Service (SaaS): In this type of cloud computing, the cloud
service provider offers software applications and services over the internet,
eliminating the need for users to install and run the software on their own
devices. Users can access the software through a web browser or a mobile
app, and the provider manages the underlying infrastructure and
maintenance. Examples of SaaS providers include Salesforce, Microsoft
Office 365, and Dropbox.
Cloud computing offers several benefits, including scalability,
cost-effectiveness, flexibility, and improved performance and reliability.
However, it also poses some challenges, such as security and privacy
concerns, vendor lock-in, and potential downtime or service interruptions.

C
O
D
E
R
S
.
S
T
O
P
22. What is the difference between virtualization and
containerization?
Virtualization and containerization are both technologies used to abstract
and manage computing resources, but they differ in how they accomplish
this goal.
Virtualization is a technology that enables multiple virtual machines (VMs)
to run on a single physical machine by abstracting the underlying hardware
and creating a virtualized environment for each VM. Each VM can run its
own operating system, applications, and software, and is isolated from
other VMs running on the same physical machine. This allows multiple
operating systems and applications to run on a single physical machine,
improving resource utilisation and flexibility.
Containerization, on the other hand, is a technology that enables multiple
containers to run on a single operating system by abstracting the operating
system and creating a lightweight, isolated environment for each container.
Unlike VMs, containers share the same operating system kernel, which
makes them lighter and more efficient than VMs. Each container runs its
own applications and software, but shares the underlying operating system
and other resources with other containers running on the same host.
The main differences between virtualization and containerization are:
Resource utilisation: Virtualization allows multiple operating systems and
applications to run on a single physical machine, improving resource
utilisation. Containerization allows multiple containers to run on a single
operating system, improving resource utilisation even further.
Isolation: Virtualization provides strong isolation between VMs, since each
VM has its own operating system and is isolated from other VMs.
Containerization provides weaker isolation between containers, since they
share the same operating system and other resources with other
containers running on the same host.
Flexibility: Virtualization provides greater flexibility, since each VM can run
its own operating system and software. Containerization provides less

C
O
D
E
R
S
.
S
T
O
P
flexibility, since containers share the same operating system and must use
the same kernel version.
Both virtualization and containerization have their own advantages and
disadvantages, and the choice between them depends on the specific use
case and requirements.
23. What is Git and how does it work?
Git is a version control system that allows developers to track and manage
changes to their source code. It was created by Linus Torvalds in 2005 to
manage the development of the Linux kernel. Git is a distributed version
control system, which means that each user has a complete copy of the
repository on their local machine.
Here's how Git works:
Create a repository: The first step is to create a Git repository, which is a
directory that Git will use to track changes to your code.
Add files: Once you have created a repository, you can add files to it. Git
tracks changes to files, so it is important to add all the files you want to
manage to the repository.
Make changes: After you have added files to the repository, you can start
making changes to them. Git tracks changes to files on a line-by-line basis,
so it can detect changes at a very fine-grained level.
Commit changes: When you are ready to save your changes, you need to
commit them to the repository. A commit is a snapshot of the changes you
have made since the last commit.
Push changes: Once you have committed your changes, you can push
them to a remote repository. This is typically done on a server that other
developers can access.

C
O
D
E
R
S
.
S
T
O
P
Pull changes: If other developers have made changes to the remote
repository, you can pull those changes down to your local repository. This
ensures that everyone is working with the latest version of the code.
Git provides a number of tools for managing the version control process,
including branching and merging. Branching allows you to create separate
versions of the codebase, which can be used for different purposes, such
as testing new features. Merging allows you to bring changes from one
branch into another, which is useful when you want to incorporate changes
made by other developers.
24. What is the difference between a unit test and integration
test?
A unit test and an integration test are two types of software testing that
serve different purposes in the software development process.
A unit test is a type of test that focuses on verifying the functionality of a
single unit of code, such as a function or method. The purpose of a unit test
is to test the code in isolation from the rest of the system, using mock
objects or other techniques to replace any dependencies that the code may
have. The goal of unit testing is to catch bugs early in the development
process, so that they can be fixed quickly and easily.
An integration test, on the other hand, is a type of test that focuses on
verifying the interactions between different units of code or different
components of the system. Integration tests are typically used to test the
system as a whole, and are designed to ensure that all the different parts of
the system are working together as expected. Integration testing is usually
done after unit testing, and is often performed on a staging or test
environment that closely resembles the production environment.
In summary, the main difference between a unit test and an integration test
is the level of granularity they operate on. Unit tests focus on testing
individual units of code in isolation, while integration tests test the

C
O
D
E
R
S
.
S
T
O
P
interactions between different components or units of code to ensure that
they work together correctly.
25. What is Continuous Integration and Continuous
Deployment (CI/CD)?
Continuous Integration and Continuous Deployment (CI/CD) is a set of
practices and tools that automate the process of building, testing, and
deploying software applications. The goal of CI/CD is to improve the speed,
reliability, and quality of software development by automating the entire
process from code changes to deployment.
Continuous Integration (CI) is the practice of merging code changes from
multiple developers into a shared repository and building and testing the
code automatically on a regular basis. The purpose of CI is to catch and fix
errors in the code as early as possible, so that they do not propagate to
later stages of the development process.
Continuous Deployment (CD) is the practice of automatically deploying the
built and tested code to production after passing all tests and quality
checks. The purpose of CD is to make the deployment process faster, more
reliable, and more consistent.
Together, CI/CD creates a continuous feedback loop that enables
developers to quickly and confidently deliver high-quality software to users.
It also helps to reduce the risk of errors and downtime in production
environments, since the automated processes catch and fix issues before
they affect end-users.
26. What is the difference between a static website and a
dynamic website?
A static website and a dynamic website are two types of websites that differ
in their content and how they are generated.
A static website is a website that contains fixed content that does not
change, except when the content is manually updated by the webmaster.

C
O
D
E
R
S
.
S
T
O
P
The content of a static website is written in HTML and CSS, and it does not
interact with a database or any other external data source. Examples of
static websites include personal blogs, brochure websites, and online
portfolios. Static websites are easy to create and maintain, but they can
become outdated quickly and may not offer advanced features.
A dynamic website, on the other hand, is a website that contains content
that is generated dynamically based on user input or other factors. The
content of a dynamic website is usually stored in a database or other
external data source, and it is generated on-the-fly by the web server in
response to user requests. Examples of dynamic websites include
e-commerce websites, social networks, and web applications. Dynamic
websites offer advanced features and functionality, but they require more
resources to build and maintain.
In summary, the main difference between a static website and a dynamic
website is the way they generate content. Static websites contain fixed
content that does not change, while dynamic websites generate content
dynamically based on user input or other factors.
27. What is cross-site scripting (XSS) and how can it be
prevented?
Cross-site scripting (XSS) is a type of security vulnerability in web
applications that allows attackers to inject malicious code into a web page
viewed by other users. The goal of XSS attacks is to steal sensitive
information or execute malicious code on the victim's browser.
XSS attacks typically occur when a web application does not properly
validate user input or output, allowing an attacker to inject script code into
the page. This can happen when a user submits a form that contains
malicious code, or when a web application retrieves user input and displays
it on a web page without proper sanitization.
To prevent XSS attacks, web developers should follow these best
practices:

C
O
D
E
R
S
.
S
T
O
P
Input validation: Web applications should validate user input to prevent the
injection of malicious code. This can be done by using input validation
libraries or by writing custom validation code.
Output encoding: Web applications should encode user input when it is
displayed on a web page. This can be done by using output encoding
libraries or by writing custom encoding code.
Content Security Policy (CSP): Web applications can use a CSP to control
what resources can be loaded by a page. This can prevent the injection of
malicious scripts or other resources.
HTTP-only cookies: Web applications can set cookies as HTTP-only to
prevent them from being accessed by JavaScript code. This can prevent
the theft of session cookies or other sensitive information.
By following these best practices, web developers can prevent XSS attacks
and keep their web applications secure.
28. What is cross-site request forgery (CSRF) and how can it
be prevented?
Cross-Site Request Forgery (CSRF) is a type of security vulnerability that
allows an attacker to force a victim's web browser to perform actions on a
website without the victim's knowledge or consent. CSRF attacks occur
when a website does not properly validate the authenticity of requests
made to the site, allowing attackers to trick users into executing actions
they did not intend to perform.
An attacker can create a malicious website or email with a link or form that
submits a request to a vulnerable site, exploiting the fact that the user is
already authenticated with that site. When the user clicks on the link or
submits the form, the request is automatically sent to the vulnerable site,
causing unintended actions to occur.
To prevent CSRF attacks, web developers should follow these best
practices:

C
O
D
E
R
S
.
S
T
O
P
Use anti-CSRF tokens: Web applications should use anti-CSRF tokens to
ensure that requests come from a legitimate source. These tokens are
randomly generated values that are included in the form or link and are
verified by the server before processing the request.
Use same-site cookies: Web applications can use same-site cookies to
ensure that cookies are only sent with requests originating from the same
site. This can prevent attackers from using stolen cookies to perform CSRF
attacks.
Implement multi-factor authentication: Web applications can implement
multi-factor authentication to require users to provide additional proof of
identity before performing sensitive actions. This can prevent attackers
from using stolen credentials to perform CSRF attacks.
Check the origin of the request: Web applications can check the origin of
the request to ensure that it came from a trusted source. This can be done
by checking the Referer header or by using the Origin header.
By following these best practices, web developers can prevent CSRF
attacks and keep their web applications secure.
29. What is Big O notation and why is it important?
Big O notation is a way of describing the time complexity of an algorithm, or
how its runtime grows as the size of the input data increases. It is
commonly used to analyse and compare the performance of different
algorithms.
In Big O notation, the runtime of an algorithm is expressed as a function of
the size of its input data. The notation ignores constant factors and
lower-order terms, focusing only on the most significant factor in
determining the algorithm's runtime. For example, an algorithm that takes
5n + 10 operations to process an input of size n would be represented as
O(n), as the constant factor 10 and the lower-order term 5 can be ignored.

C
O
D
E
R
S
.
S
T
O
P
Big O notation is important because it allows developers to analyse the
performance of an algorithm in a way that is independent of the specific
machine or language used to implement it. By understanding the time
complexity of different algorithms, developers can choose the most efficient
solution for a given problem and optimise their code for better performance.
Common Big O notations include:
● O(1): constant time complexity, where the algorithm takes the same
amount of time regardless of input size
● O(log n): logarithmic time complexity, where the algorithm's runtime
grows slowly as the input size increases
● O(n): linear time complexity, where the algorithm's runtime grows
linearly with the input size
● O(n log n): quasi-linear time complexity, where the algorithm's
runtime grows faster than linear but slower than quadratic
● O(n^2): quadratic time complexity, where the algorithm's runtime
grows exponentially with the input size
By understanding these notations and their implications, developers can
write more efficient and scalable code.
30. What is the difference between HTTP and HTTPS
protocols?
HTTP (Hypertext Transfer Protocol) and HTTPS (Hypertext Transfer
Protocol Secure) are both protocols used for transmitting data over the
internet. The main difference between them is the way they ensure the
security and privacy of data during transmission.
HTTP is an unencrypted protocol, which means that data is sent in plain
text over the internet. This makes it vulnerable to interception and
manipulation by third parties. HTTPS, on the other hand, uses SSL/TLS

C
O
D
E
R
S
.
S
T
O
P
encryption to protect data in transit. SSL/TLS establishes a secure channel
between the client (browser) and the server, encrypting all data exchanged
between them.
In addition to encryption, HTTPS also provides authentication, ensuring
that the website being accessed is the intended one and not a fake or
malicious site. This is done through the use of digital certificates, which are
issued by trusted certificate authorities (CAs).
Because of its added security features, HTTPS is commonly used for
transmitting sensitive information, such as passwords, credit card numbers,
and other personal information. It is widely used by e-commerce sites,
banking sites, and other sites that require secure transmission of data.
In summary, the main differences between HTTP and HTTPS are:
Security: HTTPS is a more secure protocol than HTTP, as it uses
encryption and authentication to protect data in transit.
Encryption: HTTPS uses SSL/TLS encryption, while HTTP does not use
encryption.
Authentication: HTTPS uses digital certificates to authenticate the server,
while HTTP does not provide authentication.
Port: HTTP typically uses port 80, while HTTPS typically uses port 443.

C
O
D
E
R
S
.
S
T
O
P
Thank You
For more helpful content, see:
Instagram
Medium
Telegram

Top 30 Technical interview questions

More Related Content

Similar to Top 30 Technical interview questions (20)

Recently uploaded (20)

Top 30 Technical interview questions