Pushing data in real time. (Long polling vs SSE vs Websocket vs QUIC with working example)

Rizwan C — Sat, 28 Feb 2026 13:51:42 +0000

Long Polling, Server-Sent Events, WebSockets, and QUIC — four ways to keep your clients in sync. Here's exactly how they work, when to use them, and what you're giving up.

Long Polling

Long polling is HTTP pretending to be real-time.
The client makes a normal HTTP request, but the server holds it open — sometimes for seconds or even minutes — until it has data to send. Once the response arrives, the client immediately fires off the next request.

It's a clever trick, and it works everywhere HTTP works. That's its superpower. But every message costs a full request/response cycle, header overhead and all.

How it works: Client polls -> Server waits -> Data arrives -> Server responds -> Connection closes -> Client immediately polls again.

Best for

Legacy system compatibility
Low-frequency updates
Strict corporate firewalls
Simple fallback mechanism

Pros

Works everywhere, any proxy
No special server setup
Easy to understand
Firewall friendly ### Cons
HTTP overhead (new HTTP request each time)
Not truly real-time
Heavy on server resources
Doesn’t scale well

Server-Sent Events (SSE)

SSE creates one persistent HTTP connection where the server streams a series of events down it indefinitely using a simple text format. The browser handles reconnection automatically.
It's unidirectional: server pushes, client listens.

Best for

AI token streaming (ChatGPT-style)
Live notifications
Stock tickers
CI/CD log tailing

Pros

Lightweight
Built in Auto-reconnect
Easy to implement
Great for notifications, dashboards

Cons

Unidirectional
Limited binary support
Not ideal for chat or gaming

WebSocket

WebSocket is what most developers reach for when they say "real-time."
It starts as an HTTP request, performs a protocol upgrade handshake and then becomes a persistent, full-duplex TCP connection. Both sides can send frames at any time, with minimal overhead.

Best for

Multiplayer games
Collaborative editing (Figma, Notion)
Live chat
IoT device control

Pros

Full-duplex
Low latency
Supports binary

Cons

Harder to scale
Needs load balancer config
No automatic reconnection

QUIC (HTTP/3)

QUIC is a modern transport protocol built on UDP, developed by Google. It powers HTTP/3.
QUIC bakes TLS 1.3 into the protocol itself and introduces independent stream multiplexing that eliminates TCP's core flaw: head-of-line blocking.
With TCP, a single lost packet blocks every stream behind it. QUIC streams are truly independent — one dropped packet only stalls its own stream.

Best for

High-performance games
High quality Video streaming (YouTube, Cloudflare)
Latency-sensitive APIs

Pros

Faster than TCP
Better mobile performance
Handles packet loss better
Future of web transport

Cons

Complex
Server infrastructure still maturing
WebTransport API still early

Example codes : https://github.com/rizwanc018/lp_sse_ws_quic

Mastering call, apply, and bind

Rizwan C — Mon, 23 Feb 2026 14:08:13 +0000

Understanding call, apply, and bind is essential if you want to truly master this (JavaScript function context).

In JavaScript, the value of this depends on how a function is called, not where it is defined.

const user = {
  name: "Jon",
  job: "engineer",
  intro() {
    console.log(`${this.name} is ${job}`);
  }
};

user.intro(); // Jon is engineer

But what if we want to use greet for another object?

That’s where call, apply, and bind come in.

call() - invokes function immediately and allows you to pass arguments individually.
apply() - similar to call(), but it accepts arguments as an array.
bind() - Unlike call and apply, bind() does NOT execute immediately. It returns a new function with this permanently bound.

call()

call() method invokes a function immediately. It takes the object you want to use as this as the first argument, followed by individual arguments for the function.

const user1 = { name: "Jon" };
const user2 = { name: "Ron" };

function intro(job) {
  console.log(`${this.name} is ${this.job}`);
}

intro.call(user1, "engineer");   // Jon is engineer
intro.call(user2, "teacher");   // Ron is teacher

apply()

apply() is similar to call(), The only difference is how it handles arguments: it takes them as an array instead of one by one.

function greet(city, country) {
  console.log(this.name + " is from " + city + ", " + country);
}

greet.apply(user1, ["Paris", "France"]); // "Jon is from Paris, France"

bind()

Unlike the other two, bind does not invoke the function immediately. Instead, it returns a new function with this permanently bound to the provided object

const jonIntro = intro.bind(user1, "engineer");

jonIntro(); // Jon is engineer

Polyfill for `call`, `apply` and `bind`

call()

Function.prototype.myCall = function (context, ...args) {
    context = context ?? globalThis;
    context = Object(context);

    const uniqueKey = Symbol();

    context[uniqueKey] = this;
    const result = context[uniqueKey](...args);

    delete context[uniqueKey];
    return result;
};

intro.myCall(user1, "engineer");   // Jon is engineer

apply()

Function.prototype.myApply = function (context, args = []) {
    context = context ?? globalThis;
    context = Object(context);

    const uniqueKey = Symbol();

    context[uniqueKey] = this;
    const result = context[uniqueKey](...args);

    delete context[uniqueKey];
    return result;
};

greet.myApply(user1, ["Paris", "France"]); // "Jon is from Paris, France"

bind()

Function.prototype.myBind = function (context, ...args) {
    const fn = this;

    return function (...newArgs) {
        return fn.apply(context, [...args, ...newArgs]);
    };
};

const jonIntro = intro.myBind(user1, "engineer");
jonIntro(); // Jon is engineer

DEV Community: Rizwan C

Pushing data in real time. (Long polling vs SSE vs Websocket vs QUIC with working example)

Long Polling

Best for

Pros

Server-Sent Events (SSE)

Best for

Pros

Cons

WebSocket

Best for

Pros

Cons

QUIC (HTTP/3)

Best for

Pros

Cons

Mastering call, apply, and bind

call()

apply()

bind()

Polyfill for call, apply and bind

call()

apply()

bind()

Polyfill for `call`, `apply` and `bind`