When debugging network issues on Linux, one of the most important commands is:

ip route

This command shows the routing table — the rules your system uses to decide where every network packet should go.

Let’s break down the following output in detail:

default via 192.168.1.1 dev wlp0s20f3 proto dhcp src 192.168.1.9 metric 600
192.168.1.0/24 dev wlp0s20f3 proto kernel scope link src 192.168.1.9 metric 600

No assumptions. No skipped words.

What a Routing Table Actually Is

A routing table is a list of instructions that answers one question:

“If a packet needs to go to this destination, which interface, gateway, and source IP should be used?”

Linux checks routes top-down, choosing the most specific match.

Line 1: The Default Route

default via 192.168.1.1 dev wlp0s20f3 proto dhcp src 192.168.1.9 metric 600

This line controls all traffic going outside your local network (internet traffic).

Word-by-word breakdown

• default
  • Matches any destination not covered by a more specific route
  • Used for internet traffic
• via
  • Indicates a gateway is required
• 192.168.1.1
  • The gateway IP
  • Usually your Wi-Fi router
• dev
  • Specifies the network interface
• wlp0s20f3
  • Wireless network interface name
  • (wl = wireless, rest is hardware naming)
• proto
  • Route origin
• dhcp
  • Route was added automatically by DHCP
  • Not manually configured
• src
  • Source IP address for outgoing packets
• 192.168.1.9
  • Your system’s IP address on this network
• metric
  • Route priority
  • Lower number = higher priority
• 600
  • Priority value used when multiple routes exist

Meaning in plain English

“For any destination not in the local network, send traffic through router 192.168.1.1 using Wi-Fi interface wlp0s20f3, with source IP 192.168.1.9.”

Line 2: The Local Network Route

192.168.1.0/24 dev wlp0s20f3 proto kernel scope link src 192.168.1.9 metric 600

This route handles local LAN traffic only.

Word-by-word breakdown

• 192.168.1.0/24
  • Destination subnet
  • Covers 192.168.1.1 → 192.168.1.254
  • /24 = subnet mask 255.255.255.0
• dev
  • Network interface used
• wlp0s20f3
  • Same Wi-Fi interface
• proto
  • Route origin
• kernel
  • Automatically added when interface came up
  • Not from DHCP or user config
• scope
  • Defines how far the route applies
• link
  • Destination is directly reachable
  • No gateway required
• src
  • Source IP for packets in this subnet
• 192.168.1.9
  • Your machine’s IP
• metric
  • Route priority
• 600
  • Same priority as default route

Meaning in plain English

“Any device inside 192.168.1.0/24 can be reached directly through Wi-Fi without using a router.”

Why Two Routes Are Needed

Linux needs both:

Without the local route → LAN breaks
Without the default route → Internet breaks

How Linux Chooses Between These Routes

Example: packet going to 192.168.1.50

• Matches 192.168.1.0/24
• Uses local route
• No gateway

Example: packet going to 8.8.8.8

• No specific subnet match
• Falls back to default route
• Uses router 192.168.1.1

Final Mental Model

Think of it like this:

• Local address? → send directly
• Anything else? → send to router
• Interface decides how
• Metric decides priority
• Source IP decides identity

You open a terminal.
You type a command.
You hit Enter.

Sometimes it works instantly.
Sometimes it hangs.
Sometimes it fails with no clear reason.

That moment — when Linux is “thinking” — is networking in action.

Let’s break down what actually happens when your Linux system talks to the internet, without buzzwords or textbook noise.

Step 1: Linux Doesn’t Know Names, Only Numbers

When you type:

google.com

Linux doesn’t understand that name.

It immediately asks:

“What is the IP address for this?”

This is DNS.

Linux checks the DNS servers listed in:

/etc/resolv.conf

If DNS fails:

• Websites won’t load
• Browsers show “No internet”
• But ping 8.8.8.8 might still work

This is why DNS issues feel confusing — the network is up, but name resolution is broken.

Step 2: Routing — Deciding Where Traffic Goes

Once Linux has the IP address, it needs to decide how to reach it.

That decision is made using the routing table:

ip route

A typical entry looks like:

default via 192.168.1.1 dev eth0

This means:

“If the destination isn’t local, send it to the router.”

If this route is missing or wrong, your system knows where it wants to go — but has no path to get there.

Step 3: Network Interfaces Are the Doors

Linux sends data through interfaces, not through “the internet”.

Common ones:

• eth0 – Ethernet
• wlan0 – Wi-Fi
• lo – Loopback (self communication)

You can check them with:

ip addr

If an interface is down, nothing leaves your system — even if everything else is configured perfectly.

This is why many network fixes start with:

ip link 

Step 4: Ports Decide Which Application Gets the Data

Your system doesn’t talk to the internet — applications do.

Ports are how Linux knows which app should receive data.

Examples:

• Web server → 80 / 443
• SSH → 22
• Database → 5432

You can see active ports using:

ss -tulnp

A common mistake:

• Service is running
• Port is open
• But it’s bound to 127.0.0.1

That means it works only locally, not from the outside world.

Step 5: Firewalls Can Block Everything Silently

Even if:

• The app is running
• The port is listening
• The route exists

Linux still asks:

“Is this traffic allowed?”

This is handled by the firewall:

• iptables
• nftables
• ufw

Firewalls don’t always say “blocked”.
They often just drop packets quietly.

That’s why networking bugs sometimes feel like ghosts.

Step 6: NAT — Why Your Private IP Works Online

Your Linux machine usually has a private IP like:

192.168.1.10

The internet never sees this.

Your router uses NAT (Network Address Translation) to:

• Replace private IPs with a public one
• Track which response belongs to which device

This is why:

• Port forwarding exists
• Containers need special rules
• Some services work internally but not externally

NAT is invisible — until it breaks.

Why Linux Networking Feels Hard (But Isn’t)

Linux networking is not one thing.

It’s a pipeline:

1. DNS → name to IP
2. Routing → path decision
3. Interface → exit door
4. Port → application
5. Firewall → permission
6. NAT → translation

If any one step fails, everything fails.

But once you understand this chain, debugging becomes logical — not magical.

Final Thought

Linux networking isn’t about memorizing commands.

It’s about understanding how Linux thinks:

• Where should this packet go?
• Who should receive it?
• Should it be allowed?

When you understand those questions, you stop guessing — and start fixing problems with confidence.

You open a website.
You enter your email and password.
You click Login.

And magically—you’re in.

No page refresh. No password sent again. You can reload the page, open a new tab, even close the browser and come back… still logged in.

Most people say:

“Yeah, that’s JWT.”

But what actually happens?

Let’s break it down in plain human language, step by step—no buzzwords, no fake complexity.

Step 1: You Send Your Credentials (Only Once)

When you click Login, your browser sends this to the server:

{
  "email": "[email protected]",
  "password": "secret123" 
} 

Important detail 👉 this is the only time your password is sent.

The server:

• Finds your user
• Verifies the password (usually via hashing)
• Decides: Yes, this user is legit

If the password is wrong → login fails
If correct → move to the next step

Step 2: The Server Creates a JWT

Instead of saving a session in memory (old-school way), the server creates a JWT (JSON Web Token).

Think of a JWT like a digitally signed ID card.

Inside the token:

• User ID
• Email / username
• Token expiry time
• Sometimes roles or permissions

Example (simplified):

{
  "user_id": 42,
  "email": "[email protected]",
  "exp": 1735689600 } 

This data is:

• Encoded
• Signed (so it can’t be tampered with)

🔐 The server signs it using a secret key only it knows.

Step 3: Token Is Sent Back to Your Browser

The server responds:

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." 
} 

Now your browser stores this token:

• Usually in localStorage
• Or cookies (more secure if done right)

From this moment on:
👉 Your token is your identity

Step 4: Every Request Includes the Token

Now when you request anything protected:

• /profile
• /notes
• /dashboard

Your browser automatically sends:

Authorization: Bearer <JWT_TOKEN> 

No password.
No login again.
Just the token.

Step 5: Server Verifies the Token (Every Time)

For each request, the server:

1. Checks the token signature
2. Verifies it hasn’t expired
3. Extracts user info
4. Allows or denies access

⚠️ No database lookup is required for sessions
That’s why JWT is called stateless authentication.

Why JWT Feels So Fast

Because:

• No session storage
• No server memory tracking
• No sticky sessions needed
• Easy to scale across multiple servers

This is why JWT is popular in:

• APIs
• Microservices
• Mobile apps
• SPAs (React, Vue, etc.)

The Part People Don’t Tell You

JWT is not magic. It has trade-offs.

❌ You Can’t “Log Out” Easily

Once issued, a JWT is valid until it expires.

Logout usually means:

• Deleting token on client
• Or maintaining a token blacklist (extra complexity)

❌ Token Theft Is Dangerous

If someone steals your token:
👉 They are you

That’s why:

• HTTPS is mandatory
• Tokens should expire quickly
• Refresh tokens must be protected

Access Token vs Refresh Token (Quickly Explained)

Good systems use two tokens:

Access Token

• Short-lived (5–15 minutes)
• Used on every request

Refresh Token

• Long-lived
• Used only to get a new access token

This way:

• Even if access token leaks, damage is limited
• Users stay logged in smoothly

When JWT Is a Bad Idea

JWT is NOT ideal if:

• You need instant logout everywhere
• You want simple auth for a small app
• You don’t understand token security well

In those cases:
👉 Traditional session-based auth is safer and simpler.

The Big Picture

JWT is not about being “modern”.
It’s about who carries the authentication state.

• Sessions → server remembers you
• JWT → you carry proof of who you are

Neither is wrong.
Both are tools.

Final Thought

If you understand this flow, you already know more JWT than most developers who use it daily.

If you’ve worked with modern web or mobile applications, you’ve probably heard this debate again and again:

“Should I use REST or GraphQL?”

Blogs, YouTube videos, and Twitter threads argue endlessly — but most explanations are either too shallow or overly technical.
Let’s break it down clearly, practically, and without hype.

What Is REST (In Simple Words)?

REST (Representational State Transfer) is an API design style where:

• Each resource has a fixed endpoint
• You use HTTP methods like GET,POST,PUT,DELETE
• The server decides the response structure

Example

GET /users/1 GET /users/1/posts

Each endpoint returns a predefined data shape.

Why REST Became Popular

• Easy to understand
• Simple to cache
• Works well with HTTP standards
• Supported everywhere

What Is GraphQL?

GraphQL is a query language for APIs where:

• There is usually one endpoint
• The client decides what data it wants
• The server returns exactly that

Example

{  user(id: 1) {    name    posts {      title    }  } } 

You get only what you ask for — nothing more, nothing less.

The Core Confusion: Overfetching vs Underfetching

This is where most people get stuck.

REST Problem

You often get:

• Too much data (overfetching)
• Too little data (underfetching → more API calls)

Example:
You want only a user’s name but get email, address, preferences, settings, etc.

GraphQL Solution

• Client controls the response
• One request can fetch deeply nested data
• No wasted bandwidth

REST vs GraphQL (Quick Comparison)

When REST Is the Better Choice

Use REST if:

• Your API is simple
• You want easy caching
• You’re building CRUD-heavy apps
• You need fast onboarding for developers

👉 Example: Blogs, admin dashboards, internal tools

When GraphQL Shines

Use GraphQL if:

• You have multiple clients (web, mobile, IoT)
• Your data is deeply connected
• Network performance matters
• Frontend needs flexibility

 Example: Social networks, large-scale SaaS apps

A Common Myth (Important)

“GraphQL will replace REST”
No. They solve different problems.

Many companies use:

• REST for public APIs
• GraphQL for internal or frontend-facing APIs

You don’t need to choose sides — choose use cases.

Final Verdict

Ask this one question before choosing:

Who should control the data shape — the server or the client?

• Server control → REST
• Client control → GraphQL

That’s it. Everything else is implementation detail.

Anime isn’t just entertainment — it’s storytelling at its peak. Whether you love intense action, emotional drama, or mind-bending plots, there’s an anime that will hook you instantly.

Below are my Top 105 picks  of must-watch anime, 

1. Attack on Titan
   Why watch: Dark, emotional, and unpredictable. A masterpiece of storytelling with deep political and moral themes.
2. Naruto Shippuden
   Why watch: One of the best character growth arcs ever. Friendship, sacrifice, and epic fights.
3. One Piece
   Why watch: World-building on another level. Emotional, adventurous, and endlessly rewarding.
4. Demon Slayer
   Why watch: Stunning animation + emotional storytelling. Easy to start, hard to stop.
5. Dragon Ball Z
   Why watch: The foundation of modern shonen anime. Pure nostalgia and iconic battles.

Most people focus on how many hours they sleep. But science says something even more important matters: waking up at the same time every day.

This one habit can quietly transform your energy, mood, focus, and even long-term health.

The Science Behind It

Your body runs on an internal clock called the circadian rhythm. When you wake up at a consistent time, this clock stays balanced. As a result:

• You fall asleep faster
• Your sleep quality improves
• Your brain feels sharper during the day

Irregular wake-up times confuse this system, leading to fatigue, brain fog, and poor concentration—even if you sleep long hours.

Why It Boosts Productivity

People who wake up at a fixed time experience:

• Better morning energy
• More stable focus
• Fewer mood swings

Your brain loves predictability. When it knows when the day starts, it performs better.

You Don’t Need to Wake Up Early

This isn’t about waking up at 5 AM. It’s about choosing a time and sticking to it—even on weekends. Consistency matters more than the clock.

The Small Habit With Big Returns

You don’t need expensive supplements, extreme routines, or complicated hacks. Just one decision made daily can improve sleep, mental clarity, and overall well-being.

Sometimes, the most powerful changes are the simplest ones.

In a world full of notifications, short videos, and endless scrolling, our attention span is shrinking fast. One simple habit is proving to be a powerful antidote: daily note-taking.

Writing notes isn’t just about remembering things — it actually trains your brain to think better.

Why Note-Taking Works

When you write something down, your brain processes information more deeply than when you just read or hear it. This improves memory, focus, and clarity. That’s why students, writers, and high performers rely on notes to organize ideas and reduce mental overload.

Notes Turn Ideas Into Action

Ever had a great idea and forgot it later? Notes capture thoughts before they disappear. Over time, your notes become a personal knowledge base — a place where small ideas grow into plans, stories, or solutions.

Digital Notes, Smarter Thinking

Modern note-taking tools allow you to:

• Organize thoughts into folders or categories
• Search ideas instantly
• Share knowledge with others
• Turn private notes into public insights

This makes writing not just personal, but powerful.

The Real Secret

You don’t need long essays or perfect words. Even rough notes written daily can improve thinking, creativity, and productivity. Five minutes a day is enough to see results.

If you want a sharper mind and a calmer head, start writing — one note at a time.

Most people think writing is for authors, poets, or someone with a big story to tell. But the truth is—writing is for anyone who feels too much, thinks too deeply, or simply doesn’t want to forget who they are becoming.

When you write things down, something strange and beautiful happens. Your thoughts slow down. Your chaos gets a shape. What felt heavy in your head suddenly feels lighter on the page.

You don’t need perfect words. You don’t need grammar or a plan. Some of the best writing starts as rough notes, half-finished thoughts, or sentences that don’t make sense yet. That’s where honesty lives.

Writing is a quiet conversation with yourself. It helps you remember ideas, heal emotions, and sometimes discover answers you didn’t know you were looking for. And when you choose to share it, your words might help someone else feel less alone.

So write—without pressure. Write to remember, to heal, to imagine, or just to breathe a little better.

Your words matter, even if no one else sees them. And sometimes, especially then. 

okokokokokokokokokokokok