Forem: Aditi Deshmukh

The Easiest Way to Understand APIs (With Simple Examples)

Aditi Deshmukh — Sun, 19 Oct 2025 14:02:49 +0000

Have you ever wondered how your weather app knows tomorrow’s forecast, or how you can log in to any website using Google?
The secret behind all this magic is something called an API — and once you understand it, you’ll start seeing it everywhere.

In this post, let’s break down what APIs are, how they work, and why they’re so powerful in the easiest way possible 🚀

What Is an API?

API stands for Application Programming Interface.

-->An API is like a messenger that allows two applications to talk to each other.
It helps one app request data or features from another app without needing to know how the other one is built inside.

Think of It Like a Restaurant

Imagine you’re at a restaurant:

You (the customer) tell the waiter what you want.
The waiter takes your order to the kitchen (where the food is made).
The kitchen prepares it and gives it back to the waiter.
The waiter brings the dish to your table.

You (customer)  →  The client or app (like your browser)
Waiter          →  The API
Kitchen         →  The server or database
Food            →  The data or response

So instead of directly going into the kitchen, you communicate through the waiter — that’s exactly how APIs work!

How APIs Work in Real Life

APIs are everywhere. You’re using them right now — you just don’t realize it.

Here are a few examples:

Weather apps use a Weather API to get live temperature and forecast.
Uber and Ola use Google Maps API for routes and navigation.
Login with Google or Facebook uses OAuth APIs to verify who you are.
Online shopping sites use Payment APIs (like Razorpay or Stripe) for secure payments.

Without APIs, every company would have to rebuild everything from scratch — from maps to payments.

APIs Are Like Digital Bridges

Imagine two apps standing on separate sides of a river.
An API acts like a bridge that connects them so they can exchange information safely and smoothly.

They don’t need to expose their internal code — they just agree on a way to talk (the API format).
That’s why APIs are sometimes called the connectors of the internet.

Let’s See a Simple Example

Here’s a tiny JavaScript example that uses a Weather API to get live data:

fetch("https://api.weatherapi.com/v1/current.json?key=YOUR_KEY&q=Mumbai")
  .then(response => response.json())
  .then(data => console.log("Temperature in Mumbai:", data.current.temp_c + "°C"))
  .catch(error => console.error("Error fetching data:", error));

Here’s what’s happening:

The code sends a request to the API’s website (URL).
The API responds with weather data in JSON format.
We then print the temperature in Mumbai.

With just a few lines of code, your app is now talking to a global weather database.

Why APIs Are So Important

APIs are what make modern software powerful and connected.

Here’s why they matter so much:

Speed        →  Fetch real-time data instantly.  
Reusability  →  Use existing tools instead of building everything from zero.  
Scalability  →  Easily connect multiple systems together.  
Security     →  Share only what’s needed — safely.

Final Thoughts

APIs are the invisible heroes of the digital world.
They make your favorite apps — like Instagram, YouTube, and Paytm — talk to each other seamlessly.

Once you understand how APIs work, you unlock one of the most powerful concepts in software development.

What Happens When You Click a Link

Aditi Deshmukh — Thu, 16 Oct 2025 20:39:04 +0000

Ever wondered what really happens behind the scenes when you click a link in your browser? It seems instant, but there’s a lot going on in the background! In this post, we’ll break it down step by step in a simple, beginner-friendly way.

1. The Browser Gets the URL

When you click a link, your browser first reads the URL — the address of the webpage.

Example: https://example.com/page1

https:// → Protocol (how to communicate with the server)
example.com → Domain name (server address)
/page1 → Specific page on the server

2. DNS Lookup – Finding the Server

Your browser needs to know where the server is physically located.

It asks a DNS server: “Hey, what’s the IP of example.com?”
The DNS responds with something like: 93.184.216.34
Now the browser knows which computer to contact.

Analogy: DNS is like the internet’s phonebook.

3. Browser Sends an HTTP Request

Once the server IP is found, the browser sends an HTTP request:

GET /page1 HTTP/1.1
Host: example.com

GET → We want to retrieve the page.

Host → Which website we’re asking.

4. Server Processes the Request

The server receives the request and decides what to send back:

HTML content of the page
CSS and JavaScript files
Images and media

The server then sends all of this back as an HTTP response.

5. Browser Renders the Page

When the browser gets the response:

It reads the HTML → creates a DOM tree.
It reads CSS → applies styles to the DOM.
It executes JavaScript → adds interactivity.
It displays the fully rendered page for you to see.

Analogy: Browser = chef 🍳, ingredients = HTML/CSS/JS, final dish = fully loaded webpage.

Final Thoughts

Clicking a link seems instant, but there’s a chain of events happening in milliseconds:

URL is read
DNS lookup finds the server
HTTP request is sent
Server responds with files
Browser renders everything

Next time you click a link, imagine your browser and the server working together like a well-coordinated team!

How Recursion Actually Works

Aditi Deshmukh — Wed, 15 Oct 2025 16:44:52 +0000

When I first learned recursion, it honestly felt like magic.
A function calling itself again and again? I could write it, but I didn’t really get how it worked behind the scenes.

*If you’ve ever felt that too — don’t worry. In this post, we’ll break down recursion step-by-step and see how the stack plays a hidden but crucial role.
*
---

What Is Recursion?

Recursion is when a function calls itself to solve a smaller version of the same problem.

Every recursive function needs two things:

1.Base case — the condition that stops the recursion
2.Recursive case — the part where the function calls itself again

Example: Finding Factorial Using Recursion

function factorial(n) {
  if (n === 1) {
    return 1; // Base case
  } else {
    return n * factorial(n - 1); // Recursive call
  }
}

console.log(factorial(5)); // Output: 120``

Behind the Scenes: The Stack in Action

_Each time a function runs, it’s placed on a call stack — a memory structure that follows Last In, First Out (LIFO).
So, the last function called is the first one to finish.
_

Step   | Function Call  | What Happens
-------|----------------|-------------------------
1      | factorial(5)   | Calls factorial(4)
2      | factorial(4)   | Calls factorial(3)
3      | factorial(3)   | Calls factorial(2)
4      | factorial(2)   | Calls factorial(1)
5      | factorial(1)   | Base case → returns 1

Now the stack unwinds:

Step   | Returning To   | Calculation
-------|----------------|----------------
6      | factorial(2)   | 2 × 1 = 2
7      | factorial(3)   | 3 × 2 = 6
8      | factorial(4)   | 4 × 6 = 24
9      | factorial(5)   | 5 × 24 = 120

Finally, the stack is empty — result: 120

Why the Stack Matters
The stack lets recursion pause each call until the next one finishes.
Imagine stacking plates in a cafeteria:
you add one plate per call, and when done, remove them from the top — one by one.

That’s exactly how recursion “returns” values.

Final Thoughts

Recursion isn’t magic — it’s just functions + a stack working together beautifully.
Once you understand that each call patiently waits on the stack, recursion becomes one of programming’s most elegant tools.

If recursion ever confuses you, just picture that stack of plates — it’ll click .

Thanks for reading!
If you enjoyed this post, follow me for more beginner-friendly programming blogs.