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.
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.
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.
The article compares polling, WebSocket, and Server‑Sent Events for server‑to‑client real‑time messaging, explains the advantages and drawbacks of each, and provides a complete Node.js/Express and plain‑HTML demo showing how to implement SSE as a lightweight alternative to WebSocket.
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.
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.
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.
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.
By sending a legitimate JSON payload that injects MongoDB operators such as $gt or $ne into the password field, attackers can trick a Node.js‑Express login endpoint into authenticating any user, illustrating how NoSQL injection bypasses authentication and how to detect and mitigate it.
ACE-Step UI is a completely free, locally run open-source interface for the ACE‑Step 1.5 AI music model, offering professional‑grade song generation, a modern React/Express stack, and a suite of audio tools, making it a viable alternative to Suno.
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.
This article walks through converting the Easysearch command‑line assistant into a web‑based tool by adding an Express API layer, reusing shared logic, and building a lightweight HTML/CSS/JS front‑end, while preserving the original CLI capabilities.
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.
The 2025 Node.js roundup highlights native TypeScript execution, the long‑awaited releases of Express 5.1 and Koa 3.0, TypeScript 5.8/5.9 enhancements, pnpm's delayed‑dependency feature, a series of supply‑chain attacks, and key official moves such as a Discord community and Corepack policy changes.
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.
This guide walks you through creating a full‑stack “afterlife” management platform that simulates traditional Chinese underworld processes, using a Node.js + Express + MySQL backend and a Vue + Element UI frontend, with step‑by‑step setup, configuration, and deployment instructions.
This article explains the double token (Access and Refresh) authentication mechanism, detailing its core principles, security benefits, and step‑by‑step implementation with Express on the backend and Vue on the frontend, including token issuance, verification, rotation, middleware, and client‑side handling.
This article walks through a complete Vue‑and‑Express solution for uploading massive files, detailing chunked splitting, hash‑based instant upload detection, resumable transfers, concurrency control, manual abort handling, and server‑side merging using streams, providing ready‑to‑use code snippets and performance optimizations.
This article walks through building a reusable TypeScript MCP Server framework using strategy and factory patterns, showing project setup, core type definitions, a sample DeployHtml tool, a singleton registry, Express‑SSE integration, automatic tool loading, and a side‑by‑side comparison with a Java implementation.
The article introduces easy.ui's honeycomb architecture that splits a monolithic frontend into an Express gateway, independent Nuxt sub‑projects, and a shared component library, detailing core code, development workflow, tech choices, pitfalls, and a future roadmap.
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.
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.
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.
This article walks through converting the open‑source SequentialThinking MCP Server from its default Stdio interface to an HTTP Server‑Sent Events (SSE) implementation using TypeScript, Express, and the MCP SDK, detailing configuration, code changes, route setup, and testing procedures.
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.
This tutorial walks through creating a weather‑focused MCP server with the Model Context Protocol TypeScript SDK, explaining Server‑Sent Events, setting up the Node.js environment, writing the TypeScript code, building, running, and testing the HTTP SSE service end‑to‑end.
Facing unexplained slowdowns in an Express site, I used the AI‑driven Trae IDE to automatically install Morgan, persist logs to rotating files, separate access and error logs, add buffering for performance, and even automate code commits, dramatically improving observability and debugging speed.
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.
This article narrates a dramatic front‑end takeover during a high‑traffic promotion, then provides a step‑by‑step guide to building a Node.js backend service with Express, MongoDB, JWT authentication, and deployment considerations, illustrating performance trade‑offs between Java and Node.js.
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.
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.
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.
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.
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.
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.
µExpress is a micro‑Express framework built on µWebSockets that offers full Express 4 compatibility while delivering 5‑10× higher request throughput across routing, middleware, and static‑file scenarios, as demonstrated by detailed wrk benchmarks and best‑practice guidelines.
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.
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.
This tutorial walks you through installing Node.js and npm, initializing a project, adding Express, creating routes, handling static files, processing POST requests with body‑parser, implementing simple in‑memory storage, adding error handling, and rendering HTML with EJS, all illustrated with complete code examples.
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.
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.
This article explains how session‑based and token‑based (JWT) authentication work in backend applications, compares their workflows, shows practical Express.js code examples, and helps you decide which method best fits your project's security and scalability needs.
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.
This article reviews four widely used authentication mechanisms—HTTP Basic authentication, session‑cookie based authentication, token (JWT) authentication, and OAuth 2.0—explaining their workflows, security characteristics, and providing Node.js/Express code examples for each.
This article shares a backend team's practical experience of adopting GraphQL with Express and Apollo Server as a BFF layer, covering motivations, implementation steps, schema merging, proxy configuration, HTTP caching strategies, DataLoader optimization, code generation, and integration testing to improve performance and developer efficiency.
This guide walks you through using Docker‑Compose to orchestrate a React front‑end, an Express back‑end, and a MariaDB database, covering environment setup, Dockerfile creation, Nginx configuration, container building, and common pitfalls for seamless full‑stack deployment.
This guide walks through using Docker Compose to package and launch a complete full‑stack application—including a React front‑end, an Express back‑end, and a MariaDB database—with a single command, covering prerequisites, Dockerfiles, Nginx configuration, and runtime management.
This guide walks beginners through the concepts, advantages, and practical steps of using Alibaba Cloud Function Compute to deploy popular web frameworks like Spring Boot and Express, create a custom Web IDE, and configure domains, while highlighting serverless architecture benefits and cost considerations.
This article explains how to migrate a traditional Node.js Express web application to a serverless environment by using an adaptation layer that maps function‑compute events to HTTP requests, covering both API‑gateway and HTTP triggers, core implementation steps, and alternative deployment methods.
This tutorial walks through creating a headless‑browser crawler using Puppeteer, extracting data from Juejin, storing it in a MySQL database, and exposing the results through an Express web service with user authentication, subscription, and a simple front‑end UI.
Node.js web frameworks have evolved from lightweight tools like Express to enterprise solutions such as Nest and Midway, and now to front‑end‑focused platforms like Next.js, with modern designs emphasizing modularity, type safety, serverless support, and developer‑friendly hooks that bridge front‑end and back‑end development.
This guide walks you through deploying a static website on Alibaba Cloud Function Compute by creating an Express‑based HTTP server, adding a bootstrap script, configuring Serverless Devs with an s.yaml file, deploying the code, and setting up a custom domain for public access.
HasChat is a free open‑source web chat application created by howcode that showcases a complete communication system using a modern front‑end stack (Vue3, Vite, TypeScript, Naive UI, Socket.io) and an Express.js back‑end, offering login, history, rich‑text, and image messaging features for beginners.
This article explains the concept of frontend‑backend integration, demonstrates how Vite can transform TypeScript functions into API requests without explicit AJAX calls, and provides a complete plugin implementation that intercepts, forwards, and handles these requests using Express and middleware.
This article explains React server-side rendering (SSR), covering the differences between client-side rendering (CSR) and SSR, their advantages and disadvantages, and provides a step-by-step guide to implementing a simple SSR demo with React.
This guide walks through installing Express and express‑generator, creating a new Express project with EJS templates, adding custom routes and route parameters, and using the next() function for middleware‑style control transfer, illustrating each step with concrete code snippets and command‑line examples.
This article explains the fundamentals of HTTP caching, covering strong and conditional cache mechanisms, the relevant response headers, and provides practical Node.js/Express code samples to demonstrate how browsers handle cache validation and expiration.
This article explains what microservices are, outlines their advantages and design considerations, and provides a practical Node.js/Express example that demonstrates a simple ticket‑query microservice along with deployment tips and best‑practice guidance.
The article argues that while middleware can simplify handling cross‑cutting concerns in HTTP APIs, overusing it leads to tangled, untestable code, and proposes refactoring middleware logic into pure functions with explicit inputs and outputs to improve clarity and maintainability.
A frontend team created a Docker‑based Express API to serve a shared navigation header, then tackled slow responses, UDP metric crashes, uncaught exceptions, Express error handling quirks, and static‑file performance bottlenecks, ultimately achieving stable sub‑second latency.
This tutorial explains how to use Next.js to create server‑rendered React applications that improve SEO and reduce initial load time, covering environment setup, page‑based routing, dynamic routes with Express, data fetching, prefetching, and hydration techniques.
This article explores the philosophical limits of design patterns and then dives into three core backend architectural patterns—Middleware, MVC, and Dependency Injection—illustrating their purpose, implementation in Node.js frameworks like Express and Koa, and their impact on code modularity and scalability.
At NodeConfBP, Snyk's Danny Grander demonstrated live attacks on a vulnerable Express 4.x app, exposing directory‑traversal, XSS, and remote memory leaks, then shared practical tips for building safer Node.js applications.
This tutorial walks through creating a simple REST API with POST, GET, PUT, and DELETE endpoints using Node.js, Express, MongoDB, and Mocha, demonstrating a test‑driven development workflow from writing tests to implementing passing code.
This guide introduces Express, a Node.js web framework, covering its advantages, environment setup, a step‑by‑step demo project, directory layout, core concepts such as routing, middleware and template engines, and practical code examples to help beginners launch a functional server quickly.
This guide outlines ten practical strategies—including parallel execution, async APIs, caching, gzip compression, client‑side rendering, lean sessions, query tuning, native V8 methods, Nginx front‑end, and JavaScript bundling—to dramatically boost the performance of Node.js web applications.
This article introduces Docker, explains its architecture and advantages over virtual machines, compares it with Vagrant, and provides a step‑by‑step tutorial for installing Docker on Fedora, pulling images, running a Node.js/Express app inside a container, and publishing the image to Docker Hub.
