This tutorial walks developers through registering a WeChat Mini Program, setting up the Small Photo Album demo, configuring HTTPS domains and SSL, deploying a Node.js backend with Nginx, integrating Tencent Cloud COS for image storage, and testing the complete end‑to‑end photo‑album application.
This article introduces Electron Fiddle, explains how to install and run it, and demonstrates its key features such as template creation, code sharing via GitHub Gist, Monaco editor integration, and packaging apps for Windows, macOS, and Linux.
IMWebConf 2018 gathered nearly 500 on‑site attendees and over a thousand online viewers for a deep dive into front‑end standards, WebXR, QUIC, WePY, mpvue, fast‑app, cross‑platform frameworks like Weex and Taro, Node.js performance, and cutting‑edge data visualization techniques.
The article explains how Node.js now supports native V8 code‑coverage via the NODE_V8_COVERAGE environment variable, describes the limitations of traditional tools like Istanbul, outlines the benefits and challenges of using V8’s built‑in coverage, and provides practical steps and tools (c8, v8-to-istanbul) to generate readable coverage reports.
This article explains how JavaScript’s single‑threaded model achieves asynchronous behavior through macro‑tasks and micro‑tasks, compares the browser and Node.js event‑loop implementations, and demonstrates the timing differences between setTimeout, setImmediate, and process.nextTick with practical code examples.
This article explains the JavaScript Event Loop mechanism in depth, covering the call stack, heap memory, macro‑ and micro‑tasks, and their queues, and demonstrates the execution order through detailed examples and step‑by‑step visualizations of multiple event‑loop cycles.
This article explains step‑by‑step how to package an Electron application using electron‑builder and electron‑packager, analyzes the resulting file sizes and project structure, and dives into the core source code of electron‑builder to reveal how the packaging process creates the final executable and asar archives.
This article explains the two inter‑process communication methods in Electron, demonstrates why the remote module behaves like a reference rather than a copy, and reveals its internal implementation that mirrors Java RMI by wrapping objects and functions as remote proxies using synchronous IPC messages.
This article chronicles the ten‑year history of Google’s V8 JavaScript engine—from its secretive beginnings and open‑source launch to major performance improvements, benchmark trends, security challenges, and its expanding role in browsers, Node.js, and WebAssembly—highlighting key milestones and future directions.
The article explains the concept of the big front‑end, distinguishes its horizontal UI and vertical server dimensions, outlines why it reduces communication and development costs, and details practical technology selection, architecture design, and the measurable benefits of shared components and server‑side rendering.
This article provides a detailed introduction to NestJS, a progressive Node.js framework, covering its modular design, core building blocks such as controllers, providers, and modules, and demonstrating how to implement middleware, pipes, guards, interceptors, and exception filters with practical TypeScript code examples and project structure recommendations.
This tutorial explains how to install ImageMagick, use its core command‑line tools such as magick, convert, identify, mogrify and composite, format image resize commands, add watermarks, generate captchas, clone and append images, convert between GIF, PDF and other formats, and integrate the tool with Node.js scripts.
GraphQL, created by Facebook in 2012 and open‑sourced in 2015, offers a flexible, efficient alternative to REST by allowing clients to request exactly the data they need, reducing redundancy, cutting request counts, and simplifying API evolution, with practical Node server and Apollo client implementations illustrated.
This article explains Node.js architecture, showing how JavaScript code interacts with the operating system via C/C++ bindings, clarifies the single‑threaded model backed by a thread pool, and details the libuv‑based event loop that enables high‑concurrency non‑blocking I/O.
Analyzing GitHub star growth over the past year, this article ranks the most popular JavaScript projects of 2017—highlighting Vue.js’s continued dominance, React’s strong showing, emerging tools like Puppeteer, and trends across frameworks, build tools, testing suites, and the rise of static site generators.
A recap of Chengdu’s Node.js underground rail salon reveals how industry experts tackled enterprise‑grade challenges such as microservice architecture, security of third‑party dependencies, TypeScript adoption, RPC communication, and stream best practices, followed by an engaging round‑table discussion.
This step‑by‑step guide shows how to install Hexo, set up Node.js and Git, configure a GitHub repository, customize themes and site settings, and publish a static blog using Hexo commands.
Koa2 is a lightweight, async‑await‑based Node.js web framework that evolved from Express to eliminate callback hell, offering an elegant onion‑style middleware system, unified ctx object, and extensibility through routers, static serving, SSR, and database integrations, making it ideal for modern web services.
This article walks through the evolution of front‑end architecture—from tightly coupled JSP/Servlet setups, through semi‑separated Ajax‑driven pages, to fully separated front‑end/back‑end designs with Node.js—highlighting their advantages, drawbacks, and practical lessons for developers.
This article explains what data streams are, how they differ from arrays, the types of streams in Node.js, demonstrates Java Stream operations, and introduces popular streaming platforms like Apache Kafka and Amazon Kinesis, highlighting their core features and real‑time processing capabilities.
This article explains Node.js's internal architecture—including the standard library, bindings, V8 engine, libuv I/O library, code structure, event loop, and concurrency model—providing a comprehensive overview for developers who want to master backend development with Node.
From legacy JSP‑based MVC to semi‑separated Ajax‑driven pages and finally fully separated front‑end architectures using Node.js, this article examines each stage’s structure, advantages, and drawbacks, arguing that small‑to‑mid‑size companies must weigh resource constraints, performance, and maintenance before fully embracing front‑end separation.
This guide walks through installing Node.js, configuring npm with a Chinese mirror, and using create‑react‑app to quickly create and run a React project on macOS, including all necessary command‑line steps and code snippets.
The article walks through the evolution of front‑end development from traditional JSP/Servlet MVC through semi‑separated Ajax‑driven pages to fully separated front‑back architectures, highlighting each stage’s structure, advantages, drawbacks, and the practical considerations that make full separation risky for small‑to‑medium projects.
Deno, the open‑source, V8‑based TypeScript runtime launched by Node.js creator Ryan Dahl, aims to correct the design errors he perceives in Node.js by offering a simple module system, built‑in TypeScript parsing, runtime safety, and Go‑based glue, making it a promising, though not definitive, successor.
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.
This article provides a step‑by‑step tutorial on building a simple ThinkJS + Vue2 project with separate user and admin pages, covering directory layout, proxy setup, multi‑page webpack configuration, server routing, API creation, adding new pages, and production build deployment.
Exploring the limits and practical value of software design patterns, this article examines philosophical critiques of scientific induction, then delves into three core web architecture patterns—Middleware, MVC, and Dependency Injection—illustrating their implementation in Node.js and Java, and highlighting how they improve code modularity, communication, and scalability.
The article compares the MEAN (MongoDB, Express, Angular, Node.js) and LAMP stacks, highlighting MEAN's flexibility, simplicity, and performance advantages while acknowledging LAMP's reliability, and lists nine reasons to consider MEAN for new projects.
This newsletter highlights design principles for massive JavaScript applications, secure sandboxing techniques for Node.js, the latest Node.js 10 and V8 6.6 features, WebAssembly debugging, and the CRNWEB framework enabling a single codebase across React‑Native, web, and PWA platforms.
This article explains the JSON Web Token (JWT) format, its three-part structure, how to encode a payload and header with Base64, sign the token using HS256, and apply the resulting JWT to a friend‑request scenario that works without requiring the recipient to log in.
This article explains the consequences of high‑traffic spikes, presents practical database and code‑level strategies to keep data consistent, and outlines server‑side architectures—including load balancing, caching, and Redis queues—to sustain massive concurrent requests without crashing.
This article explains the core concepts of NestJS—including modules, controllers, providers, guards, interceptors, and validation pipes—provides practical code examples, and describes how the Nesk fork adapts Nest's architecture to a Koa‑based environment for seamless integration with existing internal frameworks.
This article explains Bitcoin’s innovative UTXO (unspent transaction output) model, why traditional account‑based systems are unsuitable, and provides a complete Node.js implementation covering transaction inputs, outputs, coinbase and regular transfers, complete with code examples and execution details.
This article introduces the fundamental concept of blockchain as a sequential, distributed ledger, then walks through a concise Node.js implementation of a minimal blockchain in roughly 200 lines of code, providing a practical foundation for readers interested in exploring blockchain development.
The article explains the background, core concepts, components, and workflow of the Hawaii framework—a Node.js based server‑side rendering solution that uses RDS files to simplify model‑layer data handling, supports front‑end/back‑end code reuse, and compares its approach with popular frameworks like React, Vue, and GraphQL.
This article explains key Node.js design patterns—including EventEmitter, streams, control‑flow libraries, coding style, testing, and logging—providing practical guidance and recommended tools for building robust, maintainable backend applications.
This article explains RabbitMQ's typical workflow, demonstrates basic message publishing and consumption with async/await in Node.js, introduces work queues with persistent messages and prefetch, and discusses key concepts such as default exchanges, queue durability, and acknowledgment modes.
This article explains HTTP/2 fundamentals, showcases its adoption by major Chinese sites, and provides a step‑by‑step Node.js tutorial—including installation, SSL setup, server code, and a demo that fires 100 parallel requests—to help developers experience the protocol’s benefits.
This article discusses the rapid evolution of Node.js versions, the practical difficulties of converting legacy code from yield to await, and why developers should consider upgrading to newer releases like Node 8 to leverage V8's performance improvements.
This article explains how Node.js uses the Cluster module to create a master‑worker multi‑process architecture, detailing worker creation, inter‑process communication via socketpair, handling of shared ports, and provides practical code examples for master, slave, and low‑level libuv interactions.
Node.js’s child_process core module enables creation of child processes to leverage multi‑core CPUs and inter‑process communication, while also allowing execution of external files or system commands; this article explores the differences and inner workings of its exec and spawn methods.
A programmer shares how he turned a lost stroller incident into a successful Twitter‑bot project, detailing the creation of a Cloud9 environment, Node.js bot, API configuration, and the surprising compensation he received, inspiring developers to apply coding skills to real‑world problems.
This article explains what a Webpack loader is, how it works, how to configure single or multiple loaders in webpack.config.js, best‑practice guidelines, and provides a complete example of an html‑minify loader with both synchronous and asynchronous implementations.
This tutorial walks you through installing Node.js, configuring npm to avoid permission issues, using npm in both global and local modes, managing package versions with package.json, searching for packages, cleaning the cache, and leveraging version managers, providing a complete guide for modern JavaScript development.
This article shares practical micro‑optimizations for the DataStax Node.js driver of Apache Cassandra, covering I/O aggregation, timer management, V8 CPU profiling, system‑call reduction, and careful use of ECMAScript features to double application throughput.
This guide walks you through creating a lightweight Node.js web crawler using the request and cheerio modules, covering preparation, installation, core code, and testing steps, so you can fetch page HTML, parse data, and store results with just a few dozen lines of code.
This article explains Pandora.js's Service mechanism—a high-level process orchestration feature for Alibaba's Node.js applications—detailing its role in middleware management, standardized service lifecycles, isolated tasks, and an Etcd‑based service discovery example.
This comprehensive guide explores JavaScript module mechanisms—including CommonJS, Node.js core and file modules, AMD, CMD, UMD, and ES6 import/export—detailing their advantages, loading strategies, code examples, circular dependencies, and best practices for modern front‑end and back‑end development.
This article chronicles Bilibili’s front‑end evolution in 2017, detailing the shift from a backend‑centric MVC model to front‑back separation, the adoption of Node middle‑layers, Vue and React SSR, Docker deployment, caching strategies, and subsequent refactoring to improve performance and scalability.
This tutorial walks you through creating a Drone CI plugin in Node.js that sends Telegram notifications, covering environment variable handling, plugin code, Dockerfile optimization, image building, testing, secret management, and common pitfalls for seamless CI integration.
Pandora.js, the Alibaba Midway team's first open-source project, consolidates years of production-grade Node.js operations by offering three core capabilities—manageable application and process control, comprehensive metrics, and Open-Tracing-based request tracing—exposed via RESTful APIs and logs for easy integration.
This article chronicles Bilibili’s 2017 front‑end transformation, detailing the shift from a backend‑centric MVC workflow to a decoupled architecture with Node middleware, Vue SSR, Docker deployment, configuration management, caching strategies, and performance testing, illustrating lessons learned and future directions.
This article chronicles Bilibili’s transition from a traditional MVC workflow to a modern front‑end/back‑end separation, detailing the adoption of Node middle‑layers, Vue SSR, architecture refactoring, deployment strategies, performance testing, and lessons learned throughout 2017.
This article provides a comprehensive guide to WebSocket, covering its purpose, connection establishment, handshake process, data frame structure, masking algorithm, security considerations, and includes practical Node.js server and client code examples to illustrate real‑time bidirectional communication.
This tutorial walks you through setting up a Node.js environment, installing Koa, and progressively building a web application by covering basic HTTP services, context handling, response types, routing, middleware, error handling, cookies, form processing, and file uploads with clear code examples.
The article introduces the Hawaii framework—a Node.js based server‑side rendering solution used by WeChat HandQ—detailing its background, core RDS request description files, component architecture, development workflow, comparison with React/Vue and GraphQL, and its deployment and monitoring strategies.
This article walks through the process of scraping Meican's ordering data via its APIs, analyzing restaurant popularity, and creating a Node.js‑based DingTalk robot that automatically notifies users when it’s time to place their lunch orders, complete with code snippets and visual insights.
This article explains how Pandora.js solves inter‑process communication challenges by introducing IPC‑Hub, showing simple domain‑socket examples, a concise object‑proxy model, and a practical use‑case that offloads heavy webpage‑snapshot tasks to a background process using Puppeteer.
This article explains how Electron lets web developers create cross‑platform desktop applications with familiar JavaScript and Node.js, compares it to NW.js, outlines learning stages, offers documentation tips, and provides guidance on selecting and extending useful demo projects.
This article explains Pandora.js's Service mechanism—a high‑level process orchestration feature for Node.js applications—covering its problem scope, core principles, capabilities, implementation of an RPC provider with etcd registration, and a simple consumer example, while demonstrating start/stop lifecycle management.
This article explains the limitations of traditional Node.js master/worker process models, introduces Pandora.js's procfile.js definition for flexible process orchestration, and demonstrates how to configure, scale, and monitor processes using concise code examples.
This article explains how to combine Node.js's experimental Async Hooks and Performance Timing APIs to create a simple tracing and performance monitoring tool, eliminating manual timing and offering a foundation that can be extended into a custom solution, while also noting an open‑source Pandora.js utility.
This article explains how to leverage JavaScript's built‑in Error object and custom error classes to separate normal output from exceptions, improve readability, enable unified handling, and automatically report issues, offering practical code examples for both front‑end and Node.js back‑end development.
This article introduces how to leverage the opencv4nodejs Node.js module—binding OpenCV’s full API—to develop a face detection and recognition application, highlighting the CPU‑intensive nature of computer‑vision tasks, the limitations of JavaScript, and the availability of synchronous and asynchronous examples.
This article explains how to add lightweight middleware in a Node.js server that records the start time on the request object, listens for the response finish event, calculates the elapsed time with process.hrtime, and uses curl to verify the timing for different endpoints.
A recent NodeSource and Sqreen survey shows that most developers underestimate Node.js security risks, with low confidence in code safety, third‑party dependencies, and vulnerability checks, highlighting the urgent need for better practices as the npm ecosystem expands.
This article presents a comprehensive collection of 52 Node.js best‑practice recommendations covering project structure, error handling, coding style, testing, and production, each detailed with concise summaries, risk warnings, and in‑depth explanations, guiding developers toward more reliable and maintainable backend applications.
Promisify converts Node‑style callback functions into Promise‑based ones by ensuring the callback is the last argument and its first parameter is an error, enabling cleaner asynchronous code with examples, implementation details, and optimizations for JavaScript developers.
Fastify, a lightweight Node.js server framework released recently, has quickly gained traction with over 4,800 stars, 30 contributors, and performance benchmarks showing roughly six times Hapi’s speed and 1.5 times Express’s, thanks to fast-json-stringify and find‑my‑way routing, plus a growing plugin ecosystem.
This article explains how to create a JavaScript function that sends a POST request to a license‑generation API, retrieve the license data, and use it in subsequent automated test cases, including handling asynchronous callbacks and example usage.
This tutorial explains the concept of cross‑origin requests, demonstrates practical AJAX calls between two Node.js servers on different ports, and walks through three major solutions—standard AJAX, JSONP, and CORS—while also covering alternative techniques like window.name and postMessage.
This article explains how the Qudian team built a lightweight Koa‑based front‑back end separation framework called koa‑grace, covering its architecture, routing, data proxying, deployment strategies, performance benchmarks, and open‑source resources for developers seeking efficient web application development.
This guide explains how to choose between push and pull monitoring models, introduces Prometheus architecture and metric syntax, shows Node.js client integration with code examples, and covers Alertmanager features and Grafana visualization for effective application monitoring.
Node.js 8.5 brings three exciting features—native ECMAScript module support via the import syntax (enabled with --experimental-modules and .mjs files), a W3C‑compatible Performance Timeline API for high‑precision metrics, and a built‑in fs.copyFile API implemented in C++ for easy file duplication.
This guide introduces Whistle, a Node‑powered cross‑platform web debugging proxy, explains installation, core features, common usage patterns, and advanced mock data techniques, helping developers replace tools like Fiddler or Charles with a more flexible solution.
This article introduces the fundamentals of character encoding and decoding, explains the difference between character sets and encodings, and demonstrates practical Node.js examples using the iconv‑lite library to correctly encode and decode Chinese text, helping developers prevent common garbled‑text issues.
This article introduces Electron and the Nightmare framework, explains how to install and use Nightmare for web automation and crawling, and provides a complete example of scraping Zhihu topic data with JavaScript, Node.js, and Cheerio, including code snippets and JSON output.
Since Node.js v8.1.0, the experimental async_hooks module lets developers automatically monitor asynchronous operations, offering a cleaner alternative to legacy hacks like domain or async-listener for tracing and debugging complex async flows.
Explore the inner workings of Node.js streams—including readable, writable, duplex, transform, and pipe—through detailed explanations, code demos, and visual diagrams, revealing how backpressure, flow modes, and internal mechanisms shape data handling in backend development.
Contributing to the massive open‑source Node.js project is easier than it seems; you can get involved by working on the core library, joining one of its specialized working groups, or participating in the broader ecosystem through evangelism and community events.
This guide explains how gzip and deflate compression work in web browsers and demonstrates straightforward Node.js examples for compressing and decompressing files, streaming responses, and handling HTTP requests with proper Accept‑Encoding checks, helping developers improve bandwidth efficiency and page load speed.
This article provides a comprehensive guide to Node.js's path module, covering how to retrieve directories, filenames, and extensions, combine and resolve paths, normalize and parse paths, format and decompose file paths, compute relative paths, and handle platform-specific differences.
This article reviews the compatibility of various Node.js versions with ES6 features, explains key ES6 constructs such as let, const, template literals, default parameters, destructuring, and classes, and presents performance benchmarks comparing these features to their ES5 equivalents, concluding with practical recommendations for developers.
Learn how to create a C/C++ extension for Node.js using the stable N-API ABI, covering environment setup with node-gyp, writing the module code for a simple multiply-by-two function, building the add-on, and running it across platforms with minimal compilation hassle.
Bigview is a Node.js framework that implements the Bigpipe technique to provide a highly modular, pagelet‑driven frontend architecture with multiple rendering modes, fault‑tolerant independent modules, and Lerna‑managed monorepo support, aiming to accelerate first‑screen load and simplify development and maintenance.
This article chronicles JavaScript’s journey from its humble origins in Netscape’s browser to becoming the dominant language for client‑side interactivity, asynchronous communication, JSON data exchange, and even server‑side development with Node.js, highlighting key milestones, technical concepts, and code examples.
A recent global survey by the Node.js Foundation, collecting 1,405 responses between November 2016 and January 2017, shows that developers prioritize front‑end, full‑stack, and backend API use of Node.js, favor cloud platforms like AWS and Alibaba Cloud, and anticipate growing usage in China, while noting Go’s rising popularity.
An in‑depth guide shows front‑end engineers how to create Kinect‑based motion games that run in Chrome using HTML5, detailing data collection, server‑client communication with Node‑Kinect2, system requirements, setup steps, skeleton data handling, gesture recognition, and practical development tips from a TGC2016 demo.
Discover 19 practical Node.js production best practices—from monitoring and logging to security, deployment automation, and resource optimization—that help ensure reliable, scalable, and maintainable applications in real-world environments. These guidelines also cover dependency locking, CPU utilization, APM integration, and secure configuration to streamline development and operations.
This article explains how Node.js achieves its single‑threaded, non‑blocking behavior through callbacks, an event‑driven model, and an event‑loop that leverages libuv’s thread pool, and it illustrates these concepts with detailed code examples and diagrams.
This article explains how MySQL stores dates in UTC, why Sequelize returns UTC values despite a configured timezone, and demonstrates using custom getter methods (with moment) to automatically format DATE fields, including an advanced approach to apply the getter across multiple models.
This article introduces the Chrome DevTools Protocol API, provides practical coding tips for using the chrome-remote-interface library, and demonstrates complete Node.js examples for gathering performance metrics, automating Baidu searches, and extracting first‑page results with headless Chrome.
From his first webcam photo in 1997 to leading full‑stack projects, Daniel Khan shares a candid, first‑person chronicle of 17 years in web development, highlighting the evolution of Node, the pitfalls of over‑engineering, essential coding principles, and practical advice for staying adaptable in the ever‑changing JavaScript ecosystem.
This article explains how to install Chrome, configure command‑line aliases, launch Headless Chrome with various flags, and interact with it both through direct CLI commands and programmatic Node.js libraries such as chrome‑launcher and chrome‑remote‑interface.
This article walks through classic Node.js callback examples, demonstrates how event emitters can replace tangled callback nesting, and then shows how promises and async/await provide cleaner, more maintainable asynchronous code, encouraging developers to upgrade their Node version.
This article explains the rapid evolution of the JavaScript ecosystem, covering ES2015+ language features, Node.js, module systems, package management, build tools, and deployment strategies, helping newcomers and seasoned developers understand the key tools and concepts behind modern web applications.
This article explains how Node.js handles HTTP requests using an I/O multiplexing model, walks through a simple hello‑world server, examines connection and request events, discusses keep‑alive, Expect headers, proxying, and presents performance measurements comparing Node.js to a pure C implementation.
This article explains MD5's fast but insecure hashing, demonstrates its use for file verification and password storage in Node.js, and shows how adding random salts dramatically improves password protection while also introducing MD5 collision concepts.
The article explains how to perform a cross‑collection loop query with Mongoose, illustrates why using a synchronous while loop blocks Node's event loop, and shows the correct approach of using Promise.all with async handling to merge results efficiently.
