This guide walks you through preparing the environment, installing OpenClaw, configuring its onboarding, creating a Feishu custom app, setting up event subscriptions and permissions, and finally pairing the AI agent so it can respond to Feishu messages.
This guide walks through setting up the OpenClaw AI‑agent runtime on a local machine, configuring Node.js, handling common pitfalls, and finally integrating the assistant with Feishu so it can read files, manage messages, and automate daily tasks.
This article shows how to create an Easysearch intelligent assistant that lets users manage indexes, write data, search and aggregate documents using Chinese natural language, by combining the DeepSeek large‑language model with OpenAI‑compatible function calling (Tool Use) and a lightweight Node.js executor.
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.
Node.js now supports Single Executable Applications (SEA) with ESM entry points, allowing developers to bundle code and the runtime into a single binary, and benchmarks by Evan You demonstrate that the resulting executable launches faster than Bun's compiled mode.
The article explains why OpenClaw users repeatedly hit Feishu’s free‑plan API call limit, analyzes the root cause in the probe logic, and provides a step‑by‑step self‑repair guide that adds a 5‑minute cache, adjusts health‑check intervals, and replaces the original probe file to cut API calls by over 90%.
This guide walks you through the overview, system requirements, step‑by‑step installation, custom model configuration, verification methods, core file locations, environment variables, hot‑reload options, common commands, and troubleshooting for OpenClaw, a self‑hosted AI assistant gateway.
The article examines NestJS v12’s upcoming major changes—including a full migration to ESM, replacing Jest with Vitest, and native Zod schema support—explains the technical reasons behind them, outlines migration timelines, and evaluates how both new and existing projects can adopt the updates with minimal disruption.
A detailed benchmark of a reverse‑shell project shows that Go outperforms Node.js in cold‑start latency, memory consumption, and binary size, while Node.js narrows the gap on warm‑path latency, highlighting the trade‑offs developers must weigh when deciding to rewrite.
This article explains what backpressure is, why Node.js services silently run out of memory, and provides practical streaming and bounded‑concurrency patterns with code examples to keep memory usage stable under load.
This guide enumerates ten frequent traps encountered when streaming JSON in Node.js—such as assuming one chunk per object, UTF‑8 split issues, missing newline delimiters, back‑pressure overload, and handling of large numbers—and presents reliable patterns like using NDJSON framing, StringDecoder, pipeline, and proper error handling to avoid data loss and memory spikes.
The article analyzes a senior developer's decision to rewrite a multi‑year Rust web application in Node.js, detailing five concrete factors—template handling, i18n support, dynamic data processing, compile‑time overhead, and ecosystem maturity—that slowed delivery speed despite Rust's safety advantages.
This article explains what high‑throughput means for an HTTP server, why Node.js’s event‑driven, non‑blocking architecture makes it ideal, and provides step‑by‑step code examples—including a basic server, blocking vs. async I/O, clustering, keep‑alive, JSON optimization, and streaming—to help developers design scalable, low‑latency services.
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.
This tutorial walks through the OSI model, explains TCP three‑way handshake and four‑way termination, compares TCP and UDP, addresses common TCP tuning questions, describes long versus short socket connections with heartbeats, and shows how to design a custom protocol and implement a reusable Socket connection pool in Node.js.
This tutorial walks through installing Docsify, initializing a project, configuring index.html, coverpage, navbar and sidebar files, and serving the documentation site locally, providing step‑by‑step commands, code snippets, and screenshots for a complete Docsify setup.
The article examines almostnode, a 250KB open‑source library that enables a near‑complete Node.js environment to run entirely in the browser, compares it with StackBlitz WebContainers, and discusses how AI tools like Claude helped build its lightweight runtime.
This free tutorial walks you through installing Clawbot on Windows, macOS or Linux, adding the Feishu plugin, configuring Feishu app credentials, and using Clawbot to generate documents, while highlighting security risks and providing a GitHub reference.
This step‑by‑step guide shows how to set up the open‑source OpenClaw AI assistant on personal computers, cloud servers, NAS or Raspberry Pi, covering hardware requirements, system dependencies, installation scripts, platform integration, advanced skill configuration, and ongoing maintenance.
This guide provides a step‑by‑step prompt that detects the operating system, verifies Node.js, handles WSL on Windows, installs the Claude Code CLI accordingly, and confirms the installation, enabling you to run the tool instantly from any IDE.
Deploying OpenClaw on an internal Ubuntu 22.04 server exposed a prompt‑injection flaw that let colleagues trigger shutdown and data‑deletion commands, prompting a step‑by‑step hardening process that includes removing default bindings, editing gateway settings, and defining strict security prompt templates.
This guide walks you through installing n8n via npx or Docker, registering an account, understanding core concepts like workflows, nodes, and connections, and building a complete AI‑driven automation that fetches Weibo hot topics, processes them with a large language model, and emails the results.
This step‑by‑step guide shows how to prepare an Ubuntu (or Mac) VM, install an agent tool, set up Ollama, install OpenClaw via npm, configure the daemon, launch the GLM‑4.7:cloud model, and connect OpenClaw to Telegram for AI‑agent interactions.
This article walks through installing the open‑source OpenClaw AI assistant on a MacBook (or cloud server), configuring it with the MiniMax model and Feishu, enabling 24‑hour remote control, local memory, data sovereignty, and thousands of ready‑made skills, while highlighting setup commands, security considerations, and cost factors.
This article explains why Claude Code Router is needed, outlines its three core advantages, and provides a step‑by‑step guide—including environment preparation, installation, configuration, and usage—so developers can route requests to multiple LLM providers without an Anthropic account.
Clawdbot, an open‑source AI Agent gateway with 54.6k GitHub stars, offers persistent three‑month memory, 50+ built‑in tools, and multi‑model channel management; built on TypeScript/Node.js, it delivers strong automation but incurs notable API costs and a learning curve, making it ideal for long‑term AI‑driven projects yet less suited for casual users.
This article introduces a TypeScript MCP‑Server framework that simultaneously supports stdio, streamableHttp, and SSE protocols, explains its design motivations, outlines its modular architecture, provides setup and deployment instructions, and showcases key source code and usage examples.
Bun introduces the --cpu-prof-md flag that outputs CPU profiling data as structured Markdown for large language models, earning praise from Vue creator Evan You and inspiring Node.js core contributor Matteo Collina to release a pprof‑to‑md converter, highlighting a shift toward AI‑oriented CLI tools.
Electron 40.0.0, released on January 13, 2026, brings a comprehensive core stack upgrade—including Chromium 144, Node.js 24.11.1, and V8 14.4—adds new features like WebSocket authentication and HDR rendering, outlines breaking API changes, and provides a step‑by‑step migration guide for developers.
The recent Node.js security release patches eight vulnerabilities, most notably a stack‑overflow bug triggered by deep recursive promises when async_hooks is enabled, which allows a crafted JSON payload to terminate the process, and the fix modifies TryCatchScope to re‑throw stack‑overflow errors instead of exiting.
Ryan Dahl, the creator of Node.js and Deno, declares that the era of humans writing code has ended, prompting a deep dive into AI‑driven programming tools, their impact on developer roles, community reactions, and the shifting skills needed for the future of software engineering.
This guide walks through installing Claude Code, an Anthropic AI programming assistant, covering prerequisites, npm installation, authentication, optional proxy setup for Unix and Windows, MCP server configuration, common commands, and troubleshooting tips.
This article compares Node.js and Python for backend development in 2026, examining their architectures, performance benchmarks, ecosystem strengths, and suitable use-cases, and provides a decision framework to help developers choose the most appropriate technology based on project requirements, team skills, and scalability needs.
This guide explains why Playwright is essential for modern front‑end testing, walks through installation, project setup, core APIs for GET/POST requests, and provides a runnable demo to help developers quickly adopt automated testing in their web projects.
This guide explains why Playwright has become essential for front‑end automation testing, walks through installing Node.js and Playwright, shows how to configure a project, provides runnable demo code, and illustrates common API calls such as GET and POST requests with detailed examples.
Node.js now marks require(esm) as stable in LTS releases, allowing CommonJS files to require synchronous ESM modules without extra flags, simplifying package.json configuration, eliminating the need for dual packages, and resolving the long‑standing CJS‑ESM split for the vast majority of projects.
This article provides a detailed comparison of Jest and Mocha, covering their core features, performance, flexibility, ecosystem support, and ideal use‑cases, helping developers choose the most suitable JavaScript testing framework for front‑end or back‑end projects.
This article explains what MessagePack is, compares its size and speed to JSON in Node.js with real benchmarks, shows how to use the msgpackr library, and outlines the scenarios where its smaller binary payloads and native binary support outweigh its slower CPU serialization.
The article explains why teams mistakenly use databases merely as storage, shows a real‑world Node.js dashboard that suffered severe latency, demonstrates how moving aggregation and filtering into SQL queries eliminated N+1 and filtering issues, and presents dramatic performance gains and best‑practice guidelines.
The 2025 JavaScript ecosystem saw the language turn 30, Bun acquired by Anthropic, Deno embroiled in trademark and funding battles, TypeScript topping GitHub, React Compiler ending manual optimization, Vercel buying NuxtLabs, and a wave of security incidents reshaping front‑end development.
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 guide introduces OpenSpec, a specification‑driven workflow for AI coding assistants, and walks through its core concepts, installation, directory layout, markdown syntax, and practical usage in Cursor and Antigravity IDEs, helping developers keep ideas clear before writing code.
This article examines PHP 8.5’s runtime and JIT improvements, compares its async and API throughput with Node.js, and explains how architecture choices like Swoole, RoadRunner, or Octane influence real‑world performance more than the version number itself.
This article explains the origins of AI Agent Skills, walks through the standard tool‑use loop, provides step‑by‑step code for defining and invoking Skills with the OpenAI API, compares Skills with the emerging Model Context Protocol (MCP), and offers practical guidance for developers and architects building AI‑enabled systems.
This article walks through the end‑to‑end automation of a company’s daily dashboard report, covering reverse‑engineered login, API data extraction, image generation with canvas, OSS upload, and scheduled DingTalk webhook delivery, all implemented in Node.js.
This article benchmarks memory consumption of concurrent programs across Rust, Go, Java, C#, Node.js, Python, Elixir and others, revealing surprising differences in how threads, async runtimes, and virtual threads scale from a single task up to one million concurrent tasks.
This step‑by‑step guide shows how to install Cursor and Playwright‑MCP, configure the MCP server (including Windows path fixes), generate a test plan from CSV files, run automated tests with Playwright, and produce a detailed test report with screenshots and issue analysis.
This tutorial walks you through installing Node.js, Git, and Claude Code, then replacing Claude Code's default model with a domestic Chinese large model via the open‑source cc‑switch tool, and finally demonstrates the setup with two sample projects.
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 article examines how PHP's recent versions, especially the upcoming PHP 8.5, compare to Node.js across CPU‑intensive, I/O‑intensive, and web‑framework workloads, highlighting benchmark results, JIT compiler impacts, ecosystem tools, and practical guidance for choosing the right technology.
This guide walks through setting up a PeerJS‑based P2P voice call system, covering browser compatibility, Node environment preparation, installing and running the peerjs‑server (via npm or Docker), initializing the Peer object, handling connections, making and receiving calls, and customizing Peer IDs, with full code snippets and screenshots.
This guide details a step‑by‑step process for migrating a high‑traffic MongoDB app to a dedicated instance, covering full backup, real‑time incremental sync via Change Streams, compensating for missed changes, handling operation ordering, and ensuring zero downtime throughout.
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 guide walks beginners through installing Claude Code using the Zero‑Config Claude‑Code Flow (ZCF) tool, requiring only a single command, Node.js, and an iFlow API key, and shows how to configure free domestic models, workflows, and optional extensions within five minutes.
This guide walks you through installing Node.js, using the zero‑configuration ZCF tool to set up Claude Code and its router, configuring OpenRouter API keys and default models, handling common errors, and quickly launching Claude Code in the terminal or VSCode.
This article walks through constructing a LangGraph graph that encapsulates three agents—task planning, web search, and report generation—into a DeepResearch application, then shows how to package and deploy the backend and frontend so users can interact with the system via a web UI.
This tutorial walks through the complete process of setting up the wvp‑GB28181 Pro platform—including environment preparation, front‑end compilation, back‑end packaging, configuration tweaks, and test execution—to enable GB28181‑compliant video streaming using SIP and ZLMediaKit.
Learn how to ensure your Node.js applications stay alive by configuring automatic restarts for both development and production environments, using tools like Nodemon, PM2, Docker restart policies, systemd, and advanced PM2 features such as clustering, log management, and crash handling.
This guide evaluates Codex against Claude Code, walks through installing the Codex CLI on Windows, macOS and Linux, explains API‑Key and ChatGPT Plus authentication, details advanced MCP server setups, and provides a full set of configuration files and commands for turning Codex into a true AI programming partner.
Despite the hype around Node.js, PHP continues to power the majority of web servers thanks to its ultra‑simple deployment, deep LAMP integration, massive CMS ecosystem, mature frameworks, performance gains in PHP 8, and a robust community that together form a lasting moat.
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.
This tutorial walks front‑end engineers through the fundamentals of Node.js, covering its runtime concept, installation, basic file operations, built‑in APIs, creating HTTP servers, using the Koa framework, simple database interactions, and calling third‑party services, all with clear code examples.
This guide walks you through setting up a Douyin live‑room ranking service using PHP 8.1+, Node.js 16+, Composer, and Workerman, covering required tools, installation steps, parameter configuration for room_id or live_id with cookies, and how to launch and preview the real‑time WebSocket server.
This article explains why Server‑Sent Events (SSE) can replace heavyweight WebSocket connections for one‑way data push scenarios such as dashboards, news feeds, and notification systems, highlighting SSE's simplicity, lower overhead, and native browser support.
An in‑depth analysis of the 2026 web development landscape compares PHP, Python, and Node.js, examining market trends, technical strengths, performance characteristics, ideal use cases, community support, and future outlooks to help developers choose the right backend language for their projects.
This article evaluates PHP, Python, and Node.js across performance, ecosystem, trend adaptability, and community support, forecasting how each technology may evolve by 2025 and which scenarios could make one the preferred choice for developers.
This roundup highlights recent releases and announcements across the web development ecosystem, including jQuery 4.0.0 RC1, Node.js v24.7.0 with enhanced cryptography, Rspack 1.5 performance upgrades, Next.js 15.5 Turbopack beta, plus new articles on ES2025 syntax sugar, Claude Code, Node.js Type Stripping and an AI‑driven quality‑report automation.
This article introduces the rapidly popular Gemini CLI, compares it with Claude Code, explains its core features, demonstrates coding, multimodal, and MCP use cases, and details the author’s Easy LLM CLI fork that enables custom model integration, flexible configuration, and direct code embedding for developers.
Deep‑copying request payloads in Node.js prevents unintended mutations across middleware, protects shared state in async operations, improves debugging and security, and aligns with functional programming principles, making your APIs more robust, maintainable, and safe for handling user data and transactions.
This article explains how Node.js Worker Threads enable true parallelism for CPU‑intensive tasks, prevent event‑loop blocking, improve scalability with microservices, leverage shared memory for speed, and lead to cleaner, more maintainable code, complete with real‑world examples and starter code.
Effective API logging is essential for debugging and compliance, but naive synchronous logging can block the event loop, exhaust disk I/O, and degrade performance; this guide explains why, and provides ten practical steps—including asynchronous loggers, buffering, offloading, sensitive data masking, and monitoring—to keep your server fast and reliable.
Learn how to offload CPU‑intensive operations from Node.js to WebAssembly using JavaScript‑friendly tools like AssemblyScript, avoiding Rust or C++, and follow step‑by‑step instructions, best practices, and pitfalls to improve performance, scalability, and memory usage in backend services.
This article traces the history and reasons behind JavaScript’s module formats—from early AMD and UMD to Node’s CommonJS and the modern ECMAScript modules—explains migration challenges, tooling, testing nuances, and best practices for managing dual builds in contemporary projects.
This article walks through designing and implementing an AI code review tool using Node.js, GitLab webhooks, and large language models, covering prompt engineering, diff augmentation, token management, response parsing, and automated comment posting to streamline the review process.
The article introduces shadcn‑ui‑mcp‑server, a Node.js tool that implements a Model Context Protocol to let AI assistants read shadcn/ui component documentation, source code, and demos, enabling richer code suggestions and full‑page layout generation within editors like VS Code, Continue, and Cursor.
This article introduces the AI‑powered mind‑map‑MCP tool, explains its features, installation via npm or npx, usage through Coze API and Trae configuration, showcases generated mind‑maps, and outlines future enhancements for better NLP understanding and broader integrations.
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.
By imposing a strict 1 GB memory cap on identical workloads across Go, Rust, Node.js, Python (Flask/Gunicorn), and Java Spring Boot, this study reveals how each language’s runtime handles memory pressure, detailing survival times, performance quirks, and ultimate failure modes.
This article explains why sharing a single .d.ts file between ESM and CJS can cause FalseEsm and FalseCjs type errors, shows how recent Node and TypeScript updates mitigate the issue, and provides practical solutions such as generating separate .d.cts files or using TS 5.8 with "module": "nodenext".
This article explains how to streamline the repetitive manual publishing of WeChat, Alipay, and Douyin mini‑programs by using Node.js tools, a unified configuration center, Jenkins pipelines, and DingTalk notifications to achieve one‑click, synchronized releases in under ten minutes.
This guide shows beginners how to explore contract details on the Sepolia testnet using Etherscan's read‑only interface and then how to programmatically retrieve the same data with a Node.js script that leverages Web3.js, covering setup, code examples, and next‑step possibilities.
Discover why a sluggish API hurts user retention, SEO, and costs, and learn eight practical Node.js backend optimization techniques—including mastering the event loop, avoiding blocking code, leveraging async/await, offloading heavy tasks, efficient JSON handling, caching strategies, database tuning, clustering, and continuous monitoring—to boost performance and scalability.
This article introduces the Hono web framework, highlighting its ultra‑fast RegExpRouter, tiny bundle size, multi‑runtime support, rich middleware ecosystem, and excellent TypeScript experience, then walks through common use cases, routing, request handling, responses, JSX rendering, and validation with code examples.
This guide explains how to overcome large‑file upload limits by splitting files into chunks with Blob.slice, uploading them concurrently from a Vue front‑end, and merging the pieces on a Node.js back‑end using streams, while providing progress tracking and handling Nginx size restrictions.
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 explains how to create a web‑based Android terminal by combining ADB, a persistent socket connection, node‑pty, and xterm.js, enabling remote device management, command execution, and file operations for IoT and development scenarios.
This article explains how prop drilling in Next.js applications can be avoided by using Node.js's AsyncLocalStorage to store per‑request context such as requestId, tenantId, and userId, providing code examples, implementation steps, and practical usage tips for clean, maintainable backend logic.
Vite 7.0 introduces major performance upgrades, a Rust‑based bundler called Rolldown, updated Node.js and browser targets, experimental Environment API hooks, and a new DevTools suite, marking a shift from a simple build tool to a full‑stack frontend platform.
This guide explains how to use Proxy Auto‑Config (PAC) files to intelligently route traffic through different proxy tools like ClashX, Whistle, and SwitchyOmega, covering the underlying JavaScript function, configuration examples, and a Node.js server for hot‑reloading the PAC file.
From Brendan Eich’s ten‑day creation of Mocha in 1995 to the rise of WebAssembly at the edge in 2022, this article chronicles ten pivotal JavaScript milestones—including ECMAScript, Ajax, Node.js, npm, React, TypeScript, and more—that transformed the language into the web’s dominant programming force.
Gemini CLI, a Google‑released command‑line AI workflow tool, brings Gemini models into the terminal, enabling natural‑language coding, debugging, content creation, research and task management, with features like a 1 million‑token context window, generous free quota, and full open‑source availability under Apache 2.0.
By systematically applying connection pooling, batch processing, WAL tuning, table partitioning, query refactoring, and OS-level tweaks, we transformed a PostgreSQL‑Node.js stack to sustain 50,000 transactions per second with sub‑100 ms latency, while maintaining data consistency on modest hardware.
This talk explains the Model Context Protocol (MCP), how it simplifies agent tool integration by replacing numerous custom interfaces with a single standardized protocol, and details its adoption, architecture, security, and future directions within Ant Group's ecosystem.
An in‑depth 2025 benchmark compares PHP 8.4 and Node.js 22 on modern hardware, revealing PHP’s improved JIT and memory handling narrowing the gap, while Node.js still excels in I/O and concurrency, and offering practical guidance on choosing the right runtime for various web workloads.
This article details the end‑to‑end process of researching, adapting third‑party and custom plugins, recompiling, and testing the Zhiyinlou desktop client as it migrated from Electron 15 to the latest stable 29, highlighting challenges, solutions, and performance gains.
H3 is a lightweight, high‑performance HTTP server framework built on Web standards that supports multiple JavaScript runtimes, offers a concise API, composable middleware and plugin systems, and is recommended by Evan You for rapid prototyping, edge computing, and small web services.
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.
Overusing generic try/catch blocks in Node.js can silently swallow errors, degrade performance by up to 26%, and create debugging nightmares, while strategic error handling—targeted catches, proper resource cleanup, and error boundaries—offers faster, more maintainable code and prevents memory leaks.
This comprehensive guide explains observability concepts, introduces OpenTelemetry’s three signals—traces, metrics, and logs—and walks through setting up automatic and manual instrumentation for Node.js applications, configuring the OpenTelemetry Collector, deploying with Docker Compose, and visualizing data in Zipkin or Jaeger.
