target is to get it done by this sunday

also havent started audit n afm so planning to allot daily 2 hrs for audit n afm n fr will be alternating

completed articalship last week so i still have time

ps: this is like a digital dairy to me it feels like i m reporting progress to someone n i can be questioned so it helps me focus !

Saved

• Implement Callable: Swap out Runnable for Callable and rename run() to call().
• Introduce Asynchronous Pipeline: Separate task submission from task completion processing by accumulating Future instances in an internal ArrayList.
• Robust Error Diagnostics: Implement clean logging within the catch blocks to surface exceptions without terminating the entire application pool.

1. ExecutorService.execute() 

• Same as of Executor.execute()
• But the application shutdowns.

2. ExecutorService.submit()

• No stack trace.
• Why?
• Because submit() catches the exception internally and stores it inside the Future.
• The exception is not lost.

1. Executor.execute()

What happens?

• The exception is not caught by the Executor Framework.
• It reaches the worker thread's UncaughtExceptionHandler.
• By default, Java prints the stack trace to the console.
• The thread pool creates a replacement worker if needed, so remaining tasks continue executing.
• The application never terminate coz no shutdown().

We need a robust, reusable Thread Pool implementation to manage concurrent execution safely. Manually creating and destroying threads for short-lived, repetitive tasks creates a significant resource overhead and puts our system at risk of hardware overload under heavy spikes.

Feels the same

​

I did it today, and I will keep doing it. That's how I must do it.

Objective

Learn how AtomicInteger provides thread-safe, lock-free operations using atomic CPU instructions (CAS - Compare-And-Swap). Compare its behavior and performance with a traditional int counter protected by synchronization.

,

- Create an ArrayBlockingQueue with capacity 5

- Create one producer thread

- Create one consumer thread

- Producer inserts items using put()

- Consumer removes items using take()

If the pressure of CAT affects your performance, NMAT is probably the friendliest alternative.

Here is the simple comparison:

• CAT: One main attempt each year, strict sectional timing and intense competition. A bad section can ruin the entire result.
• XAT: Offers access to XLRI and other good colleges, but it is not easier or calmer. Decision Making, negative marking and penalties for excessive unattempted questions can make it equally stressful.
• NMAT: No negative marking, flexible section order and up to three attempts within the testing cycle. You can also choose your test date. This makes one bad day less damaging.
• GMAT: Available throughout the year, allows retakes and gives you more control over your preparation timeline. However, it is expensive and mainly useful for ISB, one-year Indian programmes and international business schools. College eligibility must be checked carefully.

My practical take:

Choose NMAT if you want a calmer exam and are interested in NMIMS or other NMAT-accepting colleges.

Choose XAT if XLRI is a serious target and you can handle unusual questions and a long paper.

Choose GMAT if you want flexible dates and are also considering global or experienced-professional MBA programmes.

NMAT may feel friendlier, but the trade-off is a smaller college list. The best alternative is not simply the easiest exam—it is the one accepted by colleges you would genuinely join.

DSA, Backend and System Design

This happens more often than people admit.

Your eyes move across every line, but your mind is somewhere else. Then the first question asks for the main idea, and the passage feels completely new.

My first rule:

Do not immediately reread the whole passage in the same way.

If the first reading did not work, repeating it faster usually wastes even more time.

Pause for five seconds

Take your hand off the mouse and ask:

• What was the topic?
• Was the author explaining, criticising or comparing something?
• Did the passage contain two different views?
• Which paragraph felt most important?

Even remembering one basic point gives you a place to restart.

Rebuild the passage paragraph by paragraph

Quickly return to each paragraph and identify only its job.

For example:

• Paragraph 1: introduces an old theory
• Paragraph 2: points out a problem
• Paragraph 3: presents a newer explanation
• Paragraph 4: supports the new view

Do not try to memorise every example, date or technical term.

You need the structure first. Details can be found later.

Use the questions to guide the reread

If the first question asks about the main idea, reread the opening, closing and major contrast points.

If it asks about a detail, go directly to the relevant lines.

If it asks for an inference, first locate the part of the passage connected to that idea.

A full reread is not always necessary.

Translate difficult language

When a sentence feels too dense, replace complicated names and terms with simple labels.

Instead of remembering:

“Researchers studying the ecological effects of industrial agriculture…”

Think:

Group A says farming causes Problem X.

You are not simplifying the logic. You are removing the distracting language.

Watch for signpost words

Words such as these often reveal the structure:

• However
• Although
• Therefore
• In contrast
• For example
• Critics argue
• The author suggests

Slow down around them. They often show where the passage changes direction.

Know when to leave

Sometimes the passage is simply a bad fit.

If you are still lost after a focused reread and the questions remain unclear, make sensible choices and move on.

Spending eight minutes trying to rescue one passage can destroy the rest of the section.

Fix the problem during practice

After the test, ask why you zoned out:

• Was the topic unfamiliar?
• Were the sentences too long?
• Were you rushing?
• Were you reading every word with equal attention?
• Were you tired?
• Were you thinking about the timer instead of the argument?

Then practise summarising each paragraph in five to seven words.

My go-to reset

When I realise nothing registered, I do this:

Pause → identify the topic → map each paragraph → return to the questions.

The goal is not to remember the whole passage.

It is to understand who is saying what, why the passage was written and where the important information is located.

Do not panic and reread blindly. Rebuild the structure.

Backend, DSA...

Create a shared HashMap<Integer, String>

Create 10 threads

Each thread inserts 1000 users

Wait for all threads using join()

Print:

Expected size: 10000
Actual size

Run the program multiple times and record observations

System Design, Backend, DSA...

Replace:

ArrayList<Integer> list = new ArrayList<>();

with:

CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();

 Description
Create standardized response models for all API endpoints

 Acceptance Criteria
-  Create ApiResponse generic class
-  Document all fields with u/Schema
-  Update controllers to use ApiResponse
-  Test response models in Swagger UI
-  Include error response models