Tagged articles
Polling
63 articles · Page 1 of 1
This article compares polling, WebSocket, and Server-Sent Events (SSE) for server-to-client real-time messaging, detailing SSE's lightweight HTTP-based design, automatic reconnection, and simpler server requirements, then provides a complete Node.js/Express and vanilla HTML/JavaScript demo.
EventSourceExpressHTTP Long Connection
0 likes · 13 min read

The article compares polling, WebSocket, and Server‑Sent Events (SSE) for server‑to‑client real‑time messaging, explains each method’s mechanics, advantages and drawbacks, shows browser compatibility, outlines typical business scenarios, and provides a complete Node‑Express demo with code samples.
EventSourceExpressHTTP
0 likes · 12 min read

The article compares polling, WebSocket, and Server‑Sent Events (SSE) for server‑to‑client real‑time messaging, explains each method’s advantages and drawbacks, shows when to use SSE versus WebSocket, and provides a complete Node.js/Express demo with front‑end code.
ExpressHTMLJavaScript
0 likes · 13 min read

The article compares polling, WebSocket, and Server‑Sent Events for server‑to‑client push, explains why polling is inefficient, outlines the advantages and browser compatibility of WebSocket and SSE, and provides step‑by‑step Node/Express and plain‑HTML demos showing how to implement SSE in practice.
ExpressNode.jsPolling
0 likes · 12 min read

The article compares polling, WebSocket, and Server‑Sent Events (SSE) for server‑to‑client real‑time messaging, outlines each method’s drawbacks and advantages, and provides step‑by‑step demos showing how to implement SSE with a plain HTML page and a Node‑Express backend.
ExpressJavaScriptNode.js
0 likes · 16 min read

This article examines three server‑to‑client push methods—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their mechanisms, browser compatibility, pros and cons, suitable scenarios, and provides step‑by‑step demos with Node.js/Express and plain HTML to help developers choose the most efficient solution for real‑time messaging.
ExpressNode.jsPolling
0 likes · 16 min read

The article compares three server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their mechanisms, advantages, drawbacks, browser compatibility, and suitable use cases, and provides step‑by‑step Node/Express demos showing how to implement SSE in a simple web page.
ExpressJavaScriptNode.js
0 likes · 12 min read

The article dissects Claude Code’s Coordinator pattern, explaining how separating the control plane from the data plane eliminates serial bottlenecks, context overflow, and fault‑propagation in single‑Agent setups, and details the dual back‑end design, message protocol, engineering insights, technical debt, and practical adoption guidelines.
Backend AbstractionCoordinatorData Plane
0 likes · 16 min read


java1234Mar 31, 2026 · Backend Development
The article compares polling, WebSocket, and Server‑Sent Events (SSE), explains why polling is inefficient, outlines the advantages and browser compatibility of SSE versus WebSocket, and provides step‑by‑step Node.js and HTML demos for implementing a real‑time push solution.
EventSourceExpressNode.js
0 likes · 12 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, browser compatibility, key APIs, and provides a complete Node.js/Express demo with front‑end code to help developers choose the right solution for real‑time data scenarios.
ExpressNode.jsPolling
0 likes · 16 min read

This article explains why automatic update detection is essential for web apps, compares polling version files with server‑push techniques like SSE and WebSockets, and provides practical implementation steps and UX guidelines for prompting users to refresh.
PollingSSEUser Experience
0 likes · 6 min read

This comprehensive guide explores the core concepts, protocols, implementation steps, and typical use cases of WebSocket, Server‑Sent Events, WebRTC, and traditional polling, comparing their strengths and weaknesses to help developers choose the right real‑time communication technique for web applications.
PollingSSEWebRTC
0 likes · 21 min read

This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, browser compatibility, and appropriate use cases, and provides complete Node.js and HTML demos for implementing SSE.
BackendExpressNode.js
0 likes · 13 min read

This article explains why front‑end applications need automatic version detection, compares polling, Server‑Sent Events and WebSockets, and offers practical implementation tips and UX guidelines for prompting users to refresh to the latest release.
PollingSSEUser Experience
0 likes · 7 min read

This article explains server‑to‑client push scenarios, compares polling, WebSocket and Server‑Sent Events (SSE), details SSE APIs and browser compatibility, and provides complete front‑end and back‑end Node.js demos to help you choose the right technology for real‑time data delivery.
Node.jsPollingSSE
0 likes · 11 min read

This article compares polling and WebSocket approaches for delivering real‑time updates, explains their advantages and drawbacks, provides React and Node.js code examples, and offers practical guidance on selecting the appropriate method based on task frequency and user experience requirements.
PollingReactReal-time
0 likes · 7 min read

This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, compatibility, typical use cases, and provides complete Node.js/Express and plain‑HTML demos to help developers choose the right solution.
ExpressNode.jsPolling
0 likes · 13 min read

This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, suitable business scenarios, and provides step‑by‑step demo code for implementing SSE with Node.js and plain JavaScript.
ExpressJavaScriptNode.js
0 likes · 14 min read

This article examines the inefficiencies of traditional setInterval polling and presents three intelligent alternatives—using recursive setTimeout, applying exponential backoff, and leveraging the Page Visibility API—while providing code samples and highlighting their benefits over naive polling.
Frontend DevelopmentJavaScriptPage Visibility API
0 likes · 6 min read

This article examines three server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events (SSE)—by detailing their mechanisms, listing concrete drawbacks and advantages, comparing them side‑by‑side, and providing step‑by‑step Node.js demos for real‑time dashboards and chat scenarios.
ExpressJavaScriptNode.js
0 likes · 13 min read

This article explains why automatically detecting new front‑end releases is essential, compares polling version files with server‑push techniques such as SSE and WebSockets, and offers practical implementation tips and user‑experience guidelines for prompting users to refresh their browsers.
PollingUser Experienceauto-update
0 likes · 8 min read

This article explains the scenarios where servers need to push data to clients, compares three implementation methods—polling, WebSocket, and SSE—highlights their advantages and drawbacks, and provides step‑by‑step frontend and Node.js backend demos for building a real‑time SSE connection.
ExpressJavaScriptNode.js
0 likes · 13 min read

The article explains how 1960s batch systems suffered from CPU waste due to polling I/O devices, how IBM 704’s overflow flag inspired automatic error handling, and how the concept evolved into hardware interrupts with a concrete design, interrupt types, and vector table implementation.
CPULow-Level ProgrammingPolling
0 likes · 7 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and SSE—detailing their principles, advantages, and drawbacks, then provides a step‑by‑step Node/Express and plain‑HTML demo showing how to create and use an SSE connection.
ExpressJavaScriptNode.js
0 likes · 11 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and SSE—detailing their principles, pros and cons, browser compatibility, and provides step‑by‑step Node.js/Express and plain JavaScript demos to illustrate how to implement SSE in real‑time applications.
ExpressJavaScriptNode.js
0 likes · 13 min read

This article explains the principles and use cases of Server‑Sent Events (SSE), compares it with traditional polling and WebSocket solutions, outlines their advantages and drawbacks, and provides complete front‑end and Node.js/Express demo code to build a real‑time push system.
ExpressJavaScriptNode.js
0 likes · 13 min read

This article explains the use cases and implementation of Server‑Sent Events (SSE), compares it with polling and WebSocket, details its API and browser compatibility, and provides complete front‑end and Node‑Express back‑end demo code for building a real‑time push service.
ExpressNode.jsPolling
0 likes · 15 min read

This article explains server‑push scenarios such as real‑time dashboards and chat, compares three implementation methods—polling, WebSocket, and SSE—details the advantages and drawbacks of each, and provides step‑by‑step Node.js and frontend demos for using SSE in web applications.
BackendExpressNode.js
0 likes · 14 min read

This tutorial compares server‑push techniques—polling, WebSocket, and Server‑Sent Events—detailing their mechanisms, advantages, and drawbacks, then walks through setting up a simple SSE demo with Node.js and plain HTML, helping developers pick the right solution for real‑time data scenarios.
ExpressNode.jsPolling
0 likes · 13 min read

The article explains how early batch-processing systems relied on inefficient polling of slow I/O devices, describes the inspiration from IBM 704's overflow flag, and details the invention and implementation of hardware and software interrupts, including interrupt types, vector tables, and handler functions, to enable efficient CPU‑device interaction.
CPUException HandlingPolling
0 likes · 7 min read

This article explains Server‑Sent Events (SSE), compares it with polling and WebSocket, outlines its advantages and limitations, provides API usage examples, and offers a complete Node.js/Express demo with front‑end code to illustrate real‑time one‑way data push.
ExpressNode.jsPolling
0 likes · 9 min read

This article compares Server‑Sent Events, WebSocket, and traditional polling, explains why SSE can replace heavyweight WebSocket in one‑way push scenarios, provides configuration and code examples for Spring Boot, and shares practical lessons from real project experiences.
PollingSSEServer-Sent Events
0 likes · 12 min read

This article compares three real-time data update techniques—short and long polling, WebSocket, and Server‑Sent Events—explaining their principles, advantages, drawbacks, and providing practical Vue and Node.js code examples to help developers choose the optimal solution for their specific use case.
Node.jsPollingReal-time
0 likes · 14 min read


大转转FEJan 10, 2025 · Backend Development
This article compares three real‑time data update methods—short and long polling, WebSocket, and Server‑Sent Events—explaining their principles, advantages, drawbacks, and providing practical code examples so developers can choose the most suitable solution for their web applications.
BackendPollingReal-time
0 likes · 16 min read

This article explains the lightweight Server‑Sent Events (SSE) approach for one‑way server push, compares its features, connection model, performance and use cases against WebSocket and traditional polling, and provides a SpringBoot example with code snippets for building an online‑user SSE endpoint.
PollingSSESpringBoot
0 likes · 11 min read

This article compares Server‑Sent Events, traditional polling, and WebSocket for server‑to‑client real‑time messaging, explains why WebSocket may be overkill for one‑way push scenarios, and provides a Spring Boot example of an SSE endpoint with code and configuration details.
PollingSpring BootWebSocket
0 likes · 7 min read

This article explains the three common server‑to‑client push methods—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, browser compatibility, and provides step‑by‑step demo code for both frontend and Node.js backend implementation.
ExpressNode.jsPolling
0 likes · 14 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their advantages, drawbacks, suitable business scenarios, and provides step‑by‑step demo code for both frontend and Node.js backend implementations.
BackendExpressNode.js
0 likes · 13 min read

This article explains the three main server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their advantages, drawbacks, browser compatibility, and provides step‑by‑step Node.js and front‑end demos for implementing SSE in real‑time applications.
JavaScriptNode.jsPolling
0 likes · 9 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events—detailing their principles, advantages, drawbacks, appropriate use‑cases, and provides complete front‑end and Node‑Express back‑end demo code to help developers choose and implement the right solution.
ExpressNode.jsPolling
0 likes · 12 min read

This article reviews common real‑time message push techniques—including short and long polling, Server‑Sent Events, WebSocket, Netty, and MQTT—explaining their implementation ideas, core code snippets, advantages, and drawbacks so you can choose the most suitable solution for your business scenario.
MQTTMessage PushPolling
0 likes · 8 min read

This article explains the three common server‑to‑client data push methods—polling, WebSocket, and SSE—detailing their principles, advantages, disadvantages, suitable business scenarios, and provides step‑by‑step Node.js/Express and plain JavaScript demos for implementing SSE.
ExpressJavaScriptNode.js
0 likes · 12 min read

This article explains the three common server‑to‑client push techniques—polling, WebSocket, and Server‑Sent Events (SSE)—detailing their principles, advantages, drawbacks, browser compatibility, appropriate use‑cases, and provides a complete Node.js/Express demo with front‑end code.
ExpressNode.jsPolling
0 likes · 13 min read

This article walks through the requirements, backend API design, and front‑end implementation—including TypeScript code snippets—for a QR‑code login system where the code expires after two minutes, users confirm login on mobile, and the web client polls for status updates.
API DesignAuthenticationPolling
0 likes · 8 min read

This guide explains Linux serial port device files, shows how to list them, and provides four C programming methods—polling, select‑based interrupt, SIGIO signal handling, and threaded reading—complete with code examples and detailed configuration steps.
C++Device FilesLinux
0 likes · 10 min read

The article analyzes the growing demands on network I/O, outlines Linux and x86 bottlenecks, and explains how DPDK’s user‑space bypass, UIO, PMD, and various optimization techniques such as HugePages, SIMD, and cache‑friendly design enable multi‑hundred‑million‑packet‑per‑second processing.
DPDKHugePagesLinux
0 likes · 13 min read

This article explains how Ansible’s async and poll parameters enable background execution of long‑running tasks, allowing playbooks to continue without blocking, and provides practical examples, configuration tips, and status‑checking techniques for reliable DevOps automation.
AnsibleDevOpsPolling
0 likes · 10 min read

This article compares three real‑time communication techniques—long/short polling, WebSockets, and Server‑Sent Events—by explaining their mechanisms, presenting client‑ and server‑side code examples, and discussing their advantages, drawbacks, and suitable use‑cases to help developers select the appropriate method for a dashboard application.
BackendPollingReal-time
0 likes · 12 min read

This article explains the typical e‑commerce payment flow, analyzes why duplicate payments occur due to missing locks, drop‑offs, and multi‑channel issues, and presents practical backend techniques such as distributed locking, result caching, payment‑stream cancellation, refund handling, active polling, and client‑side pull/push strategies to reliably prevent repeated payments.
Pollingduplicate paymente-commerce
0 likes · 10 min read

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.
Long PollingPollingReal-time
0 likes · 13 min read

This article explains the complete e‑commerce payment flow, identifies why orders can be paid twice—including lack of deduplication, lost orders, and multi‑channel issues—and presents practical solutions such as distributed locking, result caching, transaction cancellation, refunds, active polling, and sync‑async notifications to reliably avoid duplicate payments.
Distributed LockPollingduplicate payment
0 likes · 12 min read

This article analyzes the shortcomings of the traditional poll‑then‑process loop in Kafka consumers, explains configuration pitfalls such as max.poll.interval.ms, and proposes a more robust architecture using work queues, a poller, an executor, and an offset manager to achieve at‑most‑once, at‑least‑once, and exactly‑once processing guarantees.
ConsumerJavaKafka
0 likes · 15 min read

An in‑depth look at a real‑world file‑watching failure caused by a JDK timestamp bug, exploring Java’s WatchService implementation, its reliance on polling versus Linux’s inotify, and practical workarounds to ensure reliable configuration reloads across platforms.
File MonitoringJDK bugJava
0 likes · 10 min read

The article explains why fixed sleep calls are inefficient for asynchronous operations, introduces polling as a flexible alternative, provides Python code examples with the polling library, discusses advantages and disadvantages, and presents decorator and generic‑function abstractions for reusable polling logic.
DecoratorPollingPython
0 likes · 7 min read

The design separates the original I/O pool into dedicated network, I/O, and polling thread pools, adds comprehensive monitoring of task duration and frequency, enforces unified polling rules, and automatically tunes pool parameters, resulting in a 76 % reduction in UI lag and easier troubleshooting.
PollingRxJavamobile performance
0 likes · 12 min read

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.
BackendPollingReal-time
0 likes · 14 min read

This article summarizes essential concepts and practical optimization strategies for DPDK, covering architecture fundamentals, x86 performance analysis, virtualization overhead, NFV forwarding bottlenecks, huge‑page usage, polling modes, CPU affinity, and I/O virtualization techniques to achieve high‑throughput, low‑latency packet processing.
CPU affinityDPDKNFV
0 likes · 30 min read

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.
BackendJavaScriptPolling
0 likes · 12 min read

This article explains four common Java thread communication techniques—synchronized blocks, while‑polling, wait/notify, and piped streams—providing code examples and discussing their advantages, drawbacks, and practical usage in multithreaded applications.
JavaPiped StreamsPolling
0 likes · 10 min read


政采云技术Nov 20, 2019 · Frontend Development
This article explains the limitations of short and long polling, introduces the WebSocket protocol and its handshake mechanism, and provides complete client‑side and Node.js server code to build a basic real‑time chat application with heartbeat keep‑alive support.
Long PollingNode.jsPolling
0 likes · 11 min read


21CTOMar 18, 2019 · Frontend Development
This article reviews the evolution of web real‑time push techniques—polling, long‑polling, iframe streaming—and explains why WebSocket offers superior bidirectional communication, lower latency, and reduced bandwidth, while providing practical code examples for each method.
Long PollingPollingWebSocket
0 likes · 12 min read

Testing asynchronous systems requires specialized strategies—monitoring callbacks with synchronization primitives and reliable polling with timeouts, delays, and frequencies—to handle nondeterministic execution, avoid flaky assertions, and improve testability by decoupling business logic from periodic scheduling, as demonstrated by real‑world polling implementations for Elasticsearch and MySQL/Redis jobs.
Java TestingPollingasynchronous testing
0 likes · 6 min read

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.
PollingSSEWebSocket
0 likes · 9 min read
