Self-Introduction

I am Honey Nandal, a final-year [Link] student specializing in AI/ML, with a strong foundation in NLP, data
analytics, and full-stack development. My academic projects and certifications (including an Oracle Generative AI
credential) demonstrate expertise in building data-driven, scalable solutions. I have developed an AI-powered
healthcare chatbot and a fake-news classifier, using Python and Java-based tools (Flask, Streamlit, NLTK) to solve
real-world problems. I am passionate about healthcare – Evernorth’s mission of improving care through AI/analytics
resonates with me. For example, my chatbot project applies ML to symptom assessment, directly supporting patient
triage (a key use case for health [Link]). I value teamwork and communication – in my
Octanet internship I led cross-functional workshops to share knowledge – which aligns with Evernorth’s emphasis on
collaboration and clear communication. Overall, my background in AI/ML, fluency in Python/Java, and genuine
interest in healthcare make me a strong fit for Evernorth’s AI/ML intern role.

Project: Fake News Detection System (Jun–Jul 2025)

Overview: I built a fake-news classifier to label news articles as real or fake. The goal was to combat misinformation
by applying NLP and machine learning techniques. The pipeline ingested 40,000+ news articles and output accuracy-
improved predictions. In practice, such a system could be adapted to flag health-related misinformation, which is
crucial since up to ~29% of social media health content can be [Link].

Technologies & Approach: We used Python with libraries like NLTK and spaCy for text processing.
Preprocessing steps included lowercasing, tokenization, stop-word removal, and lemmatization to clean each article
(mirroring standard NLP [Link]). Text features were extracted via TF-IDF vectorization. For
classification, we tried Logistic Regression, Multinomial Naive Bayes, and SVM. Logistic Regression was chosen as a
fast baseline, Naive Bayes for its efficiency with word counts, and SVM for its robustness. TF-IDF and these classical
models were selected for their proven effectiveness in text [Link] and because they are
interpretable for initial comparisons.

Challenges & Solutions: A key challenge was scalability and performance on a large corpus. We optimized by using
efficient data structures and batch training, and by performing cross-validation for hyperparameter tuning (inspired by
common ML [Link]). Another challenge was class imbalance and noisy language (different
writing styles, abbreviations, etc.). We mitigated this by data cleaning and by tuning class weights in models.
Continuous evaluation (accuracy, precision, recall) helped spot issues; for example, if recall on “fake” articles was low,
we tweaked thresholds or augmented the data.

Relation to Healthcare/Evernorth: Fake-news detection directly connects to healthcare: health-related misinformation

(e.g. false cures, vaccine myths) has serious [Link]. A similar pipeline could flag or filter
out unreliable health content, helping Evernorth ensure that patients and providers access accurate health information.
Moreover, the project showcases my ability to handle large text datasets and build NLP models – skills Evernorth
values for initiatives in AI and analytics.

Likely Interview Questions:

Q: “How did you preprocess the text data?”

A: We converted text to lowercase, removed punctuation and stopwords, and applied tokenization and lemmatization
(using NLTK)[Link]. This standardized the words so the TF-IDF vectorizer could create meaningful
features.
Q: “Why did you try Logistic Regression and SVM? Which performed best?”
A: Logistic Regression is a fast, interpretable baseline; SVM can capture non-linear boundaries (with kernels). In tests,
Logistic Regression often gave high accuracy on TF-IDF vectors (the blog example achieved ~99%
[Link]), but SVM can handle complex features if needed. We compared them via validation to
choose the optimal model.
Q: “How could this project be extended to healthcare?”
A: I would apply the pipeline to health forums or news, training on labeled healthcare misinformation. The model
could flag posts or articles with high probability of being false, aiding content moderation and patient education.
Project: AI Healthcare Chatbot for Symptom Checking (May–Jul 2025)
Overview: I designed an AI-driven chatbot for symptom-based disease prediction, helping users assess potential
conditions from their symptoms in real time. The interface (built with Flask and Streamlit) asks the user about
symptoms and returns likely diagnoses, along with confidence scores. Users can provide feedback (“Was this
helpful?”) to iteratively improve the model.
 Technologies & Approach: The backend uses multi-label classification to allow multiple possible diseases per input.
We trained models (Random Forest and Logistic Regression) on an open health dataset of patient symptoms and
diagnoses. Random Forest was chosen for its ability to handle complex feature interactions and multi-class outputs
(each tree votes on disease labels)[Link]. Logistic Regression provided a simpler baseline. The UI was implemented
in Python: Flask served the web app and Streamlit provided an interactive frontend. We focused on a responsive
design so users (patients or providers) could easily enter symptoms on web or mobile. We also implemented a
confidence threshold (e.g. only present diagnoses above 60% probability) and a feedback loop: if users indicate the
prediction was wrong, we use that feedback as new training data to refine the model over time.

Challenges & Solutions: Natural language variability in symptoms (e.g. “stomach ache” vs “abdominal pain”) was a
challenge. We addressed this via fuzzy matching and synonyms: our parser maps different phrases to standard
symptoms (similar to approaches reported in [Link]). Ensuring multi-label accuracy was another challenge;
we dealt with it by carefully tuning Random Forest hyperparameters and by analyzing label correlations. Data sparsity
(some diseases with few examples) was mitigated by feature engineering (e.g. combining related symptoms) and by
using model ensembles. Lastly, user trust is critical: by providing confidence scores and clarifying that the chatbot
is advisory, not diagnostic (as emphasized in [8] and industry practice), we encourage users to consult professionals
for final [Link].

Relation to Healthcare/Evernorth: This project is directly in the healthcare domain: it improves patient self-triage
and awareness. Healthcare chatbots are a growing field (market projected to ~$1.5B by [Link])
for tasks like symptom checking and appointment scheduling. In fact, tools like Ada Health already use AI chatbots to
triage [Link]. My chatbot’s focus on accuracy and feedback loops aligns with Evernorth’s
mission to leverage AI for better care. It demonstrates experience with health data, Python frameworks, and user-
centered design – all valuable for Evernorth’s innovation projects (e.g. generative AI solutions in care).

Likely Interview Questions:

Q: “What is multi-label classification, and why is it used here?”

A: Unlike single-label classification, multi-label classification allows multiple diseases to be predicted from one set of
symptoms (since symptoms can indicate more than one condition). We formulated the problem so the model can
output a set of possible diagnoses. Random Forest naturally extended to this by training on binarized labels for each
disease.
Q: “Why use Random Forest for symptom prediction?”
A: Random Forest handles high-dimensional, categorical-like symptom data well. It is robust to noise and can give
probability scores. Since patient symptoms can correlate in complex ways, ensemble trees capture those interactions
better than a linear model. It also gave higher cross-validated accuracy on our dataset.
Q: “How did you ensure user trust in the chatbot’s predictions?”
A: We implemented confidence scoring (showing probabilities) and explicitly informed users these are suggestions,
not medical [Link]. We also included a feedback mechanism: if a user indicates the result was unhelpful, we
record that to retrain the model, continuously improving its reliability.

Internship: Octanet Services – Web Developer (Jul–Aug 2024)

At Octanet, I worked remotely on front-end optimization and team collaboration. Skills Applied: I used HTML, CSS,
and JavaScript to improve UI/UX design, and integrated new frontend frameworks (e.g. modern JS libraries) to speed
up development. I also used Git for version control and agile tools for issue tracking.

Impact of Work: My enhancements reduced the website’s bounce rate by 20%, meaning users stayed on the site
longer and engagement increased. We achieved this by optimizing page load times (image compression, code
minification) and improving navigation flow. These improvements not only improved user satisfaction but also likely
boosted conversions.

Teamwork & Communication: As part of a small distributed team, I facilitated knowledge-sharing workshops. I
organized sessions on new web technologies (e.g. introducing a CSS framework or a JS tool) to bring the team up to
speed. This enhanced cross-functional collaboration, as noted in my resume. We used Slack and video meetings
effectively to coordinate while remote.

Likely Interview Questions:

Q: “What front-end change reduced the bounce rate?”

A: We implemented lazy loading of images and streamlined the CSS to improve load time. By deferring non-critical
scripts, the page became responsive faster, which cut the initial bounce. We measured bounce rate using Google
Analytics before and after.

Q: “How did you integrate new technologies safely?”

A: I introduced new tools incrementally. For example, I added a lightweight CSS framework in a branch and tested it
for conflicts before merging. We peer-reviewed the code changes to ensure stability. This way I “streamlined
development workflows” as noted in my resume without disrupting the live site.

Q: “Describe a team challenge and your role.”

A: Coordinating across time zones was a challenge in remote work. I proposed a shared document with task ownership
and sent weekly updates to keep everyone aligned. During workshops, I actively solicited feedback to adapt content to
teammates’ needs, exemplifying collaboration.
Technical Skills & Sample Questions
Below are major skill areas from my resume, with representative interview questions and concise answers.

Programming (Java, Python, SQL):

Q: “What are key differences between Java and Python?”

A: Java is statically typed and compiled, while Python is dynamically typed and interpreted. Java enforces strict type
rules at compile time; Python is more flexible but can have runtime errors. Java’s syntax (e.g. semicolons, braces) is
more verbose. Python’s ease of scripting makes it great for quick prototyping, while Java’s performance and
robustness suit large-scale applications.

Q: “Explain a JOIN in SQL.”

A: A JOIN combines rows from two tables based on a related column. For example, an INNER JOIN returns only
matching records in both tables, while a LEFT JOIN returns all records from the left table and matched ones from the
right (filling nulls if no match).

Web Development (HTML/CSS, Flask, Streamlit):

Q: “What is Flask and why use it?”

A: Flask is a lightweight Python web framework. It’s used to build web APIs or small web apps. We used Flask to
serve the chatbot’s backend because of its simplicity and ease of integration with Python ML
[Link]. Compared to a full-stack framework like Django, Flask has less overhead, which is ideal for
prototypes.

Q: “What is Streamlit?”
A: Streamlit is a Python library for quickly building data-app frontends. It lets you create interactive dashboards with
minimal code. I used Streamlit to make a responsive chatbot interface, leveraging its built-in components for input
forms and [Link].

Databases (MySQL, MongoDB):

Q: “When would you use MongoDB over MySQL?”

A: MongoDB is a NoSQL document database, good for unstructured or rapidly changing data (e.g. storing JSON-like
user sessions or logs). MySQL is a relational database with schemas – better for structured data needing transactions.
For example, if our chatbot logs each conversation as a document, MongoDB is convenient. If we needed ACID
transactions for patient records, MySQL could be preferable.
Q: “What is normalization?”
A: Normalization is the process of organizing a relational database to reduce redundancy (e.g. splitting tables). Normal
forms (1NF, 2NF, 3NF, etc.) define rules so that each table handles a distinct concept. This prevents update anomalies.
AI/ML & NLP (Machine Learning, Deep Learning, NLTK, spaCy):

Q: “What is overfitting and how do you prevent it?”

A: Overfitting happens when a model learns noise instead of general patterns, performing well on training data but
poorly on new data. To prevent it, we can use cross-validation, regularization (e.g. L1/L2 penalties in logistic
regression), pruning in decision trees, or gather more data. Also, simpler models (like limiting tree depth in Random
Forest) help avoid overfitting.

Q: “Explain TF-IDF.”
A: TF-IDF (Term Frequency–Inverse Document Frequency) is a way to convert text to numeric features. TF measures
how often a word appears in a document; IDF downscales words that appear in many documents. Multiplying them
highlights words that are common in one document but rare overall, giving us a useful feature vector for text
classification.

Data Analysis & Visualization (Power BI, Tableau, Excel):

Q: “When use Tableau vs Excel?”

A: Excel is great for quick analysis, pivot tables, and what-if modeling. Tableau and Power BI are better for creating
interactive dashboards and handling larger datasets visually. For instance, if I needed to share interactive charts of our
chatbot’s usage metrics across regions, I’d use Tableau or Power BI for its connectivity and user-friendly visuals.

Q: “Describe a pivot table.”

A: A pivot table aggregates data by categories. For example, given patient visit data (columns: date, symptom,
outcome), a pivot table could show counts of each symptom by month. It lets you drag fields into rows/columns and
automatically computes sums, counts or averages.

Tools (Git, Office Suite):

Q: “Why use Git in projects?”

A: Git is version control. It tracks changes, allows branching, and enables collaboration. If multiple developers edit
code, Git merges changes and records history, which helps manage the project safely. For example, I used Git during
my internship to manage feature branches and ensure code integrity.

Q: “How do you resolve a merge conflict?”

A: A merge conflict happens when Git can’t automatically combine changes from two branches. To resolve it, I open
the file, look for conflict markers (<<<<<<<), manually decide which code to keep or how to merge them, remove the
markers, and then commit the result. We then run tests to ensure nothing broke.

Alignment with Evernorth’s JD

My profile closely matches Evernorth’s internship requirements. I am on track to graduate in 2026 (meeting the
eligibility of a 2026 passing batch) and have a CGPA above 8.6. I am deeply interested in healthcare: my chatbot
project is directly in the health domain, and I am “passionate about building a career in [the] healthcare domain”.
Technically, I am proficient in Python and Java, exactly the languages highlighted in the JD, and I have solid AI/ML
experience. My skills in data analytics (using Excel, Power BI, Tableau) align with the analytics focus of Evernorth.

I have a track record of adapting to new technologies (I quickly learned Streamlit and various ML libraries for my
projects) and a growth mindset (multiple certifications in AI and cloud). Evernorth values collaboration and
communication, and as noted, I have facilitated team workshops and cross-functional knowledge transfer. My
experience shows I can learn on the fly, work flexibly across front-end and ML roles, and communicate complex ideas
clearly. In summary, my AI/ML background, healthcare-aligned projects, and strong communication skills make me
well-prepared to contribute to Evernorth’s mission of leveraging AI and analytics for better health outcomes.
 Explain Java memory structure.

Interview-ready answer:

Java divides memory into two main parts: Stack and Heap.
Stack stores method calls, local variables, and references.
Heap stores all objects created using new.
The Garbage Collector automatically removes unused objects from the heap.
This structure helps Java manage memory safely and efficiently.

 What is Stack memory in Java?

Answer:

Stack is used for short-lived data such as method calls and local variables.
It is fast, thread-safe, and memory is cleaned automatically when the method ends.
It stores primitive values and references to objects.

 What is Heap memory in Java?

Answer:

Heap is where all Java objects live.

It is shared across all threads and managed by the Garbage Collector.
Instance variables and object data are stored here.

 What is the difference between Stack and Heap?

Perfect short answer:

Stack Heap
Stores local variables & references Stores objects
Very fast Slower
Memory freed automatically Uses Garbage Collector
Thread-specific Shared across threads
Limited size Much larger

Where are primitive and non-primitive types stored?

Answer:

Primitive values (int, double, boolean, etc.) are stored directly in the stack.
Objects and arrays are stored in the heap, while their references are stored in the stack.

What is the String Pool?

Interview answer:
 String Pool is a special area in the heap where Java stores unique string literals.
If two variables have the same string literal, they point to the same object in the pool, which saves
memory.

Example:

String s1 = "Java";
String s2 = "Java"; // Same object in String Pool

 What is Garbage Collection in Java?

Answer:

Garbage Collection (GC) is Java’s automatic memory management process.

It removes objects from the heap when they are no longer referenced, preventing memory leaks and
ensuring efficient memory usage.

 When does an object become eligible for Garbage Collection?

Answer:

An object becomes eligible for GC when no active reference points to it.

Example:

obj = null; // eligible for GC

 Is memory allocation the same for static variables?

Answer:

Static variables are stored in a special memory area called the Method Area (or MetaSpace in newer
Java versions), not in stack or heap.

 Can stack memory store objects?

Answer:

No. Stack stores only references.

The actual object is always stored in the heap.

 What Does “Thread-Specific” Mean?

A thread is like a separate path of execution in a program.

Thread-specific memory means:

Each thread has its own private memory area

No other thread can access or modify it
No sharing happens between threads

 In Java: Stack Memory is Thread-Specific

Every thread in Java gets its own stack.

Example:
If your program has 3 threads:

Thread A → its own stack

Thread B → its own stack

Thread C → its own stack

They cannot access each other’s stack memory.

 Why is stack thread-specific?

Because:

Each thread executes its own methods

Each has its own local variables

Each has its own call sequence

So Java gives each thread its own stack.

⭐ Stack = Thread-specific

⭐ Heap = Shared by all threads

This is why you can have thread safety issues when multiple threads access the same object in the heap.

Ques :- Difference b/w hashmap and hashtable

HashMap is the modern, faster choice, while Hashtable is an older, slower legacy class.

Here is the breakdown of why they are different:

1. Synchronization (Thread Safety)

Hashtable is Synchronized: It is "thread-safe." This means if two threads try to access it at the same time,
one has to wait for the other to finish. This makes it slower.

HashMap is Non-Synchronized: It is not thread-safe. Multiple threads can access it simultaneously. This
makes it faster and more efficient for single-threaded applications (which is most cases).

2. Handling Nulls

Hashtable: Does not allow null keys or null values. If you try, it throws a NullPointerException.

HashMap: Allows one null key and multiple null values.

3. Legacy Status
 Hashtable: Introduced in Java 1.0 (very old). It is considered a "legacy" class.

HashMap: Introduced in Java 1.2 as part of the formal Collections Framework

Python
DataFrames: A Pandas DataFrame is a two-dimensional labeled data structure (like a table) with rows and
columns. Each column can hold different data types (numbers, strings, etc.), similar to a spreadsheet or SQL
table. DataFrames are central to data manipulation (e.g., filtering, grouping, joining)
.
Object-Oriented Programming (OOP): Python supports classes and objects. In OOP, you bundle related
data (attributes) and operations (methods) into classes. Key principles are encapsulation (hiding internal
state), inheritance (extending functionality from a base class), and polymorphism (objects from different
classes providing a common interface).

Logic and Control Flow: Python uses boolean logic (and, or, not) on conditions. Control flow is managed
via conditional statements (if/elif/else) and loops (for, while). Equality (==) checks value equality, while is
checks object identity. Understanding short-circuit evaluation (e.g., in A and B, if A is false, B is not
evaluated) is important for writing efficient conditions.
(Easy) What is a Pandas DataFrame and why is it useful?
Answer: A Pandas DataFrame is essentially a table of data, organized in labeled rows and columns. It can
store heterogeneous data types (integers, strings, etc.) in each column. For example, you might have a
DataFrame of patient records with columns like Name, Age, and BloodPressure. DataFrames make it easy to
perform operations like filtering rows or computing statistics on columns. For instance, one could filter rows
with df[df['Age'] > 30] to get only patients older than 30. The DataFrame abstraction is like a spreadsheet
within Python, enabling powerful data manipulation in just a few lines of code.
(Medium) How do you filter rows of a DataFrame based on a condition?
Answer: In Pandas, filtering is done via boolean indexing. If df is a DataFrame, you can create a boolean
mask like mask = df['col'] > value and then apply it: filtered_df = df[mask]. In one line, filtered_df =
df[df['col'] > value]. This returns a new DataFrame containing only rows where col exceeds value. You can
combine conditions with & (and) or | (or), e.g. df[(df['A']>0) & (df['B']=='X')]. All these operations are
vectorized (applied element-wise) and very efficient. For missing values, functions like dropna() or fillna()
are used. In a live interview, you would explain this conceptually and might write a short code example.
(Easy) What is a class and an object in Python? Can you give a simple example?
Answer: A class in Python is a blueprint for creating objects (instances). It defines a set of attributes (data)
and methods (functions) that its objects will have. An object is a specific instance of that class in memory.
For example:
class Person:
def __init__(self, name, age):
[Link] = name
[Link] = age
# 'Person' is a class. To create an object:
p = Person("Alice", 30)
Here, Person is a class, and p is an object (instance) of that class. We call Person("Alice", 30) to allocate a
new Person object with name="Alice" and age=30. In Python, this instantiation calls the class’s __init__
constructor. This exemplifies the OOP principle that objects bundle related data and behavior.
(Medium) Explain inheritance in Python with an example.
Answer: Inheritance means creating a new class (child/subclass) from an existing class (parent/superclass)
so the child gets the parent’s attributes and methods. For example:
class Vehicle:
def start(self):
print("Engine started")
class Car(Vehicle): # 'Car' inherits from 'Vehicle'
def honk(self):
print("Beep!")
my_car = Car()
my_car.start() # Inherited method from Vehicle
my_car.honk() # Car's own method
Here, Car extends Vehicle. This “is-a” relationship lets us reuse code: Car automatically has the start()
method defined in Vehicle. In Python you write class Car(Vehicle): to inherit. Python also supports multiple
inheritance (a class can inherit from multiple parents). In an interview, explain that inheritance promotes
code reuse and polymorphism: e.g., Car and Bike could both inherit from Vehicle and override methods
differently.
(Easy) What is the difference between the == operator and the is operator in Python?
Answer: The == operator tests for equality of value, whereas is tests for identity (same object in memory).
For example:
x = [1, 2, 3]
y = [1, 2, 3]
Here x == y is True because the two lists have the same contents. However, x is y is False because x and y
refer to two separate list objects in memory. Internally, == calls the __eq__ method and compares values,
while is checks whether both names point to the exact same object. Use is primarily to check against
singletons like None.
(Hard) Explain short-circuit evaluation in Python with an example.
Answer: Short-circuiting means that in boolean expressions, Python stops evaluating as soon as the result is
determined. For example, in the expression A and B, if A is False, Python will not evaluate B because the
whole expression cannot become True. Similarly, in A or B, if A is True, B is not evaluated. Example:
def compute():
print("Computed!")
return True
x = False and compute() # 'compute()' is never called
y = True or compute() # 'compute()' is never called
Here, compute() is not executed because in x = False and ..., the first operand is already False (making x
False), and in y = True or ..., the first operand is True (making y True). This behavior is efficient for
performance and avoiding side-effects. (Logical operators in Python operate on boolean values as described,
but the short-circuit detail is a language feature.)

Java
OOP: Java is inherently object-oriented: code is structured around classes and objects. Key concepts are
encapsulation (using private fields and public getters/setters), inheritance (extends, forming "is-a"
hierarchies), polymorphism (overriding methods in subclasses), and abstraction (using interfaces and
abstract classes). For example, if class Animal has a method eat(), a subclass Dog inherits eat() or can
override it. As GeeksforGeeks explains, inheritance uses extends and forms an "is-a" relationship.
Memory Model: The Java Virtual Machine (JVM) divides memory into areas. The heap is a shared area
where all objects and their instance variables are stored. Each thread has its own stack for method calls and
local variables. For example, when you do MyObject obj = new MyObject();, the MyObject instance goes
on the heap and the reference obj lives on the current thread’s stack. Java automatically handles memory via
garbage collection, reclaiming objects that are no longer reachable.

Multithreading: Java supports concurrency through threads ([Link]) and the Runnable interface.
You create a new thread by instantiating Thread with a Runnable or subclassing it, then calling start(). The
start() method launches a new thread and calls its run() method. (Calling run() directly would not start a new
thread; it would just execute in the current thread.) The synchronized keyword is used to prevent race
conditions: a synchronized method or block allows only one thread at a time to execute it for a given object.
As Oracle’s documentation explains, when one thread is executing a synchronized method on an object, any
other thread that tries to invoke a synchronized method on the same object will block until the first thread is
done, which also ensures memory consistency between threads.
(Easy) What is a class and an object in Java? Provide an example.
Answer: In Java, a class is a blueprint for objects, and an object (instance) is a concrete realization of that
blueprint. For example:
class Point {
int x, y;
Point(int x, int y) { this.x = x; this.y = y; }
}
// Create an object of type Point
Point p = new Point(5, 10);
Here, Point is a class with two integer fields and a constructor. p is an object of class Point, created with
specific values. All code runs in objects in Java, and methods operate on object instances.
(Medium) Explain inheritance in Java and give a code example.
Answer: Inheritance allows a new class (subclass) to reuse code from an existing class (superclass). In Java,
use the extends keyword. For example:
class Animal {
void eat() { [Link]("Animal is eating"); }
}
class Dog extends Animal {
void bark() { [Link]("Dog barks"); }
}
Dog d = new Dog();
[Link](); // inherited from Animal
[Link]();
Dog inherits the eat() method from Animal due to the extends relationship. This means Dog has all Animal’s
fields/methods (unless overridden), plus any additional ones it defines. GeeksforGeeks calls this an “is-a”
relationship (a Dog is-an Animal). In an interview, note that inheritance promotes code reuse and
polymorphism (e.g., an Animal reference could point to a Dog or Cat object).
(Medium) Describe how Java manages memory (heap vs. stack) and garbage collection.
Answer: In Java, objects are allocated on the heap, which is shared among all threads. Primitive values and
object references (and function call frames) live on the stack, with one stack per thread. For example, when
you declare int n = 5;, n is stored on the stack, but if you do String s = new String("hello");, the String object
resides on the heap while the reference s is on the stack. The JVM automatically uses a garbage collector to
free heap memory of objects that are no longer reachable. You do not explicitly deallocate memory in Java;
instead the GC periodically reclaims unused objects.
(Easy) How do you create and start a thread in Java? What is the difference between start() and run()?
Answer: You create a thread by either subclassing Thread or implementing Runnable. Then you call start()
on your Thread instance. For example:
Thread t = new Thread(new MyRunnable());
[Link](); // starts a new thread and calls [Link]()
Calling start() actually creates a new OS-level thread and internally invokes the run() method of the Thread
or Runnable. If you were to call run() directly (e.g. [Link]()), it would not start a new thread but simply
execute run() in the current thread. Thus, always use start() to initiate parallel execution.
(Medium) What does the synchronized keyword do in Java?
Answer: The synchronized keyword is used for thread safety. When a method or block is declared
synchronized, the JVM ensures that only one thread at a time can execute that code for a given object. As
Oracle’s tutorial explains, if one thread is executing a synchronized instance method on an object, all other
threads that invoke synchronized methods on the same object will block until the first thread finishes. This
prevents race conditions and provides a "happens-before" guarantee so that changes made by one thread are
visible to others. For example:
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
Here, increment() is synchronized, so if two threads call it on the same Counter object, one will wait until
the other finishes, ensuring count is updated correctly.

Operating System
Processes and Threads: A process is a running instance of a program. It has its own memory space (code,
data, stack) and resources. Processes can spawn child processes (e.g., via fork() on UNIX). A thread is a
lightweight execution unit within a process. All threads of a process share the same memory space, which
allows them to communicate quickly (but also requires careful synchronization). In practice, a process may
contain one or more threads (for example, a web browser may have separate threads for rendering,
networking, and user input). Threads share code and data, making context switches faster.

Memory Management: Modern OSes use virtual memory to give each process the illusion of a large,
contiguous address space. Physical RAM is divided into fixed-size frames, and the virtual address space is
divided into pages. The OS can swap pages in and out of RAM to disk when needed. This means a program
can request more memory than the machine actually has, and the OS transparently handles storing and
retrieving pages. For instance, if a program accesses a page not currently in RAM, the CPU triggers a page
fault, and the OS loads the page from disk into RAM. Virtual memory allows efficient multitasking and
memory use, because only the working set of pages needs to be in RAM.
CPU Scheduling: The OS uses scheduling algorithms to decide which process (or thread) runs on the CPU
at any given time. Common algorithms include First-Come-First-Served (FCFS), Shortest-Job-First (SJF),
Priority, and Round Robin (RR). In Round Robin scheduling, processes take turns in a circular queue, each
running for a fixed time quantum. After a process uses its time quantum, it is preempted and placed at the
back of the queue, and the next process runs. The advantage of Round Robin is fairness: every process gets
CPU time in turn, preventing any single process from monopolizing the CPU. (Other algorithms like SJF
focus on minimizing waiting time.)
(Easy) What is the difference between a process and a thread?
Answer: A process is a program in execution, with its own memory and resources. A thread is an execution
unit within a process that shares the process’s memory. In other words, threads within the same process see
the same global data, but separate processes cannot directly access each other’s memory. For example, your
operating system and all user applications are separate processes; within a web browser process, multiple
threads might handle different tabs or background tasks. Processes have more overhead (isolated memory,
separate resources) whereas threads are “lightweight” (less overhead, since they share memory).
(Medium) Explain how virtual memory works in an operating system.
Answer: Virtual memory is a technique where the OS gives each process the illusion of a large, continuous
memory space. The OS divides the memory into pages and keeps track of their location with a page table. If
the physical RAM is insufficient, the OS can move pages that aren’t actively used to disk (a swap space) and
bring them back when needed. This means a program can use more memory than physically available, and
the OS doesn’t have to load all of a program at once. For instance, if a program tries to access a page that
isn’t currently in RAM, the CPU causes a page fault, and the OS loads the required page from disk into
RAM. Virtual memory allows efficient multitasking, because only the needed pages of each program are
kept in physical memory at a time.
(Medium) What is Round Robin scheduling and why is it used?
Answer: Round Robin (RR) is a CPU scheduling algorithm where each process in the ready queue is given a
fixed time slice (quantum) in a circular order. The scheduler cycles through all runnable processes, allowing
each to run for up to one quantum. If a process finishes before the quantum expires, it leaves the CPU;
otherwise, it is preempted when the quantum ends and placed at the back of the queue. The advantage of
Round Robin is fairness: every process gets CPU time in a predictable order, preventing any single process
from monopolizing the CPU. This is often used in time-sharing systems. A drawback is context-switch
overhead (switching processes frequently). For example, if the time quantum is 100ms, process A runs for
100ms then B runs for 100ms, then C, and so on in a cycle.
(Hard) Compare Shortest Job First (SJF) and Round Robin (RR) scheduling in terms of waiting time and
fairness.
Answer: Shortest Job First (SJF) schedules the process with the smallest CPU burst next, which minimizes
average waiting time for a given workload. However, if long processes continually arrive, short processes
keep getting scheduled first, causing long processes to wait indefinitely (starvation). In contrast, Round
Robin (RR) ensures no starvation by giving each process a turn with the CPU. As GeeksforGeeks notes, RR
is fair because all processes get to execute in turn, but its average waiting time depends on the time quantum.
A large quantum makes RR behave like FCFS (with longer waits for some), while a small quantum
increases context-switch overhead. In summary, SJF achieves the lowest average wait time but can be unfair
to long jobs, whereas RR is fair (no starvation) at the cost of higher average waiting time due to frequent
switching.
Sources: Authoritative references (Python docs, GeeksforGeeks, Oracle, Real Python) were used to define
concepts and verify correctness. This ensures accuracy of definitions and examples.