This article walks through multiple ways to add real‑time in‑site notifications—such as the familiar red‑dot badge—to a web application, covering short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket, with complete Spring Boot code examples and client‑side snippets.
This guide explains what Server‑Sent Events (SSE) are, why they are needed for real‑time server‑to‑client communication, presents complete PHP and JavaScript examples, compares three implementation patterns, and contrasts SSE with WebSocket, highlighting strengths and limitations.
This article compares Server‑Sent Events, WebSocket, and long‑polling for real‑time data push in Spring Boot, explains their communication models, performance trade‑offs, and provides complete server‑side and client‑side code examples for implementing SSE and custom event types.
This article explains how to use HTTP Server-Sent Events (SSE) as an alternative to WebSocket for one‑way data push, demonstrating a NestJS backend implementation with @Sse decorator and Observable streams, and a React frontend using EventSource to receive real‑time JSON messages, including handling logs and binary data.
This tutorial explains the concept of Server‑Sent Events, compares it with WebSocket, and provides a step‑by‑step guide to create an SSE endpoint in a NestJS backend, enable CORS, and consume the stream from a React frontend using the native EventSource API.
This article explains various web message‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—detailing their principles, advantages, and step‑by‑step Spring Boot and JavaScript implementations with complete code examples.
The guide walks through building a real‑time instant‑messaging system—using a multiplayer monster‑battle demo—to compare polling, long‑polling, SSE and WebSocket, explains the WebSocket handshake and frame format, shows a custom Node.js server implementation, and advises adopting mature IM SDKs for production.
This article compares short polling, long polling, WebSocket, and Server‑Sent Events, explaining their mechanisms, advantages, drawbacks, and appropriate use cases, and provides practical code examples for implementing each method in modern frontend development.
This article explains various web message‑push techniques—including short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket—detailing their principles, advantages, drawbacks, and providing complete Spring Boot and JavaScript code examples for real‑time notification badges.
This article explains several server‑side techniques for real‑time web message push—including short and long polling, hidden‑iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides their principles, advantages, drawbacks, and complete Spring Boot/Java code examples for each approach.
The article narrates a CPU's journey from a naïve element‑wise increment loop to the adoption of SIMD, MMX, SSE, and AVX instruction sets, illustrating the motivations, challenges, and architectural decisions behind parallelizing integer and floating‑point operations.
This tutorial shows how to use Python's requests and JSON handling to crawl the Shanghai Stock Exchange website, extract periodic report metadata, construct PDF URLs, and automatically download the files, providing a practical example of backend web‑scraping automation while warning against excessive server load.
This article explains the concepts and practical implementations of real-time push techniques—including short polling, long polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, and providing complete JavaScript code examples for both client and server sides.
This article explains the concepts of streaming output and reactive programming, describes the underlying HTTP chunked transfer, SSE, WebSocket and RSocket protocols, provides code examples, and outlines practical scenarios where end‑to‑end streaming improves performance and user experience.
This article compares three real‑time data delivery techniques—long/short polling, Server‑Sent Events, and WebSockets—explaining their mechanisms, advantages, drawbacks, and providing sample client‑server implementations to help developers select the most suitable approach for a dashboard that streams GitHub/Twitter activity.
The article explains how Server‑Sent Events (SSE) provide a lightweight, one‑way server‑to‑client push mechanism that avoids the complexity of WebSocket or polling, shows its protocol details, compares it with WebSocket, and demonstrates integration with Spring MVC and the browser EventSource API.
This article reviews the main web push techniques—short polling, long polling, iframe streaming, WebSocket, and Server‑Sent Events—explaining their principles, advantages, disadvantages, and suitability, and presents a practical implementation case with a detailed comparison and troubleshooting guide.
This article walks through the evolution of front‑end communication techniques—from classic AJAX to JSONP, Server‑Sent Events, and WebSocket—explaining their principles, differences, and providing concise code demos for each method.
Server-Sent Events (SSE) provide a lightweight, HTTP‑based mechanism for real‑time server push, and this article explains its principles, compatibility, and step‑by‑step implementation—including a simple server that streams timestamps every second and a front‑end page that displays the incoming data.
This article explains how LinkedIn engineered its instant‑messaging service using Server‑Sent Events, Java, Akka, and Play, and details key kernel and system‑level optimizations—such as socket backlog, temporary port exhaustion, and file‑descriptor limits—that enabled each server to handle hundreds of thousands of persistent connections.
This article explains how HTTP/2 server push works, why it improves page load performance, and provides practical Node‑SPDY code examples for pushing assets, redirects, cache‑validation messages, and integrating Server‑Sent Events to notify clients of pushed resources.
A detailed case study shows how a 1% precision difference discovered by query‑diff testing was traced to CPU instruction‑set discrepancies (AVX vs SSE), highlighting the impact of hardware‑level floating‑point optimizations on algorithmic results and providing practical debugging and mitigation guidelines.
This article details a query‑diff test that revealed a 1% floating‑point precision difference after a module upgrade, describes the systematic investigation of environment, compilation, and CPU instruction‑set variations (AVX vs SSE), and presents conclusions and recommendations for preventing similar issues.
This article explains the concept of HTTP/2 server push, demonstrates how to implement it using the node‑spdy module with code samples for pushing assets, redirects, and SSE notifications, and discusses practical considerations and future possibilities for optimizing web performance.
