DEV Community: Nishant Gaurav

20 JS Features That Already Exist — Stop Writing the Polyfill

Nishant Gaurav — Thu, 05 Mar 2026 06:14:53 +0000

Let me be upfront about something.

I was reviewing a PR last month — someone on my team had written a 14-line groupBy helper function, complete with JSDoc comments and unit tests. Solid code, honestly. Clean. Well-tested.

It was also completely unnecessary. Object.groupBy() has been in the language since 2024.

Nobody blamed him. I'd done the same thing myself six months earlier. That's just how it goes with JavaScript — the language keeps moving, and unless you're actively tracking TC39 proposals, you end up writing polyfills for things that already exist natively.

So this is that post. The one I wish someone had handed me.

I'm covering 20 features from ES2021 through ES2025. Some of them you've probably seen. Others are the kind of thing where you read the example and immediately start thinking about three places in your current project where you've been doing it the hard way.

Fair warning: I'm skipping the obvious stuff. No optional chaining (?.), no nullish coalescing (??). Those have been around long enough that they're basically table stakes at this point. Everything here is from 2021 or newer.

Let's go.

ES2021 — The Underappreciated Year

1. Logical Assignment Operators (`&&=`, `||=`, `??=`)

I genuinely don't understand why these don't get more attention.

You've almost certainly written this:

// Assign default only if value is null or undefined
if (user.preferences == null) {
  user.preferences = {};
}

Or this variation that looks clever until you realize it has a subtle bug with falsy values:

user.role = user.role || "viewer";

Now there are three operators that handle these exact cases, following the same mental model as += or -=:

user.preferences ??= {};       // only assign if null/undefined
config.debug &&= isDevMode();  // only assign if left side is truthy
settings.theme ||= "dark";     // assign if left side is falsy

The ??= one is the real gem. It respects the difference between "this value is missing" versus "this value happens to be false or zero" — which ||= doesn't. If you've ever had a bug because || was eating a valid 0 or false, you know exactly what I mean.

2. WeakRef and FinalizationRegistry

Okay, this one is niche. I'll admit that upfront.

Most frontend developers will never need this. But if you've ever built something like a component tree, an in-memory cache, or anything involving large objects with potentially complex lifetimes — read on.

const cache = new Map();

function remember(key, obj) {
  cache.set(key, new WeakRef(obj));
}

function recall(key) {
  const ref = cache.get(key);
  return ref?.deref(); // returns the object, or undefined if GC'd
}

WeakRef lets you hold a reference to an object without preventing it from being garbage collected. If the object gets cleaned up, deref() returns undefined. No crashes. No memory leaks.

FinalizationRegistry pairs with it — you register a callback that fires after an object is collected:

const registry = new FinalizationRegistry((label) => {
  console.log(`${label} was garbage collected`);
});

registry.register(bigObject, "my-big-object");

MDN has a very honest warning about this: don't use it for critical application logic. GC timing is non-deterministic. But for caches, event tracking, or debug tooling? Really useful.

ES2022 — The Foundation Everyone Built On

3. Top-Level `await`

Before this, using await at the top level of a file meant wrapping everything in an immediately-invoked async function:

// The old tax you had to pay
(async () => {
  const config = await loadConfig();
  startApp(config);
})();

Now:

const config = await loadConfig();
startApp(config);

That's it. It only works inside ES modules (files with type: "module" or .mjs extension), but that's increasingly the default anyway.

What I like most about this is how it cleans up initialization code. Config loading, database connections, feature flag fetches — all the stuff that happens before your app is "ready" — can now be written as flat, readable code instead of callback pyramids.

4. Private Class Fields (`#`)

JavaScript has always had "private" fields in the same way that a diary with "PRIVATE" written on the cover is private. Technically nothing stops anyone from reading it.

class ApiClient {
  _secret = "totally-not-private"; // anyone can do client._secret
}

Private class fields with # are actually private. The runtime enforces it:

class ApiClient {
  #apiKey;

  constructor(key) {
    this.#apiKey = key;
  }

  makeRequest(endpoint) {
    return fetch(endpoint, {
      headers: { Authorization: `Bearer ${this.#apiKey}` }
    });
  }
}

const client = new ApiClient("abc123");
console.log(client.#apiKey); // SyntaxError — genuinely inaccessible

You can also have private methods (#doSomething()) and private static fields. If you're writing class-based code and doing anything sensitive, this is worth adopting.

5. `Error.cause`

Here's a pattern that's saved me hours of debugging:

async function loadUserProfile(userId) {
  try {
    const raw = await db.query("SELECT * FROM users WHERE id = ?", [userId]);
    return parseUserData(raw);
  } catch (err) {
    throw new Error(`Failed to load profile for user ${userId}`, {
      cause: err
    });
  }
}

The cause property chains errors together. When you log the outer error, you can inspect .cause to find the original one. No more "something failed" errors with zero context about why.

This pairs really well with structured logging. In production systems where you're shipping errors to Datadog or Sentry, the full cause chain shows up cleanly rather than getting swallowed.

6. `Object.hasOwn()`

Short one, but worth knowing.

// What we used to write — and yes, this is as ugly as it looks
if (Object.prototype.hasOwnProperty.call(obj, "key")) { ... }

// What we write now
if (Object.hasOwn(obj, "key")) { ... }

The reason the old way was so verbose is that hasOwnProperty can be overridden on objects, and on objects created with Object.create(null) it doesn't exist at all. Object.hasOwn() bypasses all of that. Same behavior, no footguns.

7. `.at()` — Relative Array Indexing

const scores = [88, 92, 71, 95, 83];

// Before
const last = scores[scores.length - 1];

// Now
const last = scores.at(-1);   // 83
const second = scores.at(-2); // 95

Negative indices count from the end. Works on arrays, strings, and TypedArrays.

The main complaint I see about .at() is that it returns undefined rather than throwing when you go out of bounds — which is the same behavior as bracket notation, so this isn't really new territory.

8. `structuredClone()`

This one deserves way more attention than it gets.

The old approach to deep-cloning objects in JavaScript was a hack that everyone used and nobody was proud of:

const deepCopy = JSON.parse(JSON.stringify(original));

That works until your object contains a Date (gets stringified), a Map (silently becomes {}), a Set (same), a function (gets dropped), or anything circular (throws).

structuredClone() handles all of this:

const clone = structuredClone(original);

Preserves Dates, Maps, Sets, ArrayBuffers, RegExps. Handles circular references. Works in browsers and Node.js. No libraries needed.

The only things it won't clone are functions, DOM nodes, and class instances (it copies the data but loses the prototype). For plain data objects — which is most of what you're actually cloning — it's exactly what you need.

ES2023 — The Immutability Push

9. `toSorted()`, `toReversed()`, `toSpliced()`

The original sort(), reverse(), and splice() all mutate in place. This has caused so many subtle bugs in codebases that tracking one down is practically a rite of passage.

const original = [3, 1, 4, 1, 5, 9];

// Old way — mutates original, easy to forget
const sorted = [...original].sort((a, b) => a - b);

// New way — original is untouched
const sorted = original.toSorted((a, b) => a - b);
const reversed = original.toReversed();
const spliced = original.toSpliced(2, 1, 99); // replaces index 2 with 99

These are particularly valuable in React and other state-driven frameworks where mutating state directly causes rendering bugs. You can now pass array data around without having to defensively clone everything before operating on it.

10. `.with()` — Immutable Index Assignment

This is the one most people miss completely from ES2023.

toSorted() and toReversed() are the non-mutating versions of sort() and reverse(). .with() is the non-mutating version of direct index assignment.

const prices = [10, 20, 30, 40];

// Old way to update one element without mutating
const updated = prices.map((price, i) => i === 2 ? 99 : price);

// New way
const updated = prices.with(2, 99);
// prices is still [10, 20, 30, 40]
// updated is [10, 20, 99, 40]

One line. No spread. No map. No mutation. In Redux reducers or any immutable update pattern, this is a nice quality-of-life improvement.

11. `findLast()` and `findLastIndex()`

find() searches from the start. Sometimes you want the last match.

const events = [
  { type: "click", time: 100 },
  { type: "scroll", time: 200 },
  { type: "click", time: 300 },
  { type: "scroll", time: 400 },
];

// Old way — reverses array first (and mutates without the spread)
const lastClick = [...events].reverse().find(e => e.type === "click");

// New way
const lastClick = events.findLast(e => e.type === "click");
// { type: "click", time: 300 }

The old approach had two problems: it mutated (hence the spread), and the intent wasn't immediately obvious. findLast() just says what it means.

ES2024 — Async and Data Handling

12. `Promise.withResolvers()`

Before this, if you needed to resolve or reject a promise from outside its own constructor — a common pattern in event-driven code — you had to do something like this:

let resolve, reject;
const promise = new Promise((res, rej) => {
  resolve = res;
  reject = rej;
});

That let hanging out there always felt wrong. The assignment inside the callback is a side effect that's easy to miss.

const { promise, resolve, reject } = Promise.withResolvers();

Same thing, but explicit. Useful for wrapping callback-based APIs, building queues, or coordinating async state between components.

13. `Object.groupBy()`

Let me give the full before/after:

const transactions = [
  { id: 1, type: "credit", amount: 500 },
  { id: 2, type: "debit", amount: 200 },
  { id: 3, type: "credit", amount: 150 },
  { id: 4, type: "debit", amount: 75 },
];

// Old way
const grouped = transactions.reduce((acc, t) => {
  (acc[t.type] ??= []).push(t);
  return acc;
}, {});

// New way
const grouped = Object.groupBy(transactions, t => t.type);
// {
//   credit: [{ id: 1, ... }, { id: 3, ... }],
//   debit:  [{ id: 2, ... }, { id: 4, ... }]
// }

The reduce version isn't wrong. But it requires you to slow down and parse it. groupBy communicates intent instantly.

There's also Map.groupBy() for when you need non-string keys.

14. `Array.fromAsync()`

Array.from() converts iterables into arrays. Array.fromAsync() does the same for async iterables.

async function* streamLines(url) {
  const response = await fetch(url);
  for await (const line of response.body.getReader()) {
    yield line;
  }
}

const lines = await Array.fromAsync(streamLines("https://example.com/data.txt"));

Before this, collecting an async iterable into an array meant writing a for await loop and pushing manually. Not difficult, but boilerplate you shouldn't have to write. More useful in Node.js environments than in the browser — streams, file reading, any async data source that yields over time.

15. `Promise.try()`

The gap this fills is small but real.

Sometimes you call a function not knowing if it's synchronous or asynchronous. If it's sync and it throws, you want that caught as a rejected promise. If it's async, you want the rejection from the promise itself. Making both behave the same way used to require a wrapper:

// Old way to unify sync/async error handling
Promise.resolve()
  .then(() => mightBeAsyncOrMightThrow())
  .catch(handleError);

// New way
Promise.try(() => mightBeAsyncOrMightThrow())
  .catch(handleError);

Promise.try() is just more explicit about what you're doing — wrapping a call in a promise context to normalize error handling.

ES2025 — JavaScript Gets Serious About Functional Patterns

16. Iterator Helpers

This is the one that takes a little explaining, but it's worth it.

When you chain .map() and .filter() on arrays, JavaScript builds a complete new array at each step:

const result = bigArray
  .map(transform)    // new array: full length
  .filter(keep)      // another new array
  .slice(0, 10);     // yet another one

If bigArray has 100,000 elements and you only need 10 results, you've done a lot of unnecessary work.

Iterator helpers process lazily — each element goes through the whole pipeline before the next one starts, and processing stops the moment you have enough:

const result = bigArray.values()
  .map(transform)
  .filter(keep)
  .take(10)
  .toArray();

Same output. No intermediate arrays. The take(10) means the moment you have 10 results, everything stops.

Other available helpers: .drop(), .flatMap(), .forEach(), .reduce(), .some(), .every(), .find(). Everything you'd expect from array methods, but lazy.

17. New Set Methods

Sets have been in JavaScript since ES6, but for almost a decade the only way to do set operations was to convert to arrays first. ES2025 finally adds the math:

const admins = new Set(["alice", "bob", "carol"]);
const active = new Set(["bob", "carol", "dave", "eve"]);

admins.intersection(active);        // Set {"bob", "carol"}
admins.union(active);               // Set {"alice", "bob", "carol", "dave", "eve"}
admins.difference(active);          // Set {"alice"}
active.difference(admins);          // Set {"dave", "eve"}
admins.symmetricDifference(active); // Set {"alice", "dave", "eve"}

admins.isSubsetOf(active);    // false
admins.isSupersetOf(active);  // false
admins.isDisjointFrom(active);// false

The old way just for intersection:

const intersection = new Set([...admins].filter(x => active.has(x)));

Not unreadable in isolation, but once you're chaining multiple set operations — or explaining the code to someone — native methods win clearly.

18. `RegExp.escape()`

This one matters most in security-sensitive contexts.

Building a regex from user input without escaping it is a classic way to introduce bugs — or deliberately exploitable behavior:

// User types "hello.world" — the dot matches ANY character
const regex = new RegExp(userInput); // potentially dangerous

The old fix was a utility function that most codebases copy-pasted from Stack Overflow:

function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

// New way
const regex = new RegExp(RegExp.escape(userInput));

Same result, but now it's a standard language feature rather than something you wrote, or copied, or imported, and might have gotten subtly wrong.

19. `Float16Array`

This one is for a specific audience, and if you're in that audience you've probably been waiting for it.

JavaScript's default number type is 64-bit float. Float32Array has been available for a while. ES2025 adds Float16Array:

const weights = new Float16Array(1024);

16-bit floats use half the memory of 32-bit and a quarter of 64-bit. The trade-off is precision — roughly 3 decimal digits instead of 7 (Float32) or 15 (Float64).

Where this matters: WebGPU and WebGL applications, machine learning inference in the browser, any situation where you're transferring large volumes of numeric data to/from GPU memory. Smaller means faster transfer, less memory bandwidth, better throughput.

20. Explicit Resource Management (`using`)

Saving the best for last.

Anyone who's written cleanup code knows the pattern — open a connection, do work, close the connection, but also close it if something throws, so you need a try/finally block, and now your actual logic is buried in ceremony:

const connection = await db.connect();
try {
  await connection.query("...");
} finally {
  await connection.close();
}

using is JavaScript's version of Python's with statement or C#'s using block:

await using connection = await db.connect();
await connection.query("...");
// connection.close() runs automatically when the block exits
// even if an error is thrown

For this to work, the object needs to implement Symbol.asyncDispose (or Symbol.dispose for sync resources). Any class can implement this interface.

This is Stage 4 in TC39 (finalized) and already available in TypeScript 5.2+. Native browser and Node.js support is rolling out now.

The Pattern You Can't Miss

If you look at these 20 features together, something becomes obvious.

Immutability by default (toSorted, toReversed, with). Safer async patterns (Promise.withResolvers, Promise.try). Real encapsulation (#privateFields). Automatic cleanup (using). Better debugging chains (Error.cause). Lazy evaluation instead of eager allocation (iterator helpers). Native set math. Safe regex construction.

JavaScript is not becoming a different language. It's becoming a safer version of itself — filling in the gaps where experienced developers had learned to be careful, and making the right approach easier than the wrong one.

The features from 2015 onwards were largely about adding missing capabilities. What we're seeing now is the language addressing the ways those capabilities got misused.

That's 20 features. Some you'll use every week, some once a year, some maybe never depending on what you build. But all of them are things worth knowing exist.

Because the next time someone on your team writes a 14-line groupBy helper — clean, well-tested, completely unnecessary — you want to be the one who catches it in review.

Found something I got wrong, or a feature I should've included? Drop a comment. I read them all.

Rust Looks Scary. It's Not. You're Just Learning It Wrong.

Nishant Gaurav — Tue, 24 Feb 2026 18:43:47 +0000

JavaScript runs your frontend.

Node.js handles your backend.

But then you hit a wall.

Your app slows down. Memory keeps climbing. You Google "why is my Node server eating 2GB of RAM" and some Reddit thread just says — use Rust.

So you look it up. And immediately see:

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Tab closed.

I don't blame you. But here's the thing — that's advanced Rust. Nobody starts there. Let's start where you should.

What Rust Actually Does

Rust is a systems programming language built for two things that rarely come together: speed and safety.

Think operating systems, game engines, databases, web servers at scale. The kind of software where a crash isn't just a bug report — it's a disaster.

C and C++ owned this space for decades. They're fast. But dangerous. Memory leaks, data races, crashes that appear months later. Rust eliminates entire categories of bugs at compile time. Without a garbage collector. Without a runtime.

That's why Rust has been the most loved language on Stack Overflow for nine years straight. Not most used. Most loved. That's a different metric entirely.

Setting Up

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

This installs:

rustup — version manager
rustc — the compiler
cargo — build tool + package manager (think npm, but for Rust)

Create your first project:

cargo new hello_rust
cd hello_rust
cargo run

You'll see Hello, world!

You're in. Let's go.

Variables & Mutability

In most languages, variables are mutable by default. Rust flips this.

fn main() {
    let name = "Luffy";     // immutable by default
    let mut age = 19;       // mut = can be changed later

    // name = "Zoro";       // ❌ ERROR: cannot assign twice to immutable variable
    age = 20;               // ✅ fine

    println!("Name: {}, Age: {}", name, age);
}

This feels restrictive at first. But most bugs come from changing something you didn't mean to change. Rust makes you declare intent upfront.

For values that should never change anywhere:

const MAX_PLAYERS: u32 = 100; // type annotation always required

Rule of thumb: Start with let. Add mut only when you genuinely need it.

Data Types

Rust is statically typed — every value has a type, and the compiler knows all of them before your code even runs.

fn main() {
    // Integers
    let score: i32 = 100;       // signed 32-bit
    let health: u8 = 255;       // unsigned 8-bit (0–255)

    // Floats
    let price: f64 = 29.99;

    // Boolean
    let is_active: bool = true;

    // Character
    let grade: char = 'A';

    // String types (two different things in Rust)
    let language: &str = "Rust";               // string slice (borrowed)
    let greeting: String = String::from("Hi"); // owned String

    println!("{} {} {} {}", score, price, is_active, language);
}

Most of the time, Rust infers types for you:

let x = 42;     // i32
let y = 3.14;   // f64
let z = true;   // bool

Functions

// No return value
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

// Returns a value — note the arrow
fn add(a: i32, b: i32) -> i32 {
    a + b   // No semicolon = this IS the return value
}

fn main() {
    greet("Zoro");
    println!("5 + 3 = {}", add(5, 3)); // 8
}

The "no semicolon = return value" thing trips everyone up early. Once it clicks, it actually feels clean. Add a semicolon and the expression becomes a statement — returns nothing.

Control Flow

fn main() {
    let score = 87;

    if score >= 90 {
        println!("Grade: A");
    } else if score >= 80 {
        println!("Grade: B");
    } else {
        println!("Grade: F");
    }

    // if as an expression — this is genuinely useful
    let status = if score >= 60 { "Pass" } else { "Fail" };
    println!("Status: {}", status);
}

Loops

fn main() {
    // loop — runs until you break
    let mut count = 0;
    loop {
        count += 1;
        if count == 5 { break; }
    }

    // while
    let mut i = 0;
    while i < 5 {
        println!("{}", i);
        i += 1;
    }

    // for — the one you'll use most
    for number in 1..=5 { // 1..=5 = 1 through 5 inclusive
        println!("{}", number);
    }

    // iterating collections
    let fruits = ["apple", "banana", "mango"];
    for fruit in fruits {
        println!("{}", fruit);
    }
}

Structs — Rust's Version of Objects

struct Player {
    name: String,
    health: u32,
    level: u8,
}

impl Player {
    fn new(name: &str) -> Player {
        Player {
            name: String::from(name),
            health: 100,
            level: 1,
        }
    }

    fn take_damage(&mut self, damage: u32) {
        self.health = self.health.saturating_sub(damage); // never goes below 0
    }

    fn is_alive(&self) -> bool {
        self.health > 0
    }

    fn display(&self) {
        println!("{} | HP: {} | Level: {}", self.name, self.health, self.level);
    }
}

fn main() {
    let mut player = Player::new("Luffy");
    player.display();          // Luffy | HP: 100 | Level: 1

    player.take_damage(30);
    player.display();          // Luffy | HP: 70 | Level: 1

    player.take_damage(200);
    println!("Alive? {}", player.is_alive()); // false
}

&self = reading the struct. &mut self = modifying it. This pattern shows up everywhere in Rust.

Enums — More Powerful Than You Think

Rust enums can hold data. This makes them genuinely different from enums in other languages.

enum Shape {
    Circle(f64),          // radius
    Rectangle(f64, f64),  // width, height
}

fn area(shape: Shape) -> f64 {
    match shape {
        Shape::Circle(r) => std::f64::consts::PI * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("Circle: {:.2}", area(Shape::Circle(5.0)));             // 78.54
    println!("Rectangle: {:.2}", area(Shape::Rectangle(4.0, 6.0))); // 24.00
}

That match block is exhaustive. Forget a case → compiler error. Not a runtime panic. Not a wrong result. A compile-time error. Before your code runs.

The Big Three: Ownership, Borrowing, References

This is what people mean when they say "Rust is hard."

It's not impossible. It's just a different mental model. Give it real attention here and everything else in Rust becomes much clearer.

Ownership

Every value in Rust has exactly one owner. When the owner is gone, the value is dropped (memory freed). Automatically. No garbage collector.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // ownership MOVES to s2

    // println!("{}", s1); // ❌ ERROR: s1 no longer valid
    println!("{}", s2);    // ✅ fine
}

In JavaScript, both variables would point to the same string. In Rust, ownership transfers. s1 is gone.

Why? If two variables could own the same memory, who frees it? Double-free = crash. Rust makes this impossible — at compile time.

Borrowing

What if you need to use a value without taking ownership? You borrow it with &.

fn print_length(s: &String) { // borrow, don't own
    println!("Length: {}", s.len());
} // s goes out of scope, nothing freed — we didn't own it

fn main() {
    let s1 = String::from("hello world");
    print_length(&s1);  // lend s1
    println!("{}", s1); // s1 still valid
}

Mutable References

fn add_exclamation(s: &mut String) {
    s.push_str("!!!");
}

fn main() {
    let mut message = String::from("Hello");
    add_exclamation(&mut message);
    println!("{}", message); // Hello!!!
}

The rules Rust enforces:

Unlimited read-only references (&T) — all at once ✅
Exactly ONE mutable reference (&mut T) — no other references simultaneously ✅
Both at the same time — ❌ never

This eliminates an entire class of data race bugs. At compile time.

Option — No More Null

Rust has no null. Instead, there's Option<T>:

fn find_player(id: u32) -> Option<String> {
    if id == 1 {
        Some(String::from("Luffy"))
    } else {
        None
    }
}

fn main() {
    // Pattern match
    match find_player(1) {
        Some(name) => println!("Found: {}", name),
        None => println!("Not found"),
    }

    // Shorthand with default
    let player = find_player(99).unwrap_or(String::from("Unknown"));
    println!("{}", player); // Unknown

    // if let — when you only care about Some
    if let Some(name) = find_player(1) {
        println!("Welcome, {}!", name);
    }
}

The key: Rust forces you to handle None. You cannot accidentally call methods on a missing value. The compiler won't allow it.

Result — Handling Errors Properly

For operations that can fail:

fn parse_age(input: &str) -> Result<u32, String> {
    match input.trim().parse::<u32>() {
        Ok(n) => Ok(n),
        Err(_) => Err(format!("'{}' is not a valid age", input)),
    }
}

fn main() {
    match parse_age("25") {
        Ok(age) => println!("Valid age: {}", age),
        Err(e) => println!("Error: {}", e),
    }

    match parse_age("abc") {
        Ok(age) => println!("Valid age: {}", age),
        Err(e) => println!("Error: {}", e), // this one runs
    }
}

The ? operator propagates errors automatically — you don't rewrite the same match block everywhere.

Vectors & HashMaps

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];
    numbers.push(6);

    // Safe access — no crash on out-of-bounds
    println!("{:?}", numbers.get(10)); // None

    // Just like JS array methods
    let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
    let evens: Vec<&i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();

    println!("{:?}", doubled); // [2, 4, 6, 8, 10, 12]
    println!("{:?}", evens);   // [2, 4, 6]
}

use std::collections::HashMap;

fn main() {
    let mut scores: HashMap<String, u32> = HashMap::new();

    scores.insert(String::from("Luffy"), 95);
    scores.insert(String::from("Zoro"), 88);

    // Insert only if key doesn't exist
    scores.entry(String::from("Nami")).or_insert(91);

    if let Some(s) = scores.get("Luffy") {
        println!("Luffy: {}", s); // 95
    }

    for (name, score) in &scores {
        println!("{}: {}", name, score);
    }
}

Mini Project — CLI Todo App

Let's put everything together:

use std::collections::HashMap;
use std::io;

struct TodoApp {
    tasks: HashMap<u32, (String, bool)>,
    next_id: u32,
}

impl TodoApp {
    fn new() -> TodoApp {
        TodoApp { tasks: HashMap::new(), next_id: 1 }
    }

    fn add(&mut self, desc: &str) {
        self.tasks.insert(self.next_id, (desc.to_string(), false));
        println!("✅ Task #{} added: {}", self.next_id, desc);
        self.next_id += 1;
    }

    fn complete(&mut self, id: u32) {
        match self.tasks.get_mut(&id) {
            Some(task) => { task.1 = true; println!("🎉 Task #{} done!", id); }
            None => println!("❌ Task #{} not found.", id),
        }
    }

    fn list(&self) {
        if self.tasks.is_empty() {
            println!("No tasks yet."); return;
        }
        let mut ids: Vec<&u32> = self.tasks.keys().collect();
        ids.sort();
        println!("\n--- Tasks ---");
        for id in ids {
            let (desc, done) = &self.tasks[id];
            let icon = if *done { "✅" } else { "⏳" };
            println!("{} #{}: {}", icon, id, desc);
        }
        println!("-------------\n");
    }
}

fn main() {
    let mut app = TodoApp::new();
    println!("=== Rust Todo ===");
    println!("Commands: add <task> | done <id> | list | quit\n");

    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();
        let input = input.trim();

        if input.starts_with("add ") {
            app.add(&input[4..]);
        } else if input.starts_with("done ") {
            match input[5..].parse::<u32>() {
                Ok(id) => app.complete(id),
                Err(_) => println!("Enter a valid number"),
            }
        } else if input == "list" {
            app.list();
        } else if input == "quit" {
            println!("Goodbye! 🦀"); break;
        } else {
            println!("Unknown command.");
        }
    }
}

Run with cargo run. Fully working CLI app — structs, methods, HashMap, Option, pattern matching, and user input. Everything from this guide in one place.

The Compiler Is Not Your Enemy

Rust's error messages are some of the best in any language:

error[E0382]: borrow of moved value: `s1`
  --> src/main.rs:5:20
   |
3  |     let s1 = String::from("hello");
   |         -- move occurs because `s1` has type `String`
4  |     let s2 = s1;
   |              -- value moved here
5  |     println!("{}", s1);
   |                    ^^ value borrowed here after move

This error saved you from a bug. The compiler caught it before your code ever ran.

Read every error. The whole thing.

Common Mistakes to Avoid

Fighting the borrow checker. If it's complaining, your design needs adjusting — not the rules.

Cloning everything. clone() works, but it usually means you haven't understood ownership yet. Understand first, then decide.

Jumping to async Rust too early. Get the basics solid first.

Skimming error messages. They're verbose for a reason. Read them fully.

Comparing everything to JavaScript. Rust solves different problems with a different mental model. Let it be different.

How to Practice

Build small, real things:

Number guessing game (stdin, random, loops)
Temperature converter (functions, structs)
Word counter for a text file (file I/O, HashMap)
Student grade tracker (Vec, structs, sorting)
Simple calculator (enums, pattern matching)

Use cargo check instead of cargo build while iterating — gives you errors much faster.

The Rust Book is free, excellent, and written by people who care about making this approachable.

Progress in Rust feels slow, and then suddenly clicks. You go from fighting the compiler to being grateful for it. That shift happens. Give it time.

What's Next?

You now have the foundation:

Variables. Functions. Structs. Enums. Ownership. Option and Result. Vectors. HashMaps.

That's enough to build real things.

Next in this series → Building web servers and APIs with Axum + Tokio, Rust's async runtime. Fast, clean, safe backend code.

Happy building. 🦀

15 Advanced Web APIs Every Modern Developer Must Master 🚀

Nishant Gaurav — Mon, 02 Feb 2026 06:32:05 +0000

Modern web development demands more than just knowing HTML, CSS, and JavaScript. The browser provides powerful APIs that can transform your applications from basic to extraordinary. This comprehensive guide covers 15 essential Web APIs with production-ready examples, best practices, and real-world implementations.

IndexedDB API
Web Workers API
WebRTC API
Intersection Observer API
Web Notifications API
Web Speech API
WebSocket API
Service Worker API
Resize Observer API
Broadcast Channel API
WebGL API
Payment Request API
Credential Management API
Battery Status API
Screen Wake Lock API

1. IndexedDB API - Client-Side Database Powerhouse 💾

IndexedDB is a low-level API for storing significant amounts of structured data, including files and blobs. Unlike localStorage's 5-10MB limit, IndexedDB can store hundreds of megabytes or more.

Why Use IndexedDB?

Large Storage: Handles GBs of data
Indexed Queries: Fast data retrieval with indexes
Asynchronous: Non-blocking operations
Transactional: ACID-compliant database operations

Production-Ready Implementation

class IndexedDBManager {
  constructor(dbName, version = 1) {
    this.dbName = dbName;
    this.version = version;
    this.db = null;
  }

  async init() {
    return new Promise((resolve, reject) => {
      const request = indexedDB.open(this.dbName, this.version);

      request.onerror = () => reject(request.error);
      request.onsuccess = () => {
        this.db = request.result;
        resolve(this.db);
      };

      request.onupgradeneeded = (event) => {
        const db = event.target.result;

        // Create object stores
        if (!db.objectStoreNames.contains('users')) {
          const userStore = db.createObjectStore('users', { keyPath: 'id', autoIncrement: true });
          userStore.createIndex('email', 'email', { unique: true });
          userStore.createIndex('name', 'name', { unique: false });
        }

        if (!db.objectStoreNames.contains('posts')) {
          const postStore = db.createObjectStore('posts', { keyPath: 'id', autoIncrement: true });
          postStore.createIndex('userId', 'userId', { unique: false });
          postStore.createIndex('timestamp', 'timestamp', { unique: false });
        }
      };
    });
  }

  async add(storeName, data) {
    const transaction = this.db.transaction([storeName], 'readwrite');
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
      const request = store.add(data);
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
  }

  async get(storeName, key) {
    const transaction = this.db.transaction([storeName], 'readonly');
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
      const request = store.get(key);
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
  }

  async getByIndex(storeName, indexName, value) {
    const transaction = this.db.transaction([storeName], 'readonly');
    const store = transaction.objectStore(storeName);
    const index = store.index(indexName);

    return new Promise((resolve, reject) => {
      const request = index.get(value);
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
  }

  async getAll(storeName) {
    const transaction = this.db.transaction([storeName], 'readonly');
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
      const request = store.getAll();
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
  }

  async update(storeName, data) {
    const transaction = this.db.transaction([storeName], 'readwrite');
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
      const request = store.put(data);
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => reject(request.error);
    });
  }

  async delete(storeName, key) {
    const transaction = this.db.transaction([storeName], 'readwrite');
    const store = transaction.objectStore(storeName);

    return new Promise((resolve, reject) => {
      const request = store.delete(key);
      request.onsuccess = () => resolve();
      request.onerror = () => reject(request.error);
    });
  }
}

// Usage Example
const dbManager = new IndexedDBManager('MyApp');

await dbManager.init();

// Add user
const userId = await dbManager.add('users', {
  name: 'John Doe',
  email: 'john@example.com',
  role: 'admin',
  createdAt: new Date()
});

// Get user by email
const user = await dbManager.getByIndex('users', 'email', 'john@example.com');

// Update user
await dbManager.update('users', {
  ...user,
  role: 'superadmin'
});

Real-World Use Cases

Offline-First Applications: Store data locally, sync when online
Progressive Web Apps: Cache API responses and user data
Large Dataset Management: Handle complex queries client-side
Media Storage: Store images, videos, and audio files

Learn More

2. Web Workers API - Multithreading in JavaScript ⚡

Web Workers enable true parallel processing in JavaScript, running scripts in background threads without blocking the UI.

The Problem Web Workers Solve

JavaScript is single-threaded. Heavy computations freeze the UI, creating poor user experiences. Web Workers solve this by offloading work to separate threads.

Advanced Implementation with Worker Pool

// worker-pool.js - Reusable Worker Pool Manager
class WorkerPool {
  constructor(workerScript, poolSize = navigator.hardwareConcurrency || 4) {
    this.workerScript = workerScript;
    this.poolSize = poolSize;
    this.workers = [];
    this.queue = [];
    this.activeWorkers = new Set();

    this.initializePool();
  }

  initializePool() {
    for (let i = 0; i < this.poolSize; i++) {
      const worker = new Worker(this.workerScript);
      worker.id = i;
      this.workers.push(worker);
    }
  }

  async execute(data, transferable = []) {
    return new Promise((resolve, reject) => {
      const task = { data, transferable, resolve, reject };

      const availableWorker = this.workers.find(w => !this.activeWorkers.has(w));

      if (availableWorker) {
        this.runTask(availableWorker, task);
      } else {
        this.queue.push(task);
      }
    });
  }

  runTask(worker, task) {
    this.activeWorkers.add(worker);

    const messageHandler = (e) => {
      worker.removeEventListener('message', messageHandler);
      worker.removeEventListener('error', errorHandler);
      this.activeWorkers.delete(worker);

      task.resolve(e.data);
      this.processQueue();
    };

    const errorHandler = (e) => {
      worker.removeEventListener('message', messageHandler);
      worker.removeEventListener('error', errorHandler);
      this.activeWorkers.delete(worker);

      task.reject(e);
      this.processQueue();
    };

    worker.addEventListener('message', messageHandler);
    worker.addEventListener('error', errorHandler);
    worker.postMessage(task.data, task.transferable);
  }

  processQueue() {
    if (this.queue.length === 0) return;

    const availableWorker = this.workers.find(w => !this.activeWorkers.has(w));
    if (availableWorker) {
      const task = this.queue.shift();
      this.runTask(availableWorker, task);
    }
  }

  terminate() {
    this.workers.forEach(worker => worker.terminate());
    this.workers = [];
    this.queue = [];
    this.activeWorkers.clear();
  }
}

// image-processor-worker.js
self.addEventListener('message', (e) => {
  const { imageData, operation } = e.data;

  switch (operation) {
    case 'grayscale':
      const grayData = applyGrayscale(imageData);
      self.postMessage({ result: grayData }, [grayData.data.buffer]);
      break;

    case 'blur':
      const blurData = applyBlur(imageData, e.data.radius);
      self.postMessage({ result: blurData }, [blurData.data.buffer]);
      break;

    case 'brighten':
      const brightData = applyBrighten(imageData, e.data.amount);
      self.postMessage({ result: brightData }, [brightData.data.buffer]);
      break;
  }
});

function applyGrayscale(imageData) {
  const data = imageData.data;
  for (let i = 0; i < data.length; i += 4) {
    const avg = (data[i] + data[i + 1] + data[i + 2]) / 3;
    data[i] = data[i + 1] = data[i + 2] = avg;
  }
  return imageData;
}

function applyBlur(imageData, radius = 5) {
  // Implement Gaussian blur algorithm
  // ... (implementation details)
  return imageData;
}

function applyBrighten(imageData, amount = 20) {
  const data = imageData.data;
  for (let i = 0; i < data.length; i += 4) {
    data[i] = Math.min(255, data[i] + amount);
    data[i + 1] = Math.min(255, data[i + 1] + amount);
    data[i + 2] = Math.min(255, data[i + 2] + amount);
  }
  return imageData;
}

// Usage in main thread
const workerPool = new WorkerPool('image-processor-worker.js', 4);

async function processImage(canvas, operation) {
  const ctx = canvas.getContext('2d');
  const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);

  try {
    const result = await workerPool.execute(
      { imageData, operation, radius: 5, amount: 30 },
      [imageData.data.buffer] // Transfer ownership for better performance
    );

    ctx.putImageData(result.result, 0, 0);
  } catch (error) {
    console.error('Image processing failed:', error);
  }
}

// Process multiple images concurrently
const images = document.querySelectorAll('.image-to-process');
await Promise.all(
  Array.from(images).map(img => 
    processImage(img, 'grayscale')
  )
);

Performance Comparison

Task	Main Thread	Web Worker	Improvement
Image Processing (1920x1080)	~850ms (UI frozen)	~220ms (UI responsive)	74% faster perceived
JSON Parsing (50MB)	~2300ms	~2100ms	UI remains smooth
Complex Calculations	Blocks rendering	Background execution	Infinite UX improvement

Best Practices

Use Transferable Objects: Transfer array buffers instead of copying
Implement Worker Pools: Reuse workers for better performance
Handle Errors Gracefully: Always implement error handlers
Consider SharedArrayBuffer: For data sharing between workers

Learn More

3. WebRTC API - Real-Time Communication 📹

WebRTC (Web Real-Time Communication) enables peer-to-peer audio, video, and data sharing without plugins or intermediary servers.

Complete Video Chat Implementation

class VideoChat {
  constructor(localVideoEl, remoteVideoEl, signalingServer) {
    this.localVideo = localVideoEl;
    this.remoteVideo = remoteVideoEl;
    this.signalingServer = signalingServer;
    this.peerConnection = null;
    this.localStream = null;

    this.configuration = {
      iceServers: [
        { urls: 'stun:stun.l.google.com:19302' },
        { urls: 'stun:stun1.l.google.com:19302' },
        {
          urls: 'turn:your-turn-server.com:3478',
          username: 'user',
          credential: 'pass'
        }
      ]
    };

    this.setupSignaling();
  }

  async initialize() {
    try {
      // Get local media stream
      this.localStream = await navigator.mediaDevices.getUserMedia({
        video: {
          width: { ideal: 1280 },
          height: { ideal: 720 },
          frameRate: { ideal: 30 }
        },
        audio: {
          echoCancellation: true,
          noiseSuppression: true,
          autoGainControl: true
        }
      });

      this.localVideo.srcObject = this.localStream;

      // Create peer connection
      this.peerConnection = new RTCPeerConnection(this.configuration);

      // Add local tracks to peer connection
      this.localStream.getTracks().forEach(track => {
        this.peerConnection.addTrack(track, this.localStream);
      });

      // Handle incoming tracks
      this.peerConnection.ontrack = (event) => {
        this.remoteVideo.srcObject = event.streams[0];
      };

      // Handle ICE candidates
      this.peerConnection.onicecandidate = (event) => {
        if (event.candidate) {
          this.signalingServer.send({
            type: 'ice-candidate',
            candidate: event.candidate
          });
        }
      };

      // Monitor connection state
      this.peerConnection.onconnectionstatechange = () => {
        console.log('Connection state:', this.peerConnection.connectionState);

        if (this.peerConnection.connectionState === 'disconnected') {
          this.handleDisconnection();
        }
      };

      // Monitor ICE connection state
      this.peerConnection.oniceconnectionstatechange = () => {
        console.log('ICE state:', this.peerConnection.iceConnectionState);
      };

    } catch (error) {
      console.error('Failed to initialize video chat:', error);
      throw error;
    }
  }

  setupSignaling() {
    this.signalingServer.on('offer', async (offer) => {
      await this.peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
      const answer = await this.peerConnection.createAnswer();
      await this.peerConnection.setLocalDescription(answer);

      this.signalingServer.send({
        type: 'answer',
        answer: answer
      });
    });

    this.signalingServer.on('answer', async (answer) => {
      await this.peerConnection.setRemoteDescription(new RTCSessionDescription(answer));
    });

    this.signalingServer.on('ice-candidate', async (candidate) => {
      await this.peerConnection.addIceCandidate(new RTCIceCandidate(candidate));
    });
  }

  async createOffer() {
    const offer = await this.peerConnection.createOffer({
      offerToReceiveAudio: true,
      offerToReceiveVideo: true
    });

    await this.peerConnection.setLocalDescription(offer);

    this.signalingServer.send({
      type: 'offer',
      offer: offer
    });
  }

  toggleAudio(enabled) {
    this.localStream.getAudioTracks().forEach(track => {
      track.enabled = enabled;
    });
  }

  toggleVideo(enabled) {
    this.localStream.getVideoTracks().forEach(track => {
      track.enabled = enabled;
    });
  }

  async switchCamera() {
    const videoTrack = this.localStream.getVideoTracks()[0];
    const currentFacingMode = videoTrack.getSettings().facingMode;

    videoTrack.stop();

    const newStream = await navigator.mediaDevices.getUserMedia({
      video: { facingMode: currentFacingMode === 'user' ? 'environment' : 'user' }
    });

    const newVideoTrack = newStream.getVideoTracks()[0];
    const sender = this.peerConnection.getSenders().find(s => s.track.kind === 'video');

    sender.replaceTrack(newVideoTrack);
    this.localStream.removeTrack(videoTrack);
    this.localStream.addTrack(newVideoTrack);
    this.localVideo.srcObject = this.localStream;
  }

  async shareScreen() {
    try {
      const screenStream = await navigator.mediaDevices.getDisplayMedia({
        video: { cursor: 'always' },
        audio: false
      });

      const screenTrack = screenStream.getVideoTracks()[0];
      const sender = this.peerConnection.getSenders().find(s => s.track.kind === 'video');

      sender.replaceTrack(screenTrack);

      // Restore camera when screen sharing stops
      screenTrack.onended = () => {
        const videoTrack = this.localStream.getVideoTracks()[0];
        sender.replaceTrack(videoTrack);
      };

    } catch (error) {
      console.error('Screen sharing failed:', error);
    }
  }

  getStats() {
    return this.peerConnection.getStats();
  }

  handleDisconnection() {
    console.log('Peer disconnected. Attempting reconnection...');
    // Implement reconnection logic
  }

  disconnect() {
    if (this.localStream) {
      this.localStream.getTracks().forEach(track => track.stop());
    }

    if (this.peerConnection) {
      this.peerConnection.close();
    }

    this.localVideo.srcObject = null;
    this.remoteVideo.srcObject = null;
  }
}

// Usage
const videoChat = new VideoChat(
  document.getElementById('local-video'),
  document.getElementById('remote-video'),
  signalingServerConnection
);

await videoChat.initialize();
await videoChat.createOffer();

// Control buttons
document.getElementById('mute-btn').addEventListener('click', () => {
  videoChat.toggleAudio(false);
});

document.getElementById('share-screen-btn').addEventListener('click', () => {
  videoChat.shareScreen();
});

Applications

Video Conferencing: Zoom, Google Meet alternatives
Live Streaming: Twitch-like platforms
Online Gaming: Real-time multiplayer games
IoT Communication: Device-to-device communication
File Sharing: P2P file transfer without servers

Learn More

4. Intersection Observer API - Efficient Scroll Detection 🎯

The Intersection Observer API provides a way to asynchronously observe changes in the intersection of a target element with an ancestor element or the viewport.

Advanced Implementation with Performance Optimization

class LazyLoadManager {
  constructor(options = {}) {
    this.options = {
      root: options.root || null,
      rootMargin: options.rootMargin || '50px',
      threshold: options.threshold || 0.1,
      unobserveOnLoad: options.unobserveOnLoad !== false
    };

    this.observer = null;
    this.observed = new WeakMap();
    this.initialize();
  }

  initialize() {
    this.observer = new IntersectionObserver(
      (entries) => this.handleIntersection(entries),
      this.options
    );
  }

  handleIntersection(entries) {
    entries.forEach(entry => {
      if (entry.isIntersecting) {
        const element = entry.target;
        const callback = this.observed.get(element);

        if (callback) {
          callback(element, entry);

          if (this.options.unobserveOnLoad) {
            this.unobserve(element);
          }
        }
      }
    });
  }

  observe(element, callback) {
    this.observed.set(element, callback);
    this.observer.observe(element);
  }

  unobserve(element) {
    this.observed.delete(element);
    this.observer.unobserve(element);
  }

  disconnect() {
    this.observer.disconnect();
    this.observed = new WeakMap();
  }
}

// Image Lazy Loading with Progressive Enhancement
class ImageLazyLoader extends LazyLoadManager {
  constructor(options) {
    super(options);
    this.loadedImages = new Set();
  }

  loadImage(img) {
    return new Promise((resolve, reject) => {
      // Add loading placeholder
      img.classList.add('loading');

      const src = img.dataset.src;
      const srcset = img.dataset.srcset;

      // Create a temporary image to preload
      const tempImg = new Image();

      tempImg.onload = () => {
        img.src = src;
        if (srcset) img.srcset = srcset;

        img.classList.remove('loading');
        img.classList.add('loaded');

        this.loadedImages.add(img);
        resolve(img);
      };

      tempImg.onerror = () => {
        img.classList.remove('loading');
        img.classList.add('error');
        reject(new Error(`Failed to load image: ${src}`));
      };

      tempImg.src = src;
    });
  }

  observeImages(selector = 'img[data-src]') {
    const images = document.querySelectorAll(selector);

    images.forEach(img => {
      this.observe(img, async (element) => {
        try {
          await this.loadImage(element);
        } catch (error) {
          console.error(error);
        }
      });
    });
  }
}

// Infinite Scroll Implementation
class InfiniteScroll extends LazyLoadManager {
  constructor(options) {
    super({
      ...options,
      rootMargin: '200px',
      threshold: 0
    });

    this.loading = false;
    this.page = 1;
    this.hasMore = true;
  }

  async loadMore(fetchFunction) {
    if (this.loading || !this.hasMore) return;

    this.loading = true;

    try {
      const data = await fetchFunction(this.page);

      if (data && data.length > 0) {
        this.renderData(data);
        this.page++;
      } else {
        this.hasMore = false;
      }
    } catch (error) {
      console.error('Failed to load more:', error);
    } finally {
      this.loading = false;
    }
  }

  renderData(data) {
    // Implement your rendering logic
    const container = document.getElementById('content-container');

    data.forEach(item => {
      const element = this.createItemElement(item);
      container.appendChild(element);
    });
  }

  createItemElement(item) {
    const div = document.createElement('div');
    div.className = 'item';
    div.innerHTML = `
      <h3>${item.title}</h3>
      <p>${item.description}</p>
    `;
    return div;
  }

  init(sentinel, fetchFunction) {
    this.observe(sentinel, () => {
      this.loadMore(fetchFunction);
    });
  }
}

// Animate on Scroll
class ScrollAnimator extends LazyLoadManager {
  constructor(options) {
    super({
      ...options,
      threshold: 0.2,
      unobserveOnLoad: true
    });
  }

  animateElements(selector = '.animate-on-scroll') {
    const elements = document.querySelectorAll(selector);

    elements.forEach(el => {
      this.observe(el, (element, entry) => {
        const animationClass = element.dataset.animation || 'fade-in';
        const delay = element.dataset.delay || 0;

        setTimeout(() => {
          element.classList.add(animationClass, 'animated');
        }, delay);
      });
    });
  }
}

// Usage Examples

// 1. Image Lazy Loading
const imageLazyLoader = new ImageLazyLoader({
  rootMargin: '100px',
  threshold: 0.01
});
imageLazyLoader.observeImages();

// 2. Infinite Scroll
const infiniteScroll = new InfiniteScroll();
const sentinel = document.getElementById('scroll-sentinel');

infiniteScroll.init(sentinel, async (page) => {
  const response = await fetch(`/api/posts?page=${page}`);
  return response.json();
});

// 3. Scroll Animations
const animator = new ScrollAnimator({ threshold: 0.3 });
animator.animateElements('.fade-in-element');

// 4. Track Visibility for Analytics
const analyticsObserver = new LazyLoadManager({ threshold: 0.5 });
document.querySelectorAll('[data-track-view]').forEach(el => {
  analyticsObserver.observe(el, (element) => {
    const eventName = element.dataset.trackView;
    analytics.track('element_viewed', { element: eventName });
  });
});

CSS for Animations

/* Loading states */
img.loading {
  background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
  background-size: 200% 100%;
  animation: loading 1.5s infinite;
}

@keyframes loading {
  0% { background-position: 200% 0; }
  100% { background-position: -200% 0; }
}

/* Scroll animations */
.animate-on-scroll {
  opacity: 0;
  transform: translateY(30px);
  transition: opacity 0.6s ease, transform 0.6s ease;
}

.animate-on-scroll.animated {
  opacity: 1;
  transform: translateY(0);
}

.fade-in {
  animation: fadeIn 0.6s ease forwards;
}

@keyframes fadeIn {
  from {
    opacity: 0;
    transform: translateY(20px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

Performance Benefits

No Scroll Events: Eliminates expensive scroll event listeners
Asynchronous: Non-blocking, runs off the main thread
Precise Control: Multiple thresholds and margins
Battery Efficient: Only fires when needed

Learn More

5. Web Notifications API - Engage Users Effectively 🔔

The Notifications API allows web pages to send system notifications that appear outside the page, even when the browser is minimized.

Advanced Notification System

class NotificationManager {
  constructor() {
    this.permission = Notification.permission;
    this.queue = [];
    this.activeNotifications = new Map();
  }

  async requestPermission() {
    if (this.permission === 'granted') {
      return true;
    }

    if (this.permission === 'denied') {
      console.warn('Notification permission denied');
      return false;
    }

    try {
      const result = await Notification.requestPermission();
      this.permission = result;
      return result === 'granted';
    } catch (error) {
      console.error('Failed to request notification permission:', error);
      return false;
    }
  }

  async send(title, options = {}) {
    if (this.permission !== 'granted') {
      const granted = await this.requestPermission();
      if (!granted) return null;
    }

    const defaultOptions = {
      icon: '/icon.png',
      badge: '/badge.png',
      vibrate: [200, 100, 200],
      timestamp: Date.now(),
      requireInteraction: false,
      silent: false,
      ...options
    };

    try {
      const notification = new Notification(title, defaultOptions);

      // Track active notifications
      const id = options.tag || `notif-${Date.now()}`;
      this.activeNotifications.set(id, notification);

      // Event handlers
      notification.onclick = (event) => {
        event.preventDefault();
        window.focus();

        if (options.onClick) {
          options.onClick(event);
        }

        if (options.data?.url) {
          window.location.href = options.data.url;
        }

        notification.close();
      };

      notification.onclose = () => {
        this.activeNotifications.delete(id);

        if (options.onClose) {
          options.onClose();
        }
      };

      notification.onerror = (error) => {
        console.error('Notification error:', error);

        if (options.onError) {
          options.onError(error);
        }
      };

      // Auto close after duration
      if (options.duration) {
        setTimeout(() => {
          notification.close();
        }, options.duration);
      }

      return notification;

    } catch (error) {
      console.error('Failed to create notification:', error);
      return null;
    }
  }

  async sendRichNotification(title, options) {
    const richOptions = {
      ...options,
      actions: options.actions || [
        {
          action: 'view',
          title: 'View',
          icon: '/icons/view.png'
        },
        {
          action: 'dismiss',
          title: 'Dismiss',
          icon: '/icons/dismiss.png'
        }
      ]
    };

    return this.send(title, richOptions);
  }

  schedule(title, options, delay) {
    return new Promise((resolve) => {
      const timeoutId = setTimeout(async () => {
        const notification = await this.send(title, options);
        resolve(notification);
      }, delay);

      // Store for cancellation
      this.queue.push({
        timeoutId,
        title,
        options,
        scheduledTime: Date.now() + delay
      });
    });
  }

  cancelScheduled(index) {
    if (this.queue[index]) {
      clearTimeout(this.queue[index].timeoutId);
      this.queue.splice(index, 1);
    }
  }

  closeAll() {
    this.activeNotifications.forEach(notification => {
      notification.close();
    });
    this.activeNotifications.clear();
  }

  closeByTag(tag) {
    const notification = this.activeNotifications.get(tag);
    if (notification) {
      notification.close();
      this.activeNotifications.delete(tag);
    }
  }
}

// Service Worker for Background Notifications
// sw.js
self.addEventListener('push', (event) => {
  const data = event.data.json();

  const options = {
    body: data.body,
    icon: data.icon || '/icon.png',
    badge: '/badge.png',
    data: data.data,
    actions: data.actions || [
      { action: 'open', title: 'Open' },
      { action: 'close', title: 'Close' }
    ],
    tag: data.tag,
    requireInteraction: data.requireInteraction || false
  };

  event.waitUntil(
    self.registration.showNotification(data.title, options)
  );
});

self.addEventListener('notificationclick', (event) => {
  event.notification.close();

  if (event.action === 'open') {
    event.waitUntil(
      clients.openWindow(event.notification.data.url || '/')
    );
  }
});

// Usage Examples
const notificationManager = new NotificationManager();

// 1. Simple notification
await notificationManager.send('New Message', {
  body: 'You have a new message from John',
  icon: '/avatars/john.png',
  tag: 'message-123'
});

// 2. Rich notification with actions
await notificationManager.sendRichNotification('Meeting Reminder', {
  body: 'Team standup in 5 minutes',
  data: { url: '/meetings/standup' },
  actions: [
    { action: 'join', title: 'Join Now', icon: '/icons/video.png' },
    { action: 'snooze', title: 'Snooze', icon: '/icons/clock.png' }
  ],
  onClick: (event) => {
    if (event.action === 'snooze') {
      notificationManager.schedule('Meeting Reminder', {
        body: 'Team standup starting now!'
      }, 5 * 60 * 1000); // 5 minutes
    }
  }
});

// 3. Scheduled notification
await notificationManager.schedule('Take a Break', {
  body: 'You\'ve been working for 2 hours',
  icon: '/icons/break.png',
  duration: 10000
}, 2 * 60 * 60 * 1000); // 2 hours

// 4. Progressive enhancement with fallback
async function notifyUser(message) {
  if ('Notification' in window) {
    await notificationManager.send('App Notification', {
      body: message
    });
  } else {
    // Fallback to in-app notification
    showInAppNotification(message);
  }
}

Best Practices

Request Permission Contextually: Ask when user performs relevant action
Don't Spam: Respect user attention and frequency
Provide Value: Only send meaningful notifications
Allow Control: Let users manage preferences
Handle Errors: Always check permission status

Learn More

6. Web Speech API - Voice Interaction 🎤

The Web Speech API enables speech recognition (speech-to-text) and speech synthesis (text-to-speech) capabilities.

Complete Voice Assistant Implementation

class VoiceAssistant {
  constructor(options = {}) {
    this.options = {
      lang: options.lang || 'en-US',
      continuous: options.continuous || false,
      interimResults: options.interimResults || true,
      maxAlternatives: options.maxAlternatives || 1,
      ...options
    };

    this.recognition = null;
    this.synthesis = window.speechSynthesis;
    this.isListening = false;
    this.commands = new Map();
    this.transcript = '';

    this.initRecognition();
  }

  initRecognition() {
    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;

    if (!SpeechRecognition) {
      console.error('Speech recognition not supported');
      return;
    }

    this.recognition = new SpeechRecognition();
    Object.assign(this.recognition, this.options);

    this.recognition.onstart = () => {
      this.isListening = true;
      this.onListeningStart?.();
    };

    this.recognition.onend = () => {
      this.isListening = false;
      this.onListeningEnd?.();

      if (this.options.continuous && this.shouldRestart) {
        this.start();
      }
    };

    this.recognition.onresult = (event) => {
      const results = Array.from(event.results);
      const current = results[event.resultIndex];

      const transcript = current[0].transcript;
      const isFinal = current.isFinal;
      const confidence = current[0].confidence;

      if (isFinal) {
        this.transcript = transcript;
        this.processCommand(transcript, confidence);
      }

      this.onResult?.({ transcript, isFinal, confidence });
    };

    this.recognition.onerror = (event) => {
      console.error('Speech recognition error:', event.error);
      this.onError?.(event.error);
    };
  }

  registerCommand(pattern, callback, options = {}) {
    const id = options.id || `cmd-${this.commands.size}`;

    this.commands.set(id, {
      pattern: pattern instanceof RegExp ? pattern : new RegExp(pattern, 'i'),
      callback,
      priority: options.priority || 0,
      requiresConfidence: options.requiresConfidence || 0.7
    });

    return id;
  }

  unregisterCommand(id) {
    this.commands.delete(id);
  }

  processCommand(transcript, confidence) {
    const sortedCommands = Array.from(this.commands.values())
      .sort((a, b) => b.priority - a.priority);

    for (const command of sortedCommands) {
      if (confidence < command.requiresConfidence) continue;

      const match = transcript.match(command.pattern);
      if (match) {
        command.callback(match, transcript, confidence);
        return true;
      }
    }

    this.onUnknownCommand?.(transcript, confidence);
    return false;
  }

  speak(text, options = {}) {
    return new Promise((resolve, reject) => {
      if (!this.synthesis) {
        reject(new Error('Speech synthesis not supported'));
        return;
      }

      const utterance = new SpeechSynthesisUtterance(text);

      utterance.lang = options.lang || this.options.lang;
      utterance.voice = options.voice || this.getVoice(options.voiceName);
      utterance.volume = options.volume ?? 1;
      utterance.rate = options.rate ?? 1;
      utterance.pitch = options.pitch ?? 1;

      utterance.onend = () => resolve();
      utterance.onerror = (error) => reject(error);

      if (this.isListening) {
        this.pause();
      }

      this.synthesis.speak(utterance);

      utterance.onend = () => {
        resolve();
        if (this.options.continuous) {
          this.resume();
        }
      };
    });
  }

  getVoice(voiceName) {
    if (!voiceName) return null;

    const voices = this.synthesis.getVoices();
    return voices.find(voice => 
      voice.name.toLowerCase().includes(voiceName.toLowerCase())
    );
  }

  getVoices() {
    return this.synthesis.getVoices();
  }

  start() {
    if (!this.recognition) {
      console.error('Speech recognition not initialized');
      return;
    }

    try {
      this.shouldRestart = true;
      this.recognition.start();
    } catch (error) {
      if (error.message.includes('already started')) {
        console.warn('Recognition already started');
      } else {
        console.error('Failed to start recognition:', error);
      }
    }
  }

  stop() {
    this.shouldRestart = false;
    this.recognition?.stop();
  }

  pause() {
    this.recognition?.stop();
  }

  resume() {
    if (this.shouldRestart) {
      this.recognition?.start();
    }
  }

  abort() {
    this.recognition?.abort();
    this.synthesis.cancel();
  }
}

// Usage Example: Smart Home Controller
const assistant = new VoiceAssistant({
  lang: 'en-US',
  continuous: true,
  interimResults: true
});

// Register commands
assistant.registerCommand(
  /turn (on|off) the (.*)/i,
  (match) => {
    const [, action, device] = match;
    console.log(`${action} ${device}`);
    assistant.speak(`Turning ${action} the ${device}`);

    // API call to control device
    controlDevice(device, action);
  },
  { priority: 10 }
);

assistant.registerCommand(
  /what(?:'s| is) the (weather|temperature)/i,
  async (match) => {
    const [, query] = match;
    const data = await fetch(`/api/${query}`).then(r => r.json());
    assistant.speak(`The current ${query} is ${data.value}`);
  },
  { priority: 8 }
);

assistant.registerCommand(
  /set (timer|alarm) for (\d+) (minutes?|hours?)/i,
  (match) => {
    const [, type, duration, unit] = match;
    const ms = unit.includes('hour') 
      ? duration * 60 * 60 * 1000 
      : duration * 60 * 1000;

    setTimeout(() => {
      assistant.speak(`Your ${type} for ${duration} ${unit} is up!`);
    }, ms);

    assistant.speak(`${type} set for ${duration} ${unit}`);
  },
  { priority: 9 }
);

assistant.registerCommand(
  /play (.*)/i,
  (match) => {
    const [, song] = match;
    assistant.speak(`Playing ${song}`);
    playMusic(song);
  }
);

// Event handlers
assistant.onListeningStart = () => {
  document.querySelector('.mic-icon').classList.add('listening');
};

assistant.onListeningEnd = () => {
  document.querySelector('.mic-icon').classList.remove('listening');
};

assistant.onResult = ({ transcript, isFinal, confidence }) => {
  const display = document.querySelector('.transcript');
  display.textContent = transcript;

  if (isFinal) {
    display.classList.add('final');
  }
};

assistant.onUnknownCommand = (transcript, confidence) => {
  if (confidence > 0.6) {
    assistant.speak("I'm sorry, I didn't understand that command");
  }
};

// Voice selection UI
const voiceSelect = document.querySelector('#voice-select');
window.speechSynthesis.onvoiceschanged = () => {
  const voices = assistant.getVoices();
  voices.forEach(voice => {
    const option = document.createElement('option');
    option.value = voice.name;
    option.textContent = `${voice.name} (${voice.lang})`;
    voiceSelect.appendChild(option);
  });
};

// Start listening
assistant.start();

Multilingual Support

// Add language switching
const multilingualAssistant = new VoiceAssistant({
  lang: 'en-US',
  continuous: true
});

const languages = {
  'en': 'en-US',
  'es': 'es-ES',
  'fr': 'fr-FR',
  'de': 'de-DE',
  'hi': 'hi-IN',
  'ja': 'ja-JP'
};

multilingualAssistant.registerCommand(
  /switch (language|lang) to (.*)/i,
  (match) => {
    const [, , langName] = match;
    const langCode = languages[langName.toLowerCase()];

    if (langCode) {
      multilingualAssistant.recognition.lang = langCode;
      multilingualAssistant.options.lang = langCode;
      multilingualAssistant.speak(`Language switched to ${langName}`, {
        lang: langCode
      });
      multilingualAssistant.stop();
      multilingualAssistant.start();
    }
  }
);

Learn More

7. WebSocket API - Real-Time Bidirectional Communication 🔄

WebSocket provides full-duplex communication channels over a single TCP connection, perfect for real-time applications.

Production-Ready WebSocket Manager

class WebSocketManager {
  constructor(url, options = {}) {
    this.url = url;
    this.options = {
      reconnect: true,
      reconnectInterval: 1000,
      reconnectDecay: 1.5,
      maxReconnectInterval: 30000,
      maxReconnectAttempts: Infinity,
      heartbeatInterval: 30000,
      heartbeatMessage: JSON.stringify({ type: 'ping' }),
      ...options
    };

    this.socket = null;
    this.reconnectAttempts = 0;
    this.reconnectTimer = null;
    this.heartbeatTimer = null;
    this.listeners = new Map();
    this.messageQueue = [];
    this.isConnected = false;

    this.connect();
  }

  connect() {
    try {
      this.socket = new WebSocket(this.url);

      this.socket.onopen = () => this.handleOpen();
      this.socket.onmessage = (event) => this.handleMessage(event);
      this.socket.onerror = (error) => this.handleError(error);
      this.socket.onclose = (event) => this.handleClose(event);

    } catch (error) {
      console.error('WebSocket connection failed:', error);
      this.attemptReconnect();
    }
  }

  handleOpen() {
    console.log('WebSocket connected');
    this.isConnected = true;
    this.reconnectAttempts = 0;

    // Send queued messages
    while (this.messageQueue.length > 0) {
      const message = this.messageQueue.shift();
      this.send(message);
    }

    // Start heartbeat
    this.startHeartbeat();

    // Trigger onopen listeners
    this.emit('open');
  }

  handleMessage(event) {
    try {
      const data = JSON.parse(event.data);

      // Handle pong response
      if (data.type === 'pong') {
        return;
      }

      // Emit to specific event listeners
      if (data.type) {
        this.emit(data.type, data);
      }

      // Emit to general message listeners
      this.emit('message', data);

    } catch (error) {
      // Handle non-JSON messages
      this.emit('message', event.data);
    }
  }

  handleError(error) {
    console.error('WebSocket error:', error);
    this.emit('error', error);
  }

  handleClose(event) {
    console.log('WebSocket closed:', event.code, event.reason);
    this.isConnected = false;
    this.stopHeartbeat();
    this.emit('close', event);

    if (this.options.reconnect && !event.wasClean) {
      this.attemptReconnect();
    }
  }

  attemptReconnect() {
    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
      console.error('Max reconnection attempts reached');
      this.emit('reconnect_failed');
      return;
    }

    this.reconnectAttempts++;

    const delay = Math.min(
      this.options.reconnectInterval * Math.pow(this.options.reconnectDecay, this.reconnectAttempts - 1),
      this.options.maxReconnectInterval
    );

    console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);

    this.reconnectTimer = setTimeout(() => {
      this.emit('reconnecting', this.reconnectAttempts);
      this.connect();
    }, delay);
  }

  startHeartbeat() {
    this.stopHeartbeat();

    this.heartbeatTimer = setInterval(() => {
      if (this.isConnected) {
        this.send(this.options.heartbeatMessage);
      }
    }, this.options.heartbeatInterval);
  }

  stopHeartbeat() {
    if (this.heartbeatTimer) {
      clearInterval(this.heartbeatTimer);
      this.heartbeatTimer = null;
    }
  }

  send(data) {
    const message = typeof data === 'string' ? data : JSON.stringify(data);

    if (this.isConnected && this.socket.readyState === WebSocket.OPEN) {
      try {
        this.socket.send(message);
        return true;
      } catch (error) {
        console.error('Failed to send message:', error);
        this.messageQueue.push(message);
        return false;
      }
    } else {
      // Queue message for later
      this.messageQueue.push(message);
      return false;
    }
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event).push(callback);
  }

  off(event, callback) {
    if (!this.listeners.has(event)) return;

    const listeners = this.listeners.get(event);
    const index = listeners.indexOf(callback);

    if (index !== -1) {
      listeners.splice(index, 1);
    }
  }

  emit(event, data) {
    if (!this.listeners.has(event)) return;

    this.listeners.get(event).forEach(callback => {
      try {
        callback(data);
      } catch (error) {
        console.error(`Error in ${event} listener:`, error);
      }
    });
  }

  close(code = 1000, reason = 'Normal closure') {
    this.options.reconnect = false;

    if (this.reconnectTimer) {
      clearTimeout(this.reconnectTimer);
    }

    this.stopHeartbeat();

    if (this.socket) {
      this.socket.close(code, reason);
    }
  }

  getState() {
    if (!this.socket) return 'CLOSED';

    const states = {
      [WebSocket.CONNECTING]: 'CONNECTING',
      [WebSocket.OPEN]: 'OPEN',
      [WebSocket.CLOSING]: 'CLOSING',
      [WebSocket.CLOSED]: 'CLOSED'
    };

    return states[this.socket.readyState];
  }
}

// Real-time Chat Application
class ChatApplication {
  constructor(serverUrl) {
    this.ws = new WebSocketManager(serverUrl, {
      reconnect: true,
      heartbeatInterval: 30000
    });

    this.currentUser = null;
    this.setupEventListeners();
  }

  setupEventListeners() {
    this.ws.on('open', () => {
      console.log('Chat connected');
      this.showStatus('Connected', 'success');
    });

    this.ws.on('close', () => {
      this.showStatus('Disconnected', 'error');
    });

    this.ws.on('reconnecting', (attempt) => {
      this.showStatus(`Reconnecting (${attempt})...`, 'warning');
    });

    this.ws.on('message:chat', (data) => {
      this.displayMessage(data);
    });

    this.ws.on('user:joined', (data) => {
      this.showNotification(`${data.username} joined the chat`);
      this.updateUserList(data.users);
    });

    this.ws.on('user:left', (data) => {
      this.showNotification(`${data.username} left the chat`);
      this.updateUserList(data.users);
    });

    this.ws.on('typing', (data) => {
      this.showTypingIndicator(data.username);
    });
  }

  login(username) {
    this.currentUser = username;
    this.ws.send({
      type: 'auth',
      username: username,
      timestamp: Date.now()
    });
  }

  sendMessage(text) {
    const message = {
      type: 'message:chat',
      user: this.currentUser,
      text: text,
      timestamp: Date.now()
    };

    this.ws.send(message);
    this.displayMessage(message, true); // Display optimistically
  }

  sendTypingIndicator() {
    this.ws.send({
      type: 'typing',
      user: this.currentUser
    });
  }

  displayMessage(data, isOwn = false) {
    const container = document.getElementById('messages');
    const messageEl = document.createElement('div');
    messageEl.className = `message ${isOwn ? 'own' : ''}`;
    messageEl.innerHTML = `
      <div class="message-user">${data.user}</div>
      <div class="message-text">${this.escapeHtml(data.text)}</div>
      <div class="message-time">${new Date(data.timestamp).toLocaleTimeString()}</div>
    `;
    container.appendChild(messageEl);
    container.scrollTop = container.scrollHeight;
  }

  showTypingIndicator(username) {
    const indicator = document.getElementById('typing-indicator');
    indicator.textContent = `${username} is typing...`;
    indicator.style.display = 'block';

    // Hide after 3 seconds
    clearTimeout(this.typingTimeout);
    this.typingTimeout = setTimeout(() => {
      indicator.style.display = 'none';
    }, 3000);
  }

  showStatus(message, type) {
    const status = document.getElementById('status');
    status.textContent = message;
    status.className = `status ${type}`;
  }

  showNotification(message) {
    // Implementation
  }

  updateUserList(users) {
    const list = document.getElementById('user-list');
    list.innerHTML = users.map(user => `
      <div class="user">${this.escapeHtml(user)}</div>
    `).join('');
  }

  escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
  }
}

// Usage
const chat = new ChatApplication('wss://your-server.com/chat');

document.getElementById('login-btn').addEventListener('click', () => {
  const username = document.getElementById('username').value;
  chat.login(username);
});

document.getElementById('send-btn').addEventListener('click', () => {
  const text = document.getElementById('message-input').value;
  if (text.trim()) {
    chat.sendMessage(text);
    document.getElementById('message-input').value = '';
  }
});

let typingTimer;
document.getElementById('message-input').addEventListener('input', () => {
  clearTimeout(typingTimer);
  chat.sendTypingIndicator();

  typingTimer = setTimeout(() => {
    // Stop typing indicator
  }, 1000);
});

Server-Side Example (Node.js)

// server.js
const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

const clients = new Map();

wss.on('connection', (ws) => {
  let username = null;

  ws.on('message', (data) => {
    try {
      const message = JSON.parse(data);

      switch (message.type) {
        case 'auth':
          username = message.username;
          clients.set(ws, username);

          // Broadcast user joined
          broadcast({
            type: 'user:joined',
            username: username,
            users: Array.from(clients.values())
          }, ws);
          break;

        case 'message:chat':
          // Broadcast to all except sender
          broadcast(message, ws);
          break;

        case 'typing':
          broadcast(message, ws);
          break;

        case 'ping':
          ws.send(JSON.stringify({ type: 'pong' }));
          break;
      }
    } catch (error) {
      console.error('Message parse error:', error);
    }
  });

  ws.on('close', () => {
    if (username) {
      clients.delete(ws);

      broadcast({
        type: 'user:left',
        username: username,
        users: Array.from(clients.values())
      });
    }
  });
});

function broadcast(message, exclude = null) {
  const data = JSON.stringify(message);

  clients.forEach((username, client) => {
    if (client !== exclude && client.readyState === WebSocket.OPEN) {
      client.send(data);
    }
  });
}

console.log('WebSocket server running on port 8080');

Learn More

8. Service Worker API - Offline-First Web Apps 📴

Service Workers act as a proxy between web applications and the network, enabling offline functionality, background sync, and push notifications.

Complete PWA Implementation

// sw.js - Service Worker
const CACHE_VERSION = 'v1.0.0';
const CACHE_NAMES = {
  static: `static-${CACHE_VERSION}`,
  dynamic: `dynamic-${CACHE_VERSION}`,
  images: `images-${CACHE_VERSION}`
};

const STATIC_ASSETS = [
  '/',
  '/index.html',
  '/styles/main.css',
  '/scripts/app.js',
  '/offline.html',
  '/manifest.json'
];

// Install event - cache static assets
self.addEventListener('install', (event) => {
  console.log('Service Worker installing...');

  event.waitUntil(
    caches.open(CACHE_NAMES.static)
      .then(cache => cache.addAll(STATIC_ASSETS))
      .then(() => self.skipWaiting())
  );
});

// Activate event - cleanup old caches
self.addEventListener('activate', (event) => {
  console.log('Service Worker activating...');

  event.waitUntil(
    caches.keys()
      .then(cacheNames => {
        return Promise.all(
          cacheNames
            .filter(name => !Object.values(CACHE_NAMES).includes(name))
            .map(name => caches.delete(name))
        );
      })
      .then(() => self.clients.claim())
  );
});

// Fetch event - serve from cache, fallback to network
self.addEventListener('fetch', (event) => {
  const { request } = event;
  const url = new URL(request.url);

  // Handle different resource types
  if (request.destination === 'image') {
    event.respondWith(handleImageRequest(request));
  } else if (url.origin === location.origin) {
    event.respondWith(handleSameOriginRequest(request));
  } else {
    event.respondWith(handleCrossOriginRequest(request));
  }
});

async function handleImageRequest(request) {
  const cache = await caches.open(CACHE_NAMES.images);
  const cached = await cache.match(request);

  if (cached) {
    return cached;
  }

  try {
    const response = await fetch(request);

    if (response.ok) {
      cache.put(request, response.clone());
    }

    return response;
  } catch (error) {
    // Return placeholder image
    return caches.match('/images/placeholder.png');
  }
}

async function handleSameOriginRequest(request) {
  // Network-first strategy for API calls
  if (request.url.includes('/api/')) {
    return networkFirst(request);
  }

  // Cache-first strategy for static assets
  return cacheFirst(request);
}

async function handleCrossOriginRequest(request) {
  try {
    const response = await fetch(request);
    return response;
  } catch (error) {
    return new Response('Network error', { status: 503 });
  }
}

async function cacheFirst(request) {
  const cached = await caches.match(request);

  if (cached) {
    // Update cache in background
    updateCache(request);
    return cached;
  }

  try {
    const response = await fetch(request);
    const cache = await caches.open(CACHE_NAMES.dynamic);
    cache.put(request, response.clone());
    return response;
  } catch (error) {
    return caches.match('/offline.html');
  }
}

async function networkFirst(request) {
  try {
    const response = await fetch(request);
    const cache = await caches.open(CACHE_NAMES.dynamic);
    cache.put(request, response.clone());
    return response;
  } catch (error) {
    const cached = await caches.match(request);
    return cached || new Response(JSON.stringify({ error: 'Offline' }), {
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

async function updateCache(request) {
  try {
    const response = await fetch(request);
    const cache = await caches.open(CACHE_NAMES.dynamic);
    cache.put(request, response);
  } catch (error) {
    // Silently fail
  }
}

// Background Sync
self.addEventListener('sync', (event) => {
  if (event.tag === 'sync-data') {
    event.waitUntil(syncData());
  }
});

async function syncData() {
  const db = await openDB();
  const pendingData = await db.getAll('pending-requests');

  for (const item of pendingData) {
    try {
      await fetch(item.url, {
        method: item.method,
        headers: item.headers,
        body: item.body
      });

      await db.delete('pending-requests', item.id);
    } catch (error) {
      console.error('Sync failed:', error);
    }
  }
}

// Push Notifications
self.addEventListener('push', (event) => {
  const data = event.data ? event.data.json() : {};

  const options = {
    body: data.body || 'New notification',
    icon: data.icon || '/icon.png',
    badge: '/badge.png',
    data: data.data || {},
    actions: data.actions || []
  };

  event.waitUntil(
    self.registration.showNotification(data.title || 'Notification', options)
  );
});

self.addEventListener('notificationclick', (event) => {
  event.notification.close();

  event.waitUntil(
    clients.matchAll({ type: 'window', includeUncontrolled: true })
      .then(clientList => {
        // Focus existing window or open new one
        for (const client of clientList) {
          if (client.url === event.notification.data.url && 'focus' in client) {
            return client.focus();
          }
        }

        if (clients.openWindow) {
          return clients.openWindow(event.notification.data.url || '/');
        }
      })
  );
});

// Message handling
self.addEventListener('message', (event) => {
  if (event.data.action === 'skipWaiting') {
    self.skipWaiting();
  }

  if (event.data.action === 'clearCache') {
    event.waitUntil(
      caches.keys().then(names => 
        Promise.all(names.map(name => caches.delete(name)))
      )
    );
  }
});

// main.js - Register Service Worker
class ServiceWorkerManager {
  constructor(swPath = '/sw.js') {
    this.swPath = swPath;
    this.registration = null;
  }

  async register() {
    if (!('serviceWorker' in navigator)) {
      console.warn('Service Workers not supported');
      return false;
    }

    try {
      this.registration = await navigator.serviceWorker.register(this.swPath);
      console.log('Service Worker registered:', this.registration);

      // Check for updates
      this.registration.addEventListener('updatefound', () => {
        this.handleUpdate(this.registration.installing);
      });

      // Handle controller change
      navigator.serviceWorker.addEventListener('controllerchange', () => {
        console.log('New Service Worker activated');
        this.showUpdateNotification();
      });

      return true;
    } catch (error) {
      console.error('Service Worker registration failed:', error);
      return false;
    }
  }

  handleUpdate(worker) {
    worker.addEventListener('statechange', () => {
      if (worker.state === 'installed' && navigator.serviceWorker.controller) {
        // New update available
        this.showUpdatePrompt(worker);
      }
    });
  }

  showUpdatePrompt(worker) {
    const shouldUpdate = confirm('New version available! Reload to update?');

    if (shouldUpdate) {
      worker.postMessage({ action: 'skipWaiting' });
    }
  }

  showUpdateNotification() {
    const notification = document.createElement('div');
    notification.className = 'update-notification';
    notification.innerHTML = `
      <p>App updated! Reloading...</p>
    `;
    document.body.appendChild(notification);

    setTimeout(() => window.location.reload(), 1000);
  }

  async unregister() {
    if (this.registration) {
      return this.registration.unregister();
    }
    return false;
  }

  async update() {
    if (this.registration) {
      return this.registration.update();
    }
  }

  async enableBackgroundSync() {
    if (!this.registration) return false;

    try {
      await this.registration.sync.register('sync-data');
      return true;
    } catch (error) {
      console.error('Background sync registration failed:', error);
      return false;
    }
  }

  async subscribeToPush(vapidPublicKey) {
    if (!this.registration) return null;

    try {
      const subscription = await this.registration.pushManager.subscribe({
        userVisibleOnly: true,
        applicationServerKey: this.urlBase64ToUint8Array(vapidPublicKey)
      });

      return subscription;
    } catch (error) {
      console.error('Push subscription failed:', error);
      return null;
    }
  }

  urlBase64ToUint8Array(base64String) {
    const padding = '='.repeat((4 - base64String.length % 4) % 4);
    const base64 = (base64String + padding)
      .replace(/\\-/g, '+')
      .replace(/_/g, '/');

    const rawData = window.atob(base64);
    const outputArray = new Uint8Array(rawData.length);

    for (let i = 0; i < rawData.length; ++i) {
      outputArray[i] = rawData.charCodeAt(i);
    }

    return outputArray;
  }
}

// Usage
const swManager = new ServiceWorkerManager();

// Register on page load
window.addEventListener('load', async () => {
  const registered = await swManager.register();

  if (registered) {
    // Enable background sync
    await swManager.enableBackgroundSync();

    // Subscribe to push notifications
    const subscription = await swManager.subscribeToPush(VAPID_PUBLIC_KEY);

    if (subscription) {
      // Send subscription to server
      await fetch('/api/subscribe', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(subscription)
      });
    }
  }
});

// Queue requests for background sync when offline
window.addEventListener('offline', () => {
  console.log('App is offline. Requests will be queued.');
  document.body.classList.add('offline');
});

window.addEventListener('online', () => {
  console.log('App is online. Syncing queued requests.');
  document.body.classList.remove('offline');
  swManager.enableBackgroundSync();
});

manifest.json

{
  "name": "My Progressive Web App",
  "short_name": "MyPWA",
  "description": "A modern progressive web application",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#ffffff",
  "theme_color": "#007bff",
  "orientation": "portrait-primary",
  "icons": [
    {
      "src": "/icons/icon-72x72.png",
      "sizes": "72x72",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-96x96.png",
      "sizes": "96x96",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-128x128.png",
      "sizes": "128x128",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-144x144.png",
      "sizes": "144x144",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-152x152.png",
      "sizes": "152x152",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-192x192.png",
      "sizes": "192x192",
      "type": "image/png",
      "purpose": "maskable"
    },
    {
      "src": "/icons/icon-384x384.png",
      "sizes": "384x384",
      "type": "image/png"
    },
    {
      "src": "/icons/icon-512x512.png",
      "sizes": "512x512",
      "type": "image/png"
    }
  ],
  "shortcuts": [
    {
      "name": "New Post",
      "url": "/new-post",
      "icons": [{ "src": "/icons/new-post.png", "sizes": "96x96" }]
    },
    {
      "name": "Messages",
      "url": "/messages",
      "icons": [{ "src": "/icons/messages.png", "sizes": "96x96" }]
    }
  ],
  "categories": ["productivity", "social"],
  "screenshots": [
    {
      "src": "/screenshots/home.png",
      "sizes": "540x720",
      "type": "image/png"
    }
  ]
}

Learn More

9. Resize Observer API - Responsive Element Monitoring 📏

The Resize Observer API reports changes to the dimensions of an Element's content or border box.

Implementation

class ResponsiveManager {
  constructor() {
    this.observers = new Map();
    this.breakpoints = {
      mobile: 480,
      tablet: 768,
      desktop: 1024,
      wide: 1440
    };
  }

  observe(element, callback, options = {}) {
    const observer = new ResizeObserver(entries => {
      entries.forEach(entry => {
        const { width, height } = entry.contentRect;
        const { blockSize, inlineSize } = entry.contentBoxSize[0] || {};

        const data = {
          width,
          height,
          blockSize,
          inlineSize,
          element: entry.target,
          breakpoint: this.getBreakpoint(width)
        };

        callback(data, entry);
      });
    });

    observer.observe(element, options);
    this.observers.set(element, observer);

    return () => this.unobserve(element);
  }

  unobserve(element) {
    const observer = this.observers.get(element);
    if (observer) {
      observer.unobserve(element);
      this.observers.delete(element);
    }
  }

  getBreakpoint(width) {
    if (width < this.breakpoints.mobile) return 'xs';
    if (width < this.breakpoints.tablet) return 'mobile';
    if (width < this.breakpoints.desktop) return 'tablet';
    if (width < this.breakpoints.wide) return 'desktop';
    return 'wide';
  }

  disconnect() {
    this.observers.forEach(observer => observer.disconnect());
    this.observers.clear();
  }
}

// Usage
const manager = new ResponsiveManager();

manager.observe(document.querySelector('.container'), (data) => {
  console.log(`Width: ${data.width}, Breakpoint: ${data.breakpoint}`);

  // Apply responsive behavior
  if (data.breakpoint === 'mobile') {
    data.element.classList.add('mobile-layout');
  } else {
    data.element.classList.remove('mobile-layout');
  }
});

Learn More

10-15. Additional APIs

Due to length constraints, here are brief overviews of the remaining APIs:

10. Broadcast Channel API

Cross-tab communication for syncing state across browser tabs.

const channel = new BroadcastChannel('app-channel');
channel.postMessage({ type: 'logout' });
channel.onmessage = (e) => console.log(e.data);

11. WebGL API

Hardware-accelerated 3D graphics in the browser.

12. Payment Request API

Streamlined payment processing with native UI.

13. Credential Management API

Simplified authentication with password and biometric support.

14. Battery Status API

Monitor device battery level and charging status.

navigator.getBattery().then(battery => {
  console.log(`Battery: ${battery.level * 100}%`);
});

15. Screen Wake Lock API

Prevent screen from dimming or locking.

const wakeLock = await navigator.wakeLock.request('screen');

API Comparison Matrix

API	Complexity	Browser Support	Use Case	Performance Impact
IndexedDB	High	✅ Excellent	Large data storage	Low
Web Workers	Medium	✅ Excellent	Heavy computation	Positive (offloads main thread)
WebRTC	High	✅ Good	Real-time communication	High (bandwidth dependent)
Intersection Observer	Low	✅ Excellent	Lazy loading, scroll effects	Very Low
Service Worker	High	✅ Good	Offline functionality	Positive (caching)
WebSocket	Medium	✅ Excellent	Real-time updates	Low
Resize Observer	Low	✅ Good	Responsive layouts	Very Low
Web Speech	Medium	⚠️ Moderate	Voice interfaces	Medium

Learning Roadmap

Phase 1: Foundation (Weeks 1-2)

Storage API (localStorage/sessionStorage)
Fetch API
DOM Manipulation
Event Handling

Phase 2: Intermediate (Weeks 3-6)

Intersection Observer API
Clipboard API
Geolocation API
Canvas API
History API

Phase 3: Advanced (Weeks 7-12)

IndexedDB API
Web Workers API
Service Workers API
WebSocket API
Resize Observer API

Phase 4: Expert (Weeks 13+)

WebRTC API
WebGL API
Web Speech API
Payment Request API
Credential Management API

Best Practices

1. Feature Detection

Always check for API support before using:

if ('serviceWorker' in navigator) {
  // Use Service Worker
} else {
  // Provide fallback
}

2. Progressive Enhancement

Build core functionality first, then enhance:

// Basic functionality
function saveData(data) {
  localStorage.setItem('data', JSON.stringify(data));
}

// Enhanced with IndexedDB
if ('indexedDB' in window) {
  async function saveData(data) {
    await db.add('data', data);
  }
}

3. Error Handling

Always handle errors gracefully:

try {
  await navigator.clipboard.writeText(text);
} catch (error) {
  // Fallback to document.execCommand
  document.execCommand('copy');
}

4. Performance Optimization

Use Web Workers for heavy computation
Implement lazy loading with Intersection Observer
Cache resources with Service Workers
Throttle/debounce expensive operations

5. Security Considerations

Validate all user input
Use HTTPS for sensitive APIs (WebRTC, Geolocation, etc.)
Implement CSP headers
Sanitize data before storage

Real-World Project Ideas

1. Advanced PWA E-commerce Platform

APIs Used: Service Worker, IndexedDB, Payment Request, Push Notifications
Features: Offline shopping cart, order tracking, payment processing

2. Video Conferencing Application

APIs Used: WebRTC, Web Audio, Screen Wake Lock, WebSocket
Features: Multi-party video calls, screen sharing, real-time chat

3. Voice-Controlled Task Manager

APIs Used: Web Speech, IndexedDB, Web Notifications, Service Worker
Features: Voice commands, offline sync, smart reminders

4. Real-Time Collaborative Editor

APIs Used: WebSocket, IndexedDB, Broadcast Channel, Service Worker
Features: Multi-user editing, conflict resolution, offline editing

5. 3D Product Visualizer

APIs Used: WebGL, Web Workers, IndexedDB, Intersection Observer
Features: 360° product views, AR preview, lazy loading

Resources

Official Documentation

Tools & Libraries

Workbox: Service Worker library by Google
Comlink: Makes Web Workers easier
Socket.io: WebSocket library
Three.js: WebGL framework
Dexie.js: IndexedDB wrapper

Browser Support

Learning Platforms

Conclusion

Mastering these 15 Web APIs will transform your development capabilities. From building offline-first applications with Service Workers to creating real-time collaborative experiences with WebRTC and WebSocket, these APIs provide the foundation for modern web applications.

Remember:

Start with the basics and gradually progress
Always check browser compatibility
Implement progressive enhancement
Focus on user experience
Keep learning and experimenting

The web platform continues to evolve, and staying current with these APIs ensures you can build cutting-edge applications that provide exceptional user experiences.

Discussion

What APIs are you most excited to implement? Have you built anything interesting with these APIs? Share your experiences in the comments!

Tags: #webdev #javascript #api #programming #webdevelopment #pwa #webrtc #indexeddb #serviceworker #advancedweb

Author: Nishant Gaurav
Last Updated: February 2, 2026

Version: 1.0

Why I Started Learning C (And Why It Actually Mattered)

Nishant Gaurav — Tue, 20 Jan 2026 07:33:39 +0000

Look, I'm a web developer. I build stuff with Next.js and TypeScript. My projects? There's SkillBuilderJS where people practice JavaScript, FileNest for cloud storage, CodeKeys for typing practice. I even made 28+ VSCode themes that somehow got downloaded thousands of times. Point is - I live in the world of React hooks and npm packages.

So learning C? That wasn't exactly on my roadmap.

How This Actually Started

My friend Sid (@YONKO-SID on GitHub) pinged me one random evening. "Yo, wanna build an AI assistant in pure C?"

I was working on BackForge at the time - this tool that generates entire backend scaffolds automatically. Modern stack, lots of abstraction, everything automated. And here's Sid talking about building something in C. Like, why would anyone do that in 2024?

But Sid's different. He wanted to build a Jarvis-style assistant (yeah, like Iron Man) but without any frameworks or npm packages. Everything from scratch. File management, voice recognition, HTTP requests - all pure C code.

I thought he was trolling. Turns out he was serious.

The Part Where I Realized I Knew Nothing

We started Assistant-in-c. I took the developer tools part - Git integration, HTTP clients, port scanning, log monitoring. Stuff I'd knock out in an afternoon with Node.js.

Except there was no Node. No npm. No "let me just import this package."

HTTP request? Write socket code from scratch. JSON parsing? Build it yourself. Kill a process on port 3000? Raw system calls.

First week was brutal. I'd write 50 lines of C to do what took 5 lines of JavaScript. My brain was wired for fetch() and axios. Now I'm dealing with socket() and TCP handshakes and buffer management.

But something clicked around week three.

What Changed

I'd built API Visualizer before - a tool to test REST APIs. Used it plenty of times. Never thought about what actually happens when you hit an API endpoint. Node.js just... does it.

Writing C code for network stuff? You see everything. Socket creation. Connection establishment. Data serialization. HTTP headers being constructed byte by byte. All the magic that frameworks hide? Not hidden anymore.

Now when I write Node code, I get it. Why connection pooling exists. Why you shouldn't block the event loop. Why certain operations are slow. I've literally implemented these things manually in C.

My CodeKeys project tracks typing in real-time. Built it in React. Never worried about memory - React handles it, garbage collector does its thing. But in C, you're managing every single byte. Allocate it, use it, free it. Miss one free() call and you've got a memory leak.

Sounds tedious, right? But it made me write better React code. I started noticing unnecessary re-renders, inefficient state updates, wasteful data structures. SkillBuilderJS runs smoother now because I understand what's actually expensive.

Then I Did Something Stupid (Or Smart?)

After a few months with C, I started GetLainux. A Linux distribution. Built on Arch, minimal, command-line focused.

Was this necessary? No. Did I need it for work? Absolutely not. But I wanted to see how far I could push this C knowledge.

Building a Linux distro meant dealing with boot processes, package management, system initialization, kernel interactions. All that stuff I'd learned from the Jarvis project - file operations, process management, system calls - suddenly applied at a bigger scale.

GetLainux taught me more about how operating systems work than any course could. It's not pretty, it's not polished, but it works. And it exists because I learned C.

The Reality Check

Let me be clear - I'm not rewriting my Next.js projects in C. That would be insane.

But C knowledge changed how I approach web development:

FileNest (my cloud storage thing): I know exactly what happens when someone uploads a 200MB file. File I/O, buffer management, memory allocation. The optimizations I made came from understanding these low-level operations.

Convortex (file conversion tool): Image processing is CPU-intensive. Understanding C helped me pick the right libraries and optimize the conversion pipeline.

BookmarkBloom (bookmark manager): Data structures matter. Search algorithms matter. C taught me to think about efficiency in ways React never did.

Even my VSCode themes - understanding how compilation works made configuring build systems way less mysterious. Webpack config finally made sense.

Where C Actually Wins

C matters for specific stuff:

System software: GetLainux exists because of C. Linux kernel modifications, bootloaders, device drivers - that's C territory.

Performance-critical code: When milliseconds matter. Game engines, video codecs, compression, real-time systems.

Embedded systems: IoT, microcontrollers, automotive. They can't run a JavaScript runtime. Too much overhead.

Understanding foundations: Want to know how Python works? CPython's source is in C. V8 engine powering Node? C++. Everything traces back to C.

The Honest Part Nobody Talks About

C is frustrating. Really frustrating.

Segmentation faults at 3 AM? You'll experience this joy. Program crashes, debugger says "segmentation fault", and you spend hours finding one uninitialized pointer.

Memory leaks? Early in the Jarvis project, our assistant leaked memory everywhere. Every new feature made it worse. Took us weeks to track down every missing free().

Cross-platform builds? Code works on Linux, crashes on Windows. Different system calls, different libraries, different everything.

No instant feedback like web dev. Change code, compile, link, run, crash, debug, repeat. It's slow. It's painful. But you learn.

What I'm Actually Using Now

My current projects:

GetLainux - Linux distro (C, Bash, Go)
SkillBuilderJS - JS learning (Next.js, TypeScript, MongoDB)
FileNest - Cloud storage (Next.js 15, PostgreSQL)
CodeKeys - Typing practice (Next.js, Gemini AI)
BackForge - Backend generator (EJS)
VSCode Themes - 28+ themes
Assistant-in-c - AI assistant with Sid

Mostly web stuff. But C knowledge improved everything.

Should You Learn It?

Depends.

Don't bother if:

You just wanna build websites fast
Frontend/UI is your thing
You're doing data science (Python's better)
You need to ship prototypes quickly

Learn it if:

You want to actually understand computers
System programming interests you
You care about low-level optimization
You're curious what's under the abstractions
You wanna work on kernels, drivers, embedded systems

My Take

I'm still a web developer. TypeScript, React, Next.js - that's my daily work. I build SaaS products, developer tools, web apps. C isn't my main language.

But C made me significantly better. I understand performance, memory, compilation, system interactions. When I optimize my Next.js apps, I know exactly what I'm optimizing and why.

That Jarvis thing Sid and I built? It's messy. Code could be cleaner. Crashes sometimes. Has bugs. But building it - implementing 75+ features in pure C - taught me more than months of tutorials.

Would I tell a beginner to start with C? Probably not. Should you learn it eventually if you care about understanding computers? Yeah, definitely.

C isn't dying. It's not outdated. It's literally the foundation. Your OS? C. Your language's runtime? Probably C. Critical infrastructure? C everywhere.

Check my stuff:

Portfolio: nishantdev.space / rajdev.me
GitHub: @codewithevilxd
Projects: Web apps to Linux distros to everything in between

Ever learned a language that completely changed your perspective? Let me know what it was.

I Built a Small HTTP Server in C to Understand How the Web Actually Works

Nishant Gaurav — Sat, 10 Jan 2026 20:27:55 +0000

I Got Tired of Abstractions, So I Built a Tiny HTTP Server in C

Frameworks are great. I use them every day.

But at some point, I realized something uncomfortable:
I was building web apps without really understanding what actually happens when a browser talks to a server.

Routes, middleware, controllers — sab kuch kaam kar raha tha, but it felt like I was standing on too many layers of abstraction.

So I stopped reading tutorials and decided to do something more painful.

I built a tiny HTTP server in C.

No frameworks.
No helpers.
No “magic”.

Just sockets, threads, and raw HTTP requests hitting my terminal.

What I Wanted (and What I Didn’t)

This project was never about building a production server.

I wasn’t trying to compete with Nginx.
I wasn’t trying to be “secure”.
I wasn’t trying to be “fast”.

I only wanted answers to very basic questions:

What does an HTTP request really look like?

How does a server decide what file to return?

What happens between accept() and a browser rendering a page?

That’s it.

What This Server Actually Does

Here’s the exact scope — nothing more, nothing less:

Listens on port 8080

Handles GET requests only

Serves static files (HTML, text, images)

Uses POSIX threads (one client = one thread)

Sends proper Content-Type headers

Returns a plain 404 when a file doesn’t exist

It’s small enough to understand in one sitting.
And that’s the whole point.

Code Structure (Because One File Is a Nightmare)

I didn’t want everything dumped into main.c, so I split things up:

main.c → socket setup, bind, listen, accept loop

request.c → reads the request and handles the client

http.c → builds HTTP responses

utils.c → MIME types and URL decoding

Nothing fancy. Just separation of responsibility.

This alone made debugging way less painful.

The First “Oh Damn” Moment

When I printed the raw HTTP request to the terminal for the first time, it finally clicked.

`GET /index.html HTTP/1.1
Host: localhost:8080`

That’s it.
That’s what the browser sends.

No objects.
No JSON.
Just text.

At that point, HTTP stopped feeling mysterious.

Parsing Without Overthinking

I didn’t write a full HTTP parser.
I didn’t want to.

I used a small regex to extract the file path after GET /, decoded it, and moved on.

Is it fragile? Yes.
Is it enough to learn? Also yes.

Overengineering would’ve killed the whole point of this project.

Building the Response Manually

Another underrated realization:
HTTP responses are just text.

A valid response is literally:

status line

headers

empty line

body

Once I hardcoded that flow, everything made sense.

When a file wasn’t found, I sent back a simple 404.
No templates. No error pages. Just truth.

MIME Types: Small Detail, Big Lesson

At one point, HTML worked… but images didn’t.

Turns out browsers really care about Content-Type.

So I added a small extension → MIME mapping:

`.html → text/html

.jpg → image/jpeg

.png → image/png`

Suddenly, everything rendered correctly.

That tiny bug taught me more than a dozen blog posts ever did.

URL Encoding Is Annoying (But Necessary)

Browsers don’t send file names cleanly.
Spaces turn into %20. Special characters get encoded.

Without decoding them, random files just refused to load.

So yeah — I wrote a URL decoder.
Not because it was fun, but because reality demanded it.

Why C?

Because C doesn’t hide anything.

If something works, it’s because you made it work.
If something breaks, it’s also on you.

Writing this in C forced me to:

understand sockets properly

manage memory carefully

read actual system calls instead of abstractions

And honestly, it made me appreciate modern frameworks way more.

What This Server Is Bad At (On Purpose)

Let’s be clear — this server does not handle:

`POST requests

HTTPS

Keep-alive connections

Security

Real-world traffic`

And that’s fine.

This was a learning project, not a startup.

Final Thoughts

If you’ve never built a server without a framework, I think you should try it once.

Not to replace your tools.
But to understand them.

You don’t need to finish it.
You don’t need to polish it.
You just need to make it work.

For me, this project removed a lot of mental fog around HTTP.

And that alone made it worth it.

Thanks for reading 🙌

DEV Community: Nishant Gaurav

20 JS Features That Already Exist — Stop Writing the Polyfill

ES2021 — The Underappreciated Year

1. Logical Assignment Operators (&&=, ||=, ??=)

2. WeakRef and FinalizationRegistry

ES2022 — The Foundation Everyone Built On

3. Top-Level await

4. Private Class Fields (#)

5. Error.cause

6. Object.hasOwn()

7. .at() — Relative Array Indexing

8. structuredClone()

ES2023 — The Immutability Push

9. toSorted(), toReversed(), toSpliced()

10. .with() — Immutable Index Assignment

11. findLast() and findLastIndex()

ES2024 — Async and Data Handling

12. Promise.withResolvers()

13. Object.groupBy()

14. Array.fromAsync()

15. Promise.try()

ES2025 — JavaScript Gets Serious About Functional Patterns

16. Iterator Helpers

17. New Set Methods

18. RegExp.escape()

19. Float16Array

20. Explicit Resource Management (using)

The Pattern You Can't Miss

Rust Looks Scary. It's Not. You're Just Learning It Wrong.

What Rust Actually Does

Setting Up

Variables & Mutability

Data Types

Functions

Control Flow

Loops

Structs — Rust's Version of Objects

Enums — More Powerful Than You Think

The Big Three: Ownership, Borrowing, References

Ownership

Borrowing

Mutable References

Option — No More Null

Result — Handling Errors Properly

Vectors & HashMaps

Mini Project — CLI Todo App

The Compiler Is Not Your Enemy

Common Mistakes to Avoid

How to Practice

What's Next?

15 Advanced Web APIs Every Modern Developer Must Master 🚀

Table of Contents

1. IndexedDB API - Client-Side Database Powerhouse 💾

Why Use IndexedDB?

Production-Ready Implementation

Real-World Use Cases

2. Web Workers API - Multithreading in JavaScript ⚡

The Problem Web Workers Solve

Advanced Implementation with Worker Pool

Performance Comparison

Best Practices

3. WebRTC API - Real-Time Communication 📹

Complete Video Chat Implementation

Applications

4. Intersection Observer API - Efficient Scroll Detection 🎯

Advanced Implementation with Performance Optimization

CSS for Animations

Performance Benefits

5. Web Notifications API - Engage Users Effectively 🔔

Advanced Notification System

Best Practices

6. Web Speech API - Voice Interaction 🎤

Complete Voice Assistant Implementation

Multilingual Support

7. WebSocket API - Real-Time Bidirectional Communication 🔄

Production-Ready WebSocket Manager

Server-Side Example (Node.js)

8. Service Worker API - Offline-First Web Apps 📴

Complete PWA Implementation

manifest.json

1. Logical Assignment Operators (`&&=`, `||=`, `??=`)

3. Top-Level `await`

4. Private Class Fields (`#`)

5. `Error.cause`

6. `Object.hasOwn()`

7. `.at()` — Relative Array Indexing

8. `structuredClone()`

9. `toSorted()`, `toReversed()`, `toSpliced()`

10. `.with()` — Immutable Index Assignment

11. `findLast()` and `findLastIndex()`

12. `Promise.withResolvers()`

13. `Object.groupBy()`

14. `Array.fromAsync()`

15. `Promise.try()`

18. `RegExp.escape()`

19. `Float16Array`

20. Explicit Resource Management (`using`)