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 explores the Bigpipe technique for accelerating first‑screen rendering by leveraging HTTP 1.1 chunked transfer, comparing implementations in PHP, Java, Node.js (including Express and Koa), and demonstrating parallel module flushing with async patterns such as callbacks, async parallel, co, and async/await.
This article provides a comprehensive overview of Node.js’s worldwide adoption, its technical strengths and weaknesses, architectural balancing strategies, the author’s team’s practical stack and tooling choices, and guidance on becoming a full‑stack developer using Node.js technologies.
This guide explains how to set up BrowserSync with Gulp and Node.js to automatically reload the browser whenever local web project files change, improving development efficiency by eliminating manual refreshes.
This guide explains how to install Node.js, download the TFS Build vNext agent, configure it on Windows using PowerShell, set execution policies, and register the agent with TFS, covering required tools, configuration options, and optional service setup.
This guide explains practical techniques for diagnosing Node.js production issues, covering request‑latency analysis, CPU profiling with perf and FlameGraph, crash investigation via Core Dumps and mdb_v8, and memory‑leak detection using gcore and mdb_v8 diff tools.
The article examines how early‑stage startups can evaluate less‑common programming languages—Python, Ruby, Node.js, and Go—by weighing their disadvantages such as dynamic typing challenges, limited community support, hiring difficulties, and performance constraints, and explains why a mixed Python‑Go stack may balance rapid development with long‑term stability.
This article explains the concept of streams in Unix and Node.js, describes the four stream types, shows how to create and control readable streams with code examples, and demonstrates practical uses such as file serving, piping, and building an HTTP proxy.
This article demonstrates how to replace Node.js's limited parent‑child IPC with a simple, newline‑delimited JSON protocol over TCP or file sockets using Midway 5.0, providing full‑duplex client‑server communication for arbitrary processes.
This article chronicles the complete redesign of the BugHound bug‑submission system into UFT, covering data modeling with MySQL, migration from PHP/MongoDB to Node.js, progressive frontend upgrades from jQuery to Angular, schedule‑table algorithms, Git collaboration tactics, and future open‑source plans.
This article analyzes how improper use of Node.js's VM module leads to high CPU and memory consumption, explains the underlying contextify and Persistent handle mechanisms, and presents three practical solutions plus diagnostic tools to prevent and troubleshoot such performance issues.
This guide explains how to use GitHub Webhooks together with a shell deployment script, a Node.js listener, and Nginx reverse proxy to achieve fully automated website deployment, covering setup, code examples, and practical considerations.
This article walks through installing Elasticsearch on Ubuntu, adding the IK Chinese analyzer and synonym filter, configuring custom analyzers, and using the Node.js client to index and query documents, providing a complete, reproducible setup for site‑wide full‑text search.
This article walks through installing Elasticsearch on Ubuntu, adding the IK Chinese analyzer plugin, configuring synonym filters, and using the official Node.js client to create indices, mappings, and perform full‑text searches with custom analyzers and highlighting.
This article explains how Node.js supports various ES6 features, categorizes them into shipping, staged, and in‑progress groups, and shows how to enable full ES6 syntax in Node.js projects using Babel plugins, configuration files, and build scripts.
This article examines how Dragonfly, a Node.js‑based source site for Taobao's CMS, achieves high stability through thoughtful system design, robust implementation, comprehensive testing, and effective logging and monitoring practices across CDN, Redis, and other dependencies.
This article investigates the conditions under which Node.js’s drain event is emitted, explores its relationship with socket.write’s return value and highWaterMark, demonstrates experiments with TCP and HTTP streams, and shows how to implement proper back‑pressure handling using pause/resume or pipe.
This guide walks through setting up Node.js unit testing using Mocha and Istanbul, streamlining commands with npm scripts and a Makefile, handling glob patterns, and integrating continuous integration with Travis CI or a custom UITest-ci solution.
This article explains the technical details of Node.js CVE-2015-8027 and CVE-2015-6764 vulnerabilities, how they can be triggered through highWaterMark and HTTP UPGRADE misuse, and provides mitigation advice including version upgrades and Nginx filtering.
Kevin Lacker argues that JavaScript’s pervasive ecosystem is turning it into the default language for browsers, servers, and even native mobile apps, with Node.js leading backend adoption, React Native pushing cross‑platform native development, and industry surveys confirming its growing dominance across the developer community.
Learn how to achieve comprehensive code coverage for multi‑process Node.js applications by using Istanbul, instrumenting child processes, writing Mocha tests, and merging coverage reports, with detailed examples of master‑worker RPC, custom fork hacks, and package.json scripts for automated testing.
Front‑end developer Xiao Ming discovers how unit testing with TDD/BDD, Mocha, and various assertion libraries can ensure reliable Node.js deployments, prevent regressions, and enable confident refactoring, while also learning to measure coverage with Istanbul.
This article explains how Worktile’s team collaboration platform combines a single‑page AngularJS front‑end with Node.js, Redis, MongoDB, and ejabberd XMPP services to achieve cross‑platform access, native‑like interactions, and high‑performance real‑time updates for over 100,000 teams.
This article explains how Node.js implements synchronous file system and child‑process APIs on top of its asynchronous libuv core, covering the underlying C/C++ bindings, error handling, debugging techniques, and the practical trade‑offs of using sync methods in real‑world scripts.
This article details Medium's complex backend infrastructure, covering its service-oriented design, use of Node.js, Go, DynamoDB, Aurora, Redis, messaging queues, CDN strategies, monitoring tools, and continuous deployment practices.
This article explains why traditional front‑end/back‑end data coupling leads to duplicated effort, introduces GraphQL as a solution, and provides a step‑by‑step guide to creating a Node.js GraphQL server, defining schemas, handling queries, mutations, and extending the API for flexible, reusable data retrieval across multiple business scenarios.
This article explains Node.js memory architecture, how the V8 engine allocates and frees memory across code, stack, and heap, demonstrates using process.memoryUsage() to monitor RSS, heapTotal and heapUsed, describes V8’s Scavenge and Mark‑Sweep garbage collectors, and provides practical techniques for detecting and debugging memory leaks with heap snapshots and profiling tools.
This article compares PHP and Node.js server‑side architectures, explaining CGI, FastCGI, Node.js child_process and cluster modules, PHP‑FPM limitations, and how ReactPHP brings event‑driven, asynchronous, non‑blocking I/O to PHP for higher web performance.
This article explains how to construct a static‑site CMS using GitHub repositories for content, code, and a Travis‑CI‑driven builder, detailing the architecture, deployment pipeline, and the Grunt‑based static generation process for front‑end developers.
This article compares the two popular Node.js version managers, nvm and n, examining their installation methods, system support, handling of global modules, and path configuration to help developers decide which tool best fits their workflow.
This article explains how to build a robust multi‑process Node.js server using the cluster module, covering round‑robin load balancing, graceful worker shutdown, process monitoring, and inter‑process communication with code examples for both master and worker processes.
This step‑by‑step guide shows how to install Meteor on Linux/macOS, create and run a blank project, interact with MongoDB, and add a user authentication system, all without needing to refresh the browser.
This article explains what Meteor is, its full‑stack Node.js/MongoDB architecture, real‑time data handling with DDP, and the reasons it dramatically speeds up web and mobile app development for startups and rapid prototyping.
This article explains why Node.js throws errors like ETIMEDOUT and EADDRINUSE, detailing the underlying glibc connect() function, its error codes, and how non‑blocking sockets and thread cancellation affect resource handling.
This article examines Node.js’s early criticisms about reliability and single‑threaded limits, then explains how the built‑in cluster module and fork() enable multi‑process deployment, load balancing, and communication, illustrated with code demos, performance insights, and a look at nginx proxy integration.
This article introduces Node.js’s core characteristics—event‑driven, non‑blocking I/O, lightweight and efficient—while posing key questions about its underlying mechanisms, asynchronous callbacks, synchronous alternatives, event handling, performance limits, and scenarios where Node.js may not be suitable.
This article traces Node.js’s evolution from a modest 2009 V8‑based runtime to a dominant backend platform, highlighting npm’s impact, its event‑driven, non‑blocking architecture, real‑world strengths and limitations, and why careful evaluation is essential before adopting it.
This article presents a detailed case study of a mobile‑first single‑page web application built with React.js, Redux, React‑router, and a custom Node.js framework, describing the technology selection, development workflow, encountered challenges, and the advantages and drawbacks of the chosen stack.
This guide reveals the common JavaScript patterns that prevent V8’s optimizing compiler from generating fast machine code, covering unsupported syntax, misuse of arguments, excessive switch cases, problematic for‑in loops, and infinite loops, and provides practical techniques to keep your Node.js code performant.
After 15 years in software, the author reflects on JavaScript’s transformation from a simple validation script in the early 2000s to a pivotal language powering both front‑end interfaces and back‑end services, highlighting functional programming, ecosystem growth, and the market forces that drove its rise.
When Node.js receives an asynchronous request, it packages the request into an object, delegates processing to a worker thread, enqueues the completed object, and then its event loop repeatedly pulls objects from the queue to invoke their callbacks, enabling non‑blocking I/O.
A series of internal technical talks covers engineering Node.js development and operations, fast SEO and watcher solutions, native module creation, code elegance principles, rapid Chrome plugin development, and the future of web componentization, inviting staff to attend on September 19.
Tracing the evolution of web technologies—from early AJAX challenges and jQuery’s rise, through Chrome’s dominance, GitHub’s impact, OAuth, JSON, and modern frameworks like Node.js and Bootstrap—the article reflects on how these tools reshaped frontend development and the broader software landscape.
Worktile’s architecture combines a single‑page AngularJS front‑end with a Node.js/Express backend, leveraging MongoDB, Redis, and ejabberd for real‑time messaging, illustrating how SPA design, modular services, and long‑connection techniques enable a stable, high‑performance team collaboration platform.
This article explains common web security threats such as XSS and CSRF in a front‑end/back‑end separated architecture and demonstrates how the Midway framework provides HTML escaping, rich‑text filtering, and token‑based CSRF protection to safeguard user data and application integrity.
This article analyzes a Node.js buffer‑overflow vulnerability triggered by oversized UTF‑8 decoding, explains the underlying V8 call stack and key functions, demonstrates an exploit using crafted POST requests, and outlines the official security fix that adds proper bounds checking.
This article explains the concept of HTTP/2 server push, demonstrates how to implement it using the node‑spdy module with code samples for pushing assets, redirects, and SSE notifications, and discusses practical considerations and future possibilities for optimizing web performance.
The article explains how Worktile achieves cross‑platform web access, native‑like SPA experience, real‑time messaging, and service stability by using AngularJS for the frontend, Node.js, Redis, MongoDB, and ejabberd/XMPP for backend and push services.
The article summarizes Bowery’s migration from Node.js to Go and outlines six major advantages of Go—cross‑platform compilation, rapid deployment, built‑in concurrency primitives, integrated testing framework, comprehensive standard library, and structured developer workflow tools—backed by examples from leading tech firms.
Discontent with Joyent’s corporate stewardship prompted several core Node.js developers to fork the runtime into Io.js, releasing a V8‑upgraded alpha in January 2015, a move that highlights open‑source governance tensions and could reshape backend adoption by offering a more autonomous, community‑driven platform.
The article examines the recent split of the Node.js community that led to the creation of Io.js, exploring the underlying governance conflicts, commercial motivations of Joyent, and the broader implications for open‑source project independence and adoption across major enterprises.
The article explains how io.js emerged as a community‑driven fork of Node.js in early 2015 to address release frequency and governance concerns, describing its open management model, weekly release plans, compatibility with the npm ecosystem, and the broader context of Node Forward and community reactions.
This guide walks you through registering a WeChat public account, setting up a Node.js simulator for login and friend retrieval, installing Node.js, configuring Nagios commands and contacts, and finally enabling WeChat notifications for monitoring alerts.
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.
