You know the usual ones:

• click

• input

• submit

• scroll

• maybe keydown

And honestly? My work was getting done. Projects were shipping. Clients were happy.

So in my head, the logic was simple:

“If these events are enough to build websites, why even bother learning the rest?”

Turns out… that mindset was lazy 😅 And I didn’t realize it until very recently.

How I Ended Up Discovering This

This whole realization started in a very normal way.

I was going through a GitHub repository, just reading someone else’s code. No tutorial, no blog - just raw production code. And that’s when I noticed event listeners I had literally never used before.

Stuff like:

• visibilitychange

• pointer events

• animation and transition events

At first, I ignored it.

Because deep down, I already knew JavaScript has a lot of events. I just assumed:

“Yeah yeah, those are probably edge-case events. I don’t really need them.”

But then I paused and thought:

What if I’m solving problems the hard way, while JavaScript already gives me better tools?

What if some things I’m doing with hacks, timers, or heavy logic could be done more cleanly using the right event?

That’s when I decided to dig deeper.

The Big Realization

JavaScript doesn’t just react to clicks or inputs.

It literally listens to:

• user actions

• browser state

• network changes

• page visibility

• animations

• media playback

• device input

• even tab switching

• system behavior

Basically, JavaScript is always watching 👀 You just need to know what to listen for.

Categories of JavaScript Events (The Eye-Opener)

I’m not going to dump every single event here - that would be insane. But here’s a mental map that completely changed how I see events.

🖱️ Mouse Events

These are the basics, but there’s more than just click.

• click

• dblclick

• mouseenter / mouseleave

• mouseover / mouseout

• contextmenu (right click)

Useful for hover effects, menus, tooltips, custom interactions.

⌨️ Keyboard Events

• keydown

• keyup

Great for shortcuts, accessibility, power-user features.

✍️ Form & Input Events

• input

• change

• focus

• blur

• submit

These control almost every form interaction you see on the web.

📜 Scroll & Viewport Events

• scroll

• resize

• wheel

Still useful, but many scroll-based problems are now better solved with Intersection Observer instead of raw scroll.

🌐 Network Events

Yes, this exists.

• online

• offline

You can literally detect when the user loses or regains network and update UI accordingly.

👁️ Page Visibility & Lifecycle

These are criminally underrated.

• visibilitychange

• pageshow

• pagehide

• beforeunload

Perfect for:

• pausing videos

• stopping timers

• saving state

• analytics accuracy

📦 Drag & Drop

• dragstart

• dragover

• drop

• dragend

Used for file uploads, dashboards, reorderable lists, You must have used these in drag & drop.

📱 Touch & Pointer Events

Instead of separating mouse and touch, modern browsers give:

• pointerdown

• pointermove

• pointerup

• gotpointercapture

• lostpointercapture

One API → mouse, touch, pen.

🎬 Animation & Transition Events

These blew my mind a bit.

• animationstart

• animationend

• transitionend

You can literally react to CSS finishing its job instead of guessing with timeouts.

🎧 Media Events

For audio & video:

• play

• pause

• ended

• timeupdate

• volumechange

• trackchange

Used heavily in modern media-heavy websites.

🧠 Page, Browser & System Level

These events are about browser state, not UI clicks.

• visibilitychange
  Fires when the tab becomes hidden or visible.

• pageshow / pagehide
  Triggered when navigating back/forward (especially with bfcache).

• beforeunload
  Fired before the user leaves the page.

• storage
  Fired when localStorage changes in another tab.

Why This Actually Matters

This isn’t about memorizing event names.

It’s about this shift in mindset:

Instead of forcing logic with hacks, ask yourself: “Is there already an event for this?”

Chances are - yes, there is.

Using the right event:

• simplifies code

• improves performance

• makes behavior more predictable

• reduces bugs

You Don’t Need to Know Them All (Seriously)

Let’s be real - nobody remembers all JavaScript events.

And that’s completely fine.

What does matter is:

• knowing these events exist

• knowing where to look when needed

Where You Should Learn Them Properly

If you really want to explore events in depth:

• 📘 MDN Web Docs Best place to understand what each event does, with examples.

• 🌍 Can I Use Always check browser support before using advanced or newer events

There are many more events than the ones mentioned in this blog.
If you’re curious, definitely explore the full MDN list here:

👉 https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Events

👉 https://developer.mozilla.org/en-US/docs/Web/API/Window#events

But how do two devices talk directly over the internet?

The secret behind all of this is WebRTC.

In this blog, we’ll break down WebRTC from the ground up:

• What WebRTC really does
• What Signaling, SDP, and ICE are
• What Host, STUN, and TURN candidates are
• Why NAT creates problems
• Why mobile network users are always behind NAT
• And why TURN sometimes becomes mandatory

By the end, you’ll understand WebRTC like a pro.

What is WebRTC?

WebRTC (Web Real-Time Communication) is a technology that allows browsers and apps to communicate peer-to-peer without needing a server in the middle for audio/video/data transfer.

WebRTC makes possible:

• Video calling
• Voice calling
• Live screen sharing
• File transfer
• Real-time chat (via DataChannel)

Once the connection is established → the data flows directly between devices.

But establishing that connection is the tricky part.

Why Peer-to-Peer Is So Hard?

Because almost every device on the internet is behind a NAT.

It doesn’t matter if you're using:

• Home WiFi
• Broadband
• Mobile data (SIM)
• Corporate network
• Public WiFi

All of these use some type of NAT or firewall.

To bypass this, WebRTC depends on:

• Signaling
• SDP (Offer/Answer)
• ICE (Connectivity process)
• ICE Candidates (Host / STUN / TURN)

1) What is Signaling?

Signaling is how two devices exchange the initial information needed to start a WebRTC connection.

This includes:

• Their SDP
• Their ICE candidates
• Their media settings
• Their "Hey, I want to connect" messages

Signaling is not part of WebRTC itself — it’s just the method of sending messages between peers.

You can use:

• WebSocket
• Socket.io
• Firebase
• REST API
• Even manual copy-paste (for testing)

Once both devices exchange the required info → signaling is done.

flowchart LR
    A[Device A] -->|Offer SDP + ICE| S(Signaling Server)
    S -->|Forward| B[Device B]
    B -->|Answer SDP + ICE| S
    S -->|Forward| A
    classDef peer fill:#4da6ff,stroke:#333,stroke-width:1px;
    class A,B peer

2) What is SDP?

SDP (Session Description Protocol) is a long text description containing:

• Audio/Video codecs
• Encryption details
• Number of media tracks
• DataChannel info
• Network capabilities
• Offer/Answer details

SDP basically tells:

“Here is how I want to communicate. Tell me how you want to respond.”

WebRTC uses:

• Offer SDP → created by the first device
• Answer SDP → created by the second device

Without SDP, devices won’t understand each other’s capabilities.

sequenceDiagram
    participant A as Device A
    participant S as Signaling Server
    participant B as Device B

    A->>S: Offer SDP
    S->>B: Offer SDP
    B->>S: Answer SDP
    S->>A: Answer SDP

3) What is ICE?

ICE = Interactive Connectivity Establishment

It’s a smart process WebRTC uses to discover:

• How devices can reach each other
• Which path is the fastest
• Which path is even possible

ICE collects different candidates (possible connection routes).

There are 3 types:

1. Host Candidate → local network address
2. STUN Candidate → public IP address
3. TURN Candidate → relay server (last resort)

ICE tests all possibilities and automatically selects the best one.

flowchart TD
    subgraph Candidates
      H[Host Candidate]
      S[STUN Candidate]
      T[TURN Candidate]
    end

    A[Device A] -->|gathers| H
    A -->|gathers| S
    A -->|gathers| T
    B[Device B] -->|gathers| H
    B -->|gathers| S
    B -->|gathers| T

    H -- fastest --> Direct[Direct P2P]
    S -- possible --> Direct
    T -- relay --> Relay[TURN Relay]

4) ICE Candidate Types Explained

A) Host Candidates

These are local IP addresses, like:

• 192.168.x.x
• 10.x.x.x

Used when both devices are:

• On the same WiFi
• On the same LAN

Fastest possible connection.

B) STUN Candidates

A STUN server’s job:

“Tell me what my public IP looks like on the internet.”

Because NAT hides your real public address, STUN helps your device discover it.

Used for normal real-world P2P.

But STUN can fail on:

• Strict firewalls
• Mobile networks
• Corporate networks

sequenceDiagram
    participant C as Client
    participant ST as STUN Server

    C->>ST: Binding request ("what is my public IP?")
    ST-->>C: Binding response (public IP:port)

C) TURN Candidates (Relay)

If direct P2P is impossible, a TURN server becomes a relay:

Device A → TURN → Device B

TURN is slower but guarantees connection.

Required in:

• Mobile data networks
• Corporate networks
• Public WiFi
• CGNAT (Carrier-grade NAT)
• Very strict firewalls

TURN is the last hope of WebRTC.

flowchart LR
    classDef peer fill:#4da6ff,stroke:#222,stroke-width:1px,color:#000;

    A[Device A]:::peer -->|Encrypted Media| TURN[TURN Server]:::peer
    TURN -->|Encrypted Media| B[Device B]:::peer

    Note["TURN relays RTP/DTLS packets"]:::peer
    TURN -.-> Note

NAT in Mobile Data (SIM Internet)

Most people think:

“I don’t have a router, so I don’t have NAT.”

Wrong.

Mobile networks use a massive NAT system called:

CGNAT (Carrier-Grade NAT)

Your phone actually gets a private IP like 10.x.x.x, not a real public IP.

Millions of users share a few public IPs.

This makes mobile networks extremely strict:

• Direct P2P usually fails
• STUN candidates may not work
• TURN becomes necessary

This is why WebRTC sometimes struggles on 4G/5G networks without TURN.

    flowchart LR
Phone["Mobile Phone (10.x.x.x)"] -->|private| CGN["Carrier NAT"]
CGN -->|shared public| Internet["Public Internet"]
Internet -->|routes| Service["Remote Peer"]

Note["Millions of phones share a few public IPs"]
CGN -.-> Note

classDef box fill:#4da6ff,stroke:#222,stroke-width:1px,color:#000;
class Phone,CGN,Internet,Service,Note box;

ICE Connectivity Check (how candidates are tested)

sequenceDiagram
    participant A as Device A
    participant B as Device B

    A->>B: STUN connectivity check (candidate pair)
    B-->>A: STUN success
    A->>B: Confirm and switch media path

This process repeats across candidate pairs until a working pair is found.

Summary

Conclusion

WebRTC is incredibly powerful — enabling P2P communication without needing a central media server.

But to make this work, it must deal with:

• NAT
• Firewalls
• Mobile network restrictions
• Different internet conditions

That’s why WebRTC uses:

• SDP
• ICE
• STUN
• TURN

Together, they create a stable P2P connection under almost every condition.

Windows

• Download installer from the GitHub CLI releases

• Or install via Scoop:

scoop install gh

• Or via Chocolatey:

choco install gh

macOS

• Install via Homebrew:

brew install gh

Linux

• Debian/Ubuntu:

sudo apt install gh

• Fedora:

sudo dnf install gh

• Arch Linux:

sudo pacman -S github-cli

2. Authenticate with GitHub

Run:

gh auth login

• Select GitHub.com or GitHub Enterprise.

• Choose HTTPS or SSH as preferred.

• Use a personal access token or OAuth for authentication.

Verify authentication:

gh auth status

3. Basic Commands

• Version Check:

gh --version

• Configure Editor:

gh config set editor "vim"

4. Working with Repositories

• Create a New Repository:

gh repo create my-new-repo --public

• Clone a Repository:

gh repo clone /

• View Repository Details:

gh repo view my-repo --web

5. Managing Issues

• List Issues:

gh issue list

• Create a New Issue:

gh issue create --title "Bug in login system" --body "User cannot log in with valid credentials."

• View Issue Details:

gh issue view

6. Managing Pull Requests (PRs)

• List Pull Requests:

gh pr list

• Create a New PR:

gh pr create --title "Fix memory leak" --body "This PR fixes the memory leak in X module."

• View PR Details:

gh pr view

• Merge a PR:

gh pr merge --merge

7. Managing Gists

• Create a New Gist:

gh gist create file.txt --public

• List Gists:

gh gist list

• View a Gist:

gh gist view

8. GitHub Actions and Workflows

• List Workflow Runs:

gh run list

• View a Specific Workflow Run:

gh run view

• Trigger a Workflow:

gh workflow run

9. GitHub CLI Aliases

• Create an Alias:

gh alias set myrepos 'repo list --limit 10'

10. Logging Out

• Log Out:

gh auth logout

🛠️ Step 1: Update and Upgrade System

sudo apt update && sudo apt upgrade -y

📌 What to Do: Keep your system up to date with this single command.

🌐 Step 2: Install Apache

sudo apt install apache2 -y

📌 What to Do: Install Apache, the web server.

• Check Apache Status:

sudo systemctl status apache2

• Test Apache:
  Open your browser and navigate to http://your-server-ip to see the Apache default page.

🐬 Step 3: Install MySQL

sudo apt install mysql-server -y

📌 What to Do: Install MySQL for database management.

• Secure MySQL:

sudo mysql_secure_installation

👉 Detailed Guide: MySQL Secure Installation

• Login to MySQL:

sudo mysql

💻 Step 4: Install PHP

sudo apt install php libapache2-mod-php php-mysql -y

📌 What to Do: Install PHP and its modules.

• Test PHP:

  • Create a test file:

      sudo nano /var/www/html/info.php
    

  • Add the following code:

      <?php
      phpinfo();
      ?>
    

  • Visit http://your-server-ip/info.php in your browser to confirm PHP installation.

🛡️ Step 5: Adjust Firewall (Optional)

sudo ufw allow in "Apache Full"

📌 What to Do: Allow Apache through the firewall for proper access.

🔄 Step 6: Enable Modules and Restart Apache

sudo a2enmod rewrite  
sudo systemctl restart apache2

📌 What to Do: Enable Apache modules for better functionality.

✅ Step 7: Verify Installation

• Apache: Navigate to http://your-server-ip in your browser.

• PHP Info: Navigate to http://your-server-ip/info.php in your browser.

📊 Optional: Install phpMyAdmin

sudo apt install phpmyadmin -y

📌 What to Do: Install phpMyAdmin to manage MySQL databases via a web interface.

• Configure: Follow the installation prompts and integrate it with Apache.

• Access: Visit http://your-server-ip/phpmyadmin in your browser.

🎉 Congratulations! Your LAMP stack is ready to use.

📌 1. List – Ordered & Duplicates Allowed

Think of a List as a VIP guest list at a party. Everyone comes in a specific order, and duplicates are totally fine. You can add, remove, and find elements at specific positions.

🍕 ArrayList<E> – The Fast One

• Best for: Fast random access, but slow insertions/removals.

• Think of it as: A resizable array.

Common Methods:

ArrayList<String> list = new ArrayList<>();
list.add("A");          // Adds at the end
list.add(1, "B");       // Adds at index 1
list.get(0);            // Returns "A"
list.set(1, "C");       // Replaces "B" with "C"
list.remove(1);         // Removes index 1
list.contains("A");     // Returns true
list.indexOf("A");      // Returns index of "A"
list.lastIndexOf("A");  // Returns last occurrence of "A"
list.isEmpty();         // Returns true if empty
list.size();            // Returns size
list.clear();           // Removes all elements

🛤 LinkedList<E> – The Smooth Operator

• Best for: Fast insertions/deletions, but slow random access.

• Think of it as: A train with connected compartments.

Common Methods:

LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(10);  
linkedList.addFirst(5);  // Adds at the beginning
linkedList.addLast(20);  // Adds at the end
linkedList.get(1);       // Returns element at index 1
linkedList.removeFirst(); // Removes first element
linkedList.removeLast();  // Removes last element
linkedList.peekFirst();   // Returns first element without removing
linkedList.peekLast();    // Returns last element without removing
linkedList.isEmpty();     // Returns true if empty
linkedList.size();        // Returns size

📌 2. Set – Unique Elements Only (No Duplicates Allowed!)

A Set is like your ex’s blocklist—every name is unique, and order doesn't matter (except for TreeSet).

🔥 HashSet<E> – The Speed Demon

• Best for: Super-fast searches.

• Think of it as: A randomly ordered bag of unique elements.

Common Methods:

HashSet<String> set = new HashSet<>();
set.add("Java");       // Adds element
set.add("Python");
set.remove("Java");    // Removes "Java"
set.contains("Python"); // Returns true
set.isEmpty();         // Returns true if empty
set.size();            // Returns number of elements
set.clear();           // Removes all elements

🌲 TreeSet<E> – The Sorted Scholar

• Best for: When you need elements in sorted order.

• Think of it as: A self-sorting list.

Common Methods:

TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(10);
treeSet.add(5);
treeSet.add(20);
treeSet.first();     // Returns smallest element (5)
treeSet.last();      // Returns largest element (20)
treeSet.higher(10);  // First element greater than 10
treeSet.lower(10);   // First element smaller than 10
treeSet.remove(5);   // Removes 5

📌 3. Map – Key-Value Storage

A Map is like a real-life dictionary—you look up a key to find its value.

🗺 HashMap<K, V> – The Fast Look-up Boss

• Best for: Fast key-value lookups, but unordered.

• Think of it as: A messy but super-fast key-value storage.

Common Methods:

HashMap<Integer, String> map = new HashMap<>();
map.put(1, "One");        // Adds key-value pair
map.put(2, "Two");
map.get(1);               // Returns "One"
map.remove(2);            // Removes key 2
map.containsKey(1);       // Returns true
map.containsValue("Two"); // Returns false (since we removed it)
map.keySet();             // Returns all keys
map.values();             // Returns all values
map.entrySet();           // Returns key-value pairs
map.getOrDefault(10, "Not Found");  // If key 10 not present, returns "Not Found"

🌳 TreeMap<K, V> – The Sorted Organizer

• Best for: Keeping keys sorted.

• Think of it as: A well-organized, auto-sorting dictionary.

Common Methods:

TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(3, "Three");
treeMap.put(1, "One");
treeMap.put(2, "Two");
treeMap.firstKey();   // Returns 1
treeMap.lastKey();    // Returns 3
treeMap.higherKey(2); // Returns 3 (next larger key)
treeMap.lowerKey(2);  // Returns 1 (previous smaller key)
treeMap.remove(1);    // Removes key 1
treeMap.getOrDefault(10, "Not Found");  // If key 10 not present, returns "Not Found"

📌 4. Queue & Stack – FIFO & LIFO Masters

🎟 Queue<E> – The Waiting Line

• Best for: First-In-First-Out (FIFO) operations.

Common Methods:

Queue<String> queue = new LinkedList<>();
queue.add("A");   // Adds to queue
queue.poll();     // Removes and returns front element
queue.peek();     // Shows front element without removing
queue.size();     // Returns queue size

🎯 PriorityQueue<E> – The Smart Sorter

• Best for: When you need automatic sorting while inserting elements.

• Think of it as: A VIP entry system—smallest (or largest) element always gets out first!

Common Methods:

PriorityQueue<Integer> pq = new PriorityQueue<>(); // Min-Heap (Default)
pq.add(5);
pq.add(1);
pq.add(3);
pq.poll();    // Removes & returns the smallest element (1)
pq.peek();    // Shows the smallest element without removing (3)
pq.size();    // Returns size
pq.isEmpty(); // Checks if empty

// Max-Heap using Comparator
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
maxHeap.add(5);
maxHeap.add(1);
maxHeap.add(3);
maxHeap.poll(); // Removes & returns the largest element (5)

💡 Default = Min-Heap (smallest comes out first). If you want a Max-Heap, use Collections.reverseOrder(). 🚀

🧱 Stack<E> – The Last-Minute Cramming Machine

• Best for: Last-In-First-Out (LIFO) operations.

Common Methods:

Stack<String> stack = new Stack<>();
stack.push("Book");   // Adds to stack
stack.pop();         // Removes and returns top element
stack.peek();        // Shows top element without removing
stack.size();        // Returns stack size

📊 Master Table – Java Collections at a Glance

🤩 Bonus Table – Similar Methods Across Collections

😎 Wrap-Up

And that's a wrap on Java Collections! 🚀 Now, whether you're dealing with lists, sets, maps, queues, or stacks, you've got this handy cheat sheet to refer to anytime. Bookmark it, star it, share it! 🎯

If you want to fully understand Java classes, objects, and linked list references, this blog is for you.
I used to be confused about when to use new and how references work. Let’s clear it using the box analogy.

The new keyword

Node n = new Node(10);

• Right side (new Node(10)) → creates a new box (object) in memory with data=10 and next=null

• Left side (n) → a reference variable storing the box’s address

Analogy:
n holds the address of a box with 10 inside.

[ data=10 | next=null ]  <-- box
       ^
       |
       n

Reference without new

Node temp = head;

• No new box is created.

• temp just copies the address that head has.

• Both head and temp point to the same object.

[ data=5 | next=null ]  <-- box
       ^       ^
       |       |
      head    temp

Linked List Example

Node head = new Node(5);      // new box1
Node temp = head;             // temp points to box1
temp.data = 20;               // update box1's data
temp.next = new Node(30);     // create new box2 and link it

Memory:

[ data=20 | next--> ]  <-- box1
       ^       ^
       |       |
      head    temp
                 \
                  [ data=30 | next=null ]  <-- box2

Linked List:

head → 20 → 30 → null

Rule of Thumb

• Use new → When you want a new object/box

• Do not use new → When you want to point to an existing object/box

Tricky Example

Node temp = head;
temp = new Node(50);

• temp now points to a new box

• head still points to the old box

Conclusion

1. new = create new box

2. No new = copy existing box’s address

3. Linked list traversal uses references, insertion uses new

TL;DR

Understanding Java references and new keyword is just about knowing the difference between a box’s content and its address.

• new = create fresh box

• Reference = point to existing box