Code with Adiii

Which one automatically gets sent to the server with every request?

1 month ago | [YT] | 1

Code with Adiii

Where would you usually store a user's dark mode preference?

1 month ago | [YT] | 0

Code with Adiii

Which storage mechanism is considered the most secure for sensitive user data?

1 month ago | [YT] | 0

Code with Adiii

🍪 Cookie vs Session vs Local Storage — Which one would you use?

Many beginners think all three do the same thing because they all store data.

But they have completely different purposes.

📌 Cookie → Small data stored in the browser and automatically sent to the server.

📌 Session → Data is stored on the server, and the browser only keeps a session ID.

📌 Local Storage → Data stays inside the browser and isn't sent to the server.

If you're learning Web Development, understanding these three concepts is a must because almost every website uses them.

Which one do you think is the most secure? 🤔

1 month ago | [YT] | 1

Code with Adiii

🌐 Understanding DNS (Domain Name System)

DNS is one of the most important systems that powers the internet, yet most people use it every day without realizing it.

Every device connected to the internet is identified using an **IP address**. An IP address is a unique numerical identifier that allows devices and servers to communicate with each other.

Humans, however, are not good at remembering long sequences of numbers. Remembering addresses such as **142.250.190.78** for every website would be impractical.

To solve this problem, the internet uses **DNS (Domain Name System)**.

DNS is a distributed system responsible for translating human-readable domain names into machine-readable IP addresses.

When a user enters a domain name such as **google.com** into a browser, the browser cannot directly establish a connection because domain names are not used for communication between computers. The browser first needs to determine the IP address associated with that domain.

The process begins with a DNS lookup request.

The browser contacts a DNS server and asks for the IP address corresponding to the requested domain name.

If the DNS server already has the information available in its cache, it immediately returns the IP address. If not, it queries other DNS servers until it finds the correct record.

Once the IP address is obtained, the browser establishes a connection with the destination server.

The browser then sends an HTTP or HTTPS request asking for the resources required to build the webpage.

The server responds by sending files such as:

• HTML – defines the structure of the webpage.

• CSS – defines the appearance and styling.

• JavaScript – adds logic and interactivity.

The browser parses these files, executes the JavaScript code, and renders the final webpage that appears on the user's screen.

The overall flow can be summarized as:

User enters a domain name

↓

Browser performs a DNS lookup

↓

DNS returns the IP address

↓

Browser connects to the server

↓

Browser sends an HTTP/HTTPS request

↓

Server sends website resources

↓

Browser renders the webpage

↓

Website appears on the screen

DNS is often referred to as one of the foundational components of the internet because nearly every online activity depends on it.

Without DNS, users would have to memorize and manually enter IP addresses for every website they wanted to access.

Understanding DNS also creates a strong foundation for learning other networking concepts such as HTTP, HTTPS, web servers, APIs, CDNs, load balancing, and cloud infrastructure.

Mastering these fundamentals is essential for every software engineer, whether you are a frontend, backend, mobile, or DevOps developer.

1 month ago | [YT] | 1

Code with Adiii

JavaScript Is Single Threaded… Then How Does Instagram Work?

One of the most confusing things beginners hear while learning JavaScript is that JavaScript is a single-threaded language. At the same time, when we open applications like Instagram, YouTube, or WhatsApp, everything seems to happen almost instantly. Posts load, stories appear, notifications update, and messages synchronize in the background. This raises an obvious question: if JavaScript can execute only one task at a time, then how can modern websites perform so many operations simultaneously?

The first thing to understand is that JavaScript has only one Call Stack. You can think of the Call Stack as a to-do list where JavaScript executes one task after another. If there are three functions waiting to be executed, JavaScript will pick the first one, complete it, then move to the second one, and finally execute the third one. It cannot execute multiple pieces of code simultaneously because there is only one Call Stack available.

Now imagine opening Instagram. As soon as the application starts, several operations need to happen at almost the same time. The application needs to fetch posts from a server, load stories, update notifications, synchronize messages, and prepare the user interface for interaction. If JavaScript had to do all this work by itself, the application would become very slow and the user interface would freeze while waiting for these operations to complete.

The reason this does not happen is because JavaScript is not working alone. The browser helps JavaScript by providing additional capabilities called Web APIs. Features like `fetch()`, `setTimeout()`, geolocation, camera access, and microphone access are not part of JavaScript itself. These capabilities are provided by the browser. Whenever JavaScript encounters one of these operations, it delegates the work to the browser instead of trying to execute everything on its own.

For example, when JavaScript encounters a `fetch()` call to retrieve posts from a server, it hands over that responsibility to the browser. The browser then starts performing the network request in the background. During this time, JavaScript does not sit idle and wait for the response. Instead, it continues executing the remaining code. This is one of the main reasons modern web applications remain responsive.

Once the browser finishes these operations, the results cannot immediately jump back into JavaScript. JavaScript may still be busy executing another task in the Call Stack. To avoid interrupting the currently running code, completed tasks are placed inside a waiting area called the Task Queue. For example, an API response, a finished timer, or a user click event can all wait inside this queue until JavaScript becomes available.

This is where the Event Loop comes into the picture. The Event Loop continuously checks two things: whether there is a task waiting inside the Task Queue and whether the Call Stack is empty. If both conditions are true, it moves the next task from the Task Queue back into the Call Stack. JavaScript can then execute that task. The Event Loop does not execute code itself; its responsibility is simply to coordinate when completed tasks can return to JavaScript.

This entire process explains why websites feel fast and responsive. JavaScript itself is not magically performing multiple tasks at once. Instead, the browser is handling time-consuming operations separately while JavaScript continues executing other code. The browser performs the heavy work in the background, and the Event Loop ensures that completed tasks are brought back into JavaScript at the right time.

One of the biggest misconceptions among beginners is the statement, "JavaScript is multitasking." This is incorrect. JavaScript is still a single-threaded language. The browser is doing the heavy lifting behind the scenes, and the Event Loop coordinates how completed tasks are returned to JavaScript. Understanding this concept is extremely important because it forms the foundation for many advanced topics such as Promises, Async/Await, API calls, React rendering, and asynchronous programming in general.

If you remember just one sentence, remember this: **JavaScript has one Call Stack, the browser provides Web APIs to handle heavy operations, and the Event Loop brings completed tasks back to JavaScript when it becomes available.**

Once this concept clicks, many JavaScript topics that previously seemed complicated will suddenly start making sense.

1 month ago | [YT] | 1

Code with Adiii

Everyone is talking about React vs Next.js lately.

Here’s the real deal:

React is the library that teaches you how to build UI.
Next.js is a framework built on top of React that adds routing, SSR, and full-stack power.

React gives you control.
Next gives you structure.

Neither is “better” — it depends on what you’re building.

Want super fast websites with SEO and backend routes? Next.js.
Want to master UI fundamentals and component logic? React.

Pro tip:
Learn React first → then Next.js becomes easy and powerful.

Build smarter, not just trendy. 🚀

5 months ago | [YT] | 4

Code with Adiii

💡 React useState – Explained Simply

Many beginners think React is confusing because the UI updates “automatically.”
But once you understand useState, everything starts to make sense.

In React, you don’t update the UI directly.
You update the state, and React takes care of the UI for you.

Example:

const [count, setCount] = useState(0);

👉 count stores the current value
👉 setCount updates the value

When you click a button and call setCount(count + 1), React:
1️⃣ Updates the state
2️⃣ Re-renders the component
3️⃣ Updates only the changed part of the UI

That’s why there is no page refresh.

❌ Common mistake beginners make:

count = count + 1;


This changes the variable but React won’t re-render.

✅ Correct way:

setCount(count + 1);


Once you understand this flow:
State change ➝ Re-render ➝ UI update

React becomes much easier.

📌 Tip for beginners:
Master useState and props before jumping into advanced hooks.

6 months ago | [YT] | 0

Code with Adiii

Which HTML tag is used to display JavaScript output in React JSX?

6 months ago | [YT] | 0

Code with Adiii

What will this Javascript code output?
console.log(typeof null);

6 months ago | [YT] | 0