This article analyzes the reasons for preferring EventSource instead of WebSocket in a browser‑based ChatGPT chat system, covering protocol basics, system characteristics, advantages, code examples, performance trade‑offs, and future extensibility.
This article introduces the yargs Node.js library for building command‑line interfaces, demonstrates core features such as automatic help generation, type validation, alias handling, and sub‑command support with code examples, and explains the underlying Levenshtein distance algorithm used for command recommendation.
This article introduces the Yargs Node.js library for building command‑line interfaces, demonstrates how to define options, aliases, sub‑commands, and automatic help, and explains the Levenshtein distance algorithm used for command recommendation, complete with practical code examples and performance considerations.
This article explains why TypeScript’s process.env lacks autocomplete, shows three approaches—including global type augmentation, a custom getter function, and using t3‑env with Zod—to ensure environment variables are type‑safe and available at runtime.
This guide explains the Node.js child_process module, covering its purpose, the four creation methods (exec, execFile, spawn, fork), how to handle output streams, inter‑process communication, best‑practice management tips, and when to choose child processes over worker threads.
This article walks through creating a Juejin comment bot that polls for article links, uses the 豆包 MarsCode AI IDE to generate summarization code via its API, and automatically posts the summary back as a comment, covering environment setup, task breakdown, code generation, and deployment.
This article explains WebRTC fundamentals, the PeerConnection API, signaling, ICE, STUN/TURN servers, the full P2P call flow, and provides a Node.js WebSocket signaling server example for front‑end developers building real‑time communication.
The VS Code 1.93 release brings a major shift to ESM modules, fixes SQL language highlighting, adds configuration file UI improvements, introduces Django test support, and enhances IntelliSense and experimental network inspection for JavaScript and Node.js developers.
This article explores WebRTC’s fundamental architecture, detailing PeerConnection terminology, core methods and events, various connection strategies—including local network, STUN, and TURN—and walks through the complete signaling and ICE exchange process, culminating in a step‑by‑step Node.js WebSocket signaling server implementation with full code examples.
This article explains how to implement an online‑user counter using Redis sorted sets by detailing the four essential ZSET commands, fingerprint‑based user identification, Java and JavaScript code examples, and scheduled cleanup for accurate real‑time statistics.
This article explains how async/await simplifies callback and Promise code in Node.js, covering async function basics, error handling, retry strategies, parallel execution, array iteration pitfalls, and step‑by‑step refactoring of callback‑ and Promise‑based applications into clear, maintainable async/await code.
Node.js now includes native TypeScript support, letting developers run .ts files directly without extra tools, which simplifies development, removes additional dependencies, and provides a more seamless experience for JavaScript back‑end projects.
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 guide explains why .env files are used, how to install and configure the dotenv package, handle multiple environments, expand variables, and secure secrets with dotenvx, providing clear code examples and best‑practice recommendations for Node.js developers.
This article reviews four modern Node.js version managers—VMR, vfox, Volta, and fnm—detailing their cross‑platform support, multi‑language capabilities, user‑friendly interfaces, and GitHub links, and explains why they can be more powerful and convenient alternatives to the classic NVM tool.
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.
Node.js v22.6.0 introduces the experimental --experimental-strip-types flag, enabling developers to execute TypeScript files directly, but it only strips type annotations at runtime and imposes several usage constraints such as mandatory type‑only imports and explicit file extensions.
This article examines various image‑generation approaches, compares web‑frontend, client‑side, and backend methods, introduces a new Node‑backend solution based on Satori to convert HTML to SVG and then to PNG with Resvg (later Sharp), and details performance and memory optimizations that dramatically improve speed, resource usage, and stability for large‑scale image‑service deployments.
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 guide explains why developers love Google DevTools, introduces VS Code's launch.json for configuring debugging sessions, covers REPL basics, provides practical examples for Node.js and Chrome debugging, and details every launch.json option with descriptions, types, defaults, and sample code.
This article compares three popular Node.js version managers—fnm, nvm, and Volta—detailing their speed, size, features, ease of use, and community support, and provides guidance on which tool best fits developers’ needs for efficient JavaScript environment management.
This guide walks you through installing, configuring, and using Egg‑Sequelize in Egg.js, explains core ORM features, demonstrates model definition and CRUD operations, and covers advanced topics such as complex queries, transactions, validation, migrations, associations, and common pitfalls to avoid.
Node.js merged PR #53725, introducing the --experimental-strip-types flag that lets developers run TypeScript files directly by transpiling them to JavaScript without type checking, while outlining current limitations such as missing enum and namespace support, .ts file handling, and source‑map absence.
This tutorial explains the fundamentals of Node.js debugging, covering V8 and Chrome DevTools Protocol basics, step‑by‑step CDP usage, built‑in debugger commands, and detailed VS Code configuration to help developers efficiently locate and fix issues.
This article demystifies the JavaScript event loop, explaining how browsers and environments like Node.js manage asynchronous tasks through call stacks, macro‑ and micro‑task queues, and various implementation libraries, illustrated with clear code examples and comparisons across Chrome, Firefox, Safari, Edge, Electron, and Deno.
This comprehensive guide walks you through initializing a TypeScript project, explains core and advanced type features, shows how to integrate third‑party libraries, and provides real‑world examples for React and Node.js, while offering best‑practice tips to boost code quality and performance.
Understanding the SameSite attribute lets developers control cookie transmission across sites, balancing security and usability by choosing Strict for maximum protection, Lax for a user‑friendly compromise, or None (with Secure) for cross‑site scenarios, with practical code examples and usage guidelines.
TransformStream, a core component of the Streams API, enables developers to process and convert data chunks on the fly, offering examples ranging from simple text uppercase conversion to complex scenarios like compression, video transcoding, real-time IoT filtering, and handling common pitfalls such as errors and backpressure.
This guide walks through setting up Jenkins with Docker Compose, installing Node.js, configuring npm to use the Taobao mirror, and creating a Jenkins pipeline to compile and package a Vue application, including troubleshooting tips for common errors.
This article explains what Node.js is, its role as a JavaScript runtime for server‑side programming, the fundamentals of the B/S architecture, and how browsers, web servers, application servers, and databases interact to deliver static and API services.
This article reviews the ten most valuable JavaScript libraries for 2024—including React, Redux, D3.js, TensorFlow.js, Angular, Node.js, Vue, Svelte, Three.js, and Lodash—detailing their core features, performance benefits, typical use cases, and why they remain essential tools for modern frontend development.
Learn how to boost Node.js application performance using the popular lru-cache package, covering the LRU algorithm fundamentals, basic installation and usage, advanced features like peek, fetchMethod, and custom disposal, plus an in‑depth look at its internal Map and doubly‑linked list implementation.
This beginner-friendly Node.js course guides learners through installation, environment setup, asynchronous programming, module systems, event-driven architecture, and building efficient web servers with practical examples covering HTTP handling, file operations, and database integration.
This guide walks you through creating a VS Code extension that automatically detects the Node.js version specified in each project's package.json and switches the editor’s environment accordingly, covering setup with Yeoman, core activation code, debugging, packaging, and publishing to the Marketplace.
This article reviews the five most popular Node.js backend frameworks of 2024—Express.js, NestJS, Koa.js, Hapi.js, and Adonis.js—highlighting their core features, typical use cases, and providing code examples to help developers choose the right tool for their projects.
This article recounts a failed Node.js installation on an older Ubuntu server caused by a missing GLIBC 2.28 library, details the attempted GLIBC upgrade script that led to system-wide segmentation faults, and explains how reinstalling a newer Ubuntu version resolved the issue while emphasizing careful backup practices.
This article explains how to create two interactive Coze bots—a fish‑knowledge quiz and a nostalgic 147‑258‑369 chess game—by designing workflows, integrating large language models, using databases, and implementing Node.js code for canvas drawing and GIF generation, complete with deployment tips.
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.
This guide explains how to create a Node.js script that automatically generates export statements for component libraries, covering script basics, file operations with fs‑extra, package imports, npm integration, and debugging techniques using VS Code.
The article details the technical architecture and design of the StarCreate landing‑page editor, describing its monorepo structure, low‑code JSON template, backend permission system, canvas implementation choices, Valtio state management, and the resulting operational benefits and future expansion plans.
This tutorial explains how to combine Node.js with OpenAI's AIGC to build a backend service that reads user comments, sends them to a GPT‑3.5‑turbo model for sentiment classification, and outputs whether the sentiment is positive or negative, complete with setup steps and full source code.
This article details how to create a Teamfight Tactics assistant bot on the Coze low‑code AI platform, covering background motivation, Coze features, workflow design, Node.js plugin development, API implementation, scheduled data clearing, and future improvement plans.
This curated roundup highlights recent technical resources—including React Compiler, Deno's JSX migration, Node v22.2.0, image loading optimizations, short‑URL generation, hooks ref handling, HTTP proxy solutions, and notification system design—to keep developers up‑to‑date with modern web development practices.
Traditional PHP architectures suffer from single‑threaded request handling that slows page loads on high‑traffic e‑commerce sites, whereas Node.js’s asynchronous, non‑blocking I/O and event‑driven architecture provide faster loading, superior scalability, and real‑time capabilities, making it a better fit for platforms like Amazon.
The article examines PHP’s role in web development, outlining its strengths such as ease of use, open‑source community, and server‑side capabilities, while also discussing reasons for its declining popularity, the shift to JavaScript frameworks, and why it still remains a viable backend choice for many projects.
This article introduces how to use NAPI‑RS for developing, debugging, and publishing Node.js extensions in Rust, covering Rust’s growing role in frontend tooling, project setup with @napi‑rs/cli, exposing functions and objects to JavaScript, handling callbacks, asynchronous calls, and CI/CD build and release processes.
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 provides a comprehensive tutorial on building cross‑platform desktop applications with Electron, covering environment setup, essential command‑line tools, project initialization, detailed source‑code directory structure, main and renderer processes, inter‑process communication, and example projects such as a music player.
This article traces the evolution of JavaScript package managers—from early manual inclusion methods to npm, Yarn, and pnpm—detailing their architectures, performance characteristics, version‑locking mechanisms, and trade‑offs, helping developers choose the most suitable tool for modern frontend projects.
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 combining AI with Node.js crawling through the x‑crawl library makes web data collection more intelligent, flexible, and resilient to website changes, and provides detailed feature descriptions, code examples, and practical usage scenarios.
A Tencent engineer fixed a severe memory‑leak in the qs library’s encode function by processing 30 MB strings in 1024‑character chunks, reducing heap usage from 2.5 GB to 0.48 GB and cutting runtime from 7.9 s to 2.1 s, achieving a five‑fold speedup and memory reduction, and contributed the change as an open‑source pull request.
This guide introduces CozeIDE, explains its main features such as code editing, dependency management, AI programming assistant, testing and publishing, and walks you through two complete plugin development examples—including a stock‑price lookup plugin—showing how to create, test, and release plugins using Node.js or Python runtimes.
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 explores the hidden complexities of dependency management in modern Node.js development, covering the risks of unstable package structures, versioning pitfalls, various dependency types, ghost and circular dependencies, and provides practical strategies and best‑practice recommendations to keep dependency graphs stable, secure, and maintainable.
This article traces the evolution of JavaScript module systems—from the early script tags and manual dependency ordering, through CommonJS, AMD, and UMD, to the modern ECMAScript modules—explaining their origins, challenges, and how bundlers and package fields enable seamless usage across browsers and Node.js environments.
This comprehensive tutorial walks you through creating a Node.js command‑line scaffolding tool that uses yargs for argument parsing, inquirer for interactive prompts, copy‑dir for file operations, mustache for dynamic templates, and pnpm with ora for automated dependency installation, all organized in a monorepo structure.
An overview of the five most popular Node.js backend frameworks in 2024—Express.js, NestJS, Koa.js, Hapi.js, and Adonis.js—detailing their key features, typical use cases, and code examples to help developers choose the right tool for building scalable web applications.
Node.js extends JavaScript to the server, offering a lightweight, event‑driven runtime that front‑end developers use for APIs, tooling, and SSR, while version‑management tools like NVM, N, and Volta simplify installing and switching multiple Node versions, each with distinct strengths in maturity, speed, and project‑level automation.
After six years of rapid growth, the open‑source RSSHub project faces hidden maintenance costs, outdated architecture, and scalability challenges, prompting its author to overhaul the codebase with modern technologies like TypeScript, ESM, and a new framework to ensure future sustainability.
This article explains how to construct effective SQL prompts by combining personal SQL expertise with large language model capabilities, introduces the open‑source sql‑translator tool for bidirectional SQL‑natural language conversion, and discusses practical productization scenarios.
The ioredis author @Luin announced the library's acquisition by Redis Inc., recounting its nine‑year evolution from a personal side project created to address missing Promise support, aesthetic command syntax, and lacking Cluster/Sentinel features into the most popular Node.js Redis client today.
This guide introduces Strapi, an open‑source headless CMS, covering its key features, quick installation, language switching, basic usage for creating content types, exposing RESTful and GraphQL CRUD APIs, visualizing data with external tools, and migrating SQLite databases to other systems.
The article details how a Node‑based business gateway for QQ Channel services replaced legacy RPC with a lightweight tRPC solution, achieving ten‑fold latency reduction, higher QPS, improved security and availability, and added observability through logging, metrics, and a WebSocket push layer.
The ioredis author announced its acquisition by Redis, detailing the library's evolution from a personal side project to the leading Node.js Redis client, its technical advantages over earlier libraries, and providing links to the new repository and author’s profile.
This article explains why the browser‑based ChatGPT conversation system prefers the lightweight EventSource API over WebSocket, detailing protocol differences, system characteristics, advantages, code implementations, performance considerations, and future extension possibilities.
ioredis, a high‑performance Node.js Redis client created by luin, uses a single‑socket pipeline for efficient command batching, has attracted enterprise users like Alibaba, and after years of growth was officially acquired by Redis, with its source now hosted on GitHub.
The ioredis project, a robust Node.js Redis client created by Luin to address shortcomings in existing libraries, has been acquired by Redis Ltd, with its repository moved under the official Redis organization, highlighting its nine‑year evolution from a personal side project to a leading open‑source database client.
A Node.js service migrated to containers began experiencing intermittent timeouts and high CPU usage due to the default enableServiceLinks parameter injecting thousands of environment variables, and the analysis shows how to identify, reproduce, and resolve the issue with Kubernetes configuration and code adjustments.
This article explains what headless browsers are, outlines their advantages and limitations, introduces Puppeteer as a Node.js library for controlling headless Chrome, and provides step‑by‑step code examples for taking screenshots, generating PDFs, and performing automated web interactions.
This article explains why direct file storage on application servers is not scalable, introduces Alibaba Cloud OSS as an object storage solution, walks through bucket creation, access key management, Node.js upload code, temporary credentials for browser uploads, CDN integration, and security considerations, providing a complete end‑to‑end upload workflow.
In 2024 the Prisma ORM outperforms TypeORM for Node.js projects thanks to more frequent updates, richer ecosystem, superior type safety, simpler integration, built‑in pagination and aggregation features, and a dramatically better developer experience illustrated with real code examples.
This article explains how front‑end developers can expand into full‑stack development by using Next.js with server‑side rendering, Prisma ORM, and SQLite to create a functional Todo List application, covering installation, database schema, server actions, and client‑side form handling.
This article explores high‑frequency frontend design patterns, demonstrates how mastering CSS Grid simplifies layouts, introduces Node.js Addons for native capabilities, reviews Meta’s StyleX CSS‑in‑JS library, recaps major 2023 frontend developments, and highlights the Cloud Academy frontend team.
The article walks through the author's investigation of why a Node.js CLI tool using Got fails to route HTTPS requests through Charles, compares direct proxy versus reverse‑proxy strategies, and provides a step‑by‑step implementation using https‑proxy‑agent and Got with certificate verification disabled, enabling successful request capture.
This guide shows how to use LangChain with OpenAI’s API, Puppeteer, and vector stores to automatically read local or web‑based API documentation, split and retrieve relevant text, and prompt an LLM to generate ready‑to‑use TypeScript front‑end code, highlighting setup, prompt design, and example outputs.
This article introduces TensorFlow.js, explains its origin and core features, and provides step‑by‑step instructions for using it in browsers, Node.js, and WeChat mini‑programs, including package installation, sample code, and practical tips for front‑end developers.
Tencent Docs transformed its gateway from a monolithic Node.js service into a four‑service micro‑architecture using a pnpm monorepo, deterministic lockfiles, and a custom Docker context script that eliminates symlinks, pins @grpc/grpc‑js, and produces smaller, reproducible images.
This tutorial walks through creating an intelligent documentation site that stores markdown pages in Embedbase, retrieves semantically similar chunks for user queries, builds contextual prompts, and streams answers from ChatGPT using a custom Nextra theme and Node.js backend.
This article outlines the background, terminology, network architecture, and step‑by‑step Node.js implementation of both MQTT broker and client for a sensor project, enabling two‑way communication between cloud platforms and edge devices without fixed IPs, complete with code snippets and visual results.
When Tubi upgraded from Node.js 14 to 20, server‑side requests began returning 404 errors, leading to a deep investigation that uncovered how the Request library and Sentry SDK altered HTTP module arguments, causing the built‑in URL detection to misclassify plain objects as URLs.
This article details the evolution of Ctrip's flight IVR system from a simple Chinese‑only version to a multilingual, fully visualized low‑code platform, describing its architecture, core components such as data definition, rule and script engines, version management, and the underlying Node.js and React technologies.
An in‑depth look at how switching a Java backend method from returning null to List.of() caused a serialization quirk that made Node’s HSF client receive a tagged object instead of an empty array, and the simple fix to avoid the pitfall.
This article introduces the ten most popular web development stacks—MERN, MEAN, LAMP, MEVN, Django, Ruby on Rails, MERN with Nest.js, Laravel, PERN, and ASP.NET Core—explains their components, provides code examples, and offers guidance on selecting the most suitable stack for a project.
This article walks through the evolution of thermal printer solutions—from basic driver printing to command‑based and image‑based approaches—detailing hardware principles, Electron architecture, USB communication, Rust‑based monitoring, and practical code snippets for reliable store‑level receipt printing.
This article compares Nuxt.js, Next.js, and Nest.js, explaining their roles as server‑side rendering frameworks for Vue and React and as a TypeScript‑based Node backend, and provides installation steps, core features, and code examples for each.
This guide explains how to export a Feishu knowledge base, configure required Feishu app permissions, set environment variables, and install the Feishu Pages npm package to generate a static website using a Markdown‑based static page generator, supporting CI/CD workflows.
This tutorial walks you through creating a Node backend using NestJS, configuring Sequelize with MySQL, setting up the project structure, writing DTOs, controllers, services, and modules, and implementing basic CRUD operations with code examples and deployment tips.
This article walks through setting up a Node.js backend using NestJS, integrating Sequelize with MySQL, configuring the database, defining entities, services, controllers, and demonstrating CRUD operations, along with optional features like GraphQL, Swagger, and deployment considerations.
Airbnb boosted page performance by implementing HTTP streaming with an early‑flush strategy that sends the head chunk first, allowing browsers to start loading CSS and JavaScript while the server fetches data, cutting First Contentful Paint by roughly 100 ms despite challenges like tag handling, buffering, and latency.
This article identifies nineteen common performance pitfalls in JavaScript and Node.js applications—ranging from improper variable scope and inefficient DOM manipulation to blocking I/O, unoptimized loops, and excessive dependencies—providing illustrative code examples and actionable solutions to improve speed and responsiveness.
This article walks through implementing React Server Components (RSC) from the ground up, covering basic file‑serving with PHP, migrating to Node.js with JSX, adding component, routing, async support, and client‑side state persistence, while contrasting RSC with traditional MVC approaches.
The article summarizes recent AI and development news, covering Elon Musk’s vision to integrate his companies into the xAI project, Google’s expansion of its Search Generative Experience to Japan and India, Tencent’s new large language model, and Node.js 20.6’s .env support and Oilpan garbage collector.
fnm is a fast, Rust‑built, cross‑platform Node.js version manager that simplifies installing, switching, and uninstalling Node versions, with step‑by‑step instructions for WSL and Windows installations, usage commands, alias setup, and common operations, all illustrated with code snippets and screenshots.
This article explains how to move frontend project build steps into Docker containers, addressing version‑conflict and npm‑cache issues by creating dedicated node‑pnpm images, configuring Jenkins to run builds inside isolated containers, and mapping workspace paths for seamless artifact handling.
This article describes how to engineer Java Velocity templates for local development within a Vue project by creating a Node‑based rendering engine and a custom Webpack loader, enabling hot‑reloading, mock data injection, and seamless integration of Velocity‑generated HTML into the Vue build pipeline.
This tutorial walks you through creating a 100‑line Node.js CLI scaffolding tool that supports global and local installation, interactive project and template selection, command‑line arguments, loading animations, overwrite prompts, dynamic template fetching via GitHub API, and finally publishing the package to npm for frontend engineers.
This article explains the concept of sandbox security mechanisms, explores their use cases in iPaaS API orchestration and micro‑frontend applications, compares eval, Function, with + proxy techniques, presents JavaScript, iframe and Node vm sandbox implementations, and details practical deployments within the Kraken framework and a centralized approval service.
This article explains why performance stress testing is essential, describes core metrics and the wrk tool, outlines a step‑by‑step testing workflow, analyzes bottlenecks, and presents concrete optimization measures that doubled the single‑machine QPS from 300 to 600 for a Nuxt‑based web service.
Researchers from Shanghai Jiao Tong University, Ant Security Light-Year Lab, and Zhejiang University present HODOR, a system that reduces the attack surface of Node.js applications by generating fine-grained system‑call allowlists using Seccomp, achieving an average 80% reduction in exploit surface with negligible runtime overhead.
