This article breaks down Dubbo's overall architecture, integration with Spring, URL‑bus design, startup sequences for registry, provider and consumer, the actual invocation chains, and the key design patterns such as Factory, Decorator, Observer, and Dynamic Proxy that power the framework.
This article walks through two common pitfalls when connecting a WeChat Mini‑Program to a server—an “invalid url” error caused by using single quotes instead of backticks, and a TLS 1.2 requirement that necessitates upgrading OpenSSL and recompiling Nginx, providing step‑by‑step solutions.
This article explains the fundamentals of consensus in distributed systems, compares Paxos and Raft, and provides a step‑by‑step guide with code snippets on embedding the etcd/raft library into the open‑source Mesos scheduler Swan to achieve reliable multi‑node data synchronization.
This article outlines the most important Node.js best practices for 2017, including adopting ES2015, using Promises, following coding standards, deploying with Docker, monitoring with Prometheus or Trace, enhancing security with checklists, learning micro‑services, attending conferences, semantic versioning, and using LTS releases.
This article explains how Tomcat leverages the Observer (publish/subscribe) pattern to manage component lifecycles, detailing the involved classes such as Lifecycle, LifecycleListener, LifecycleEvent, and their default implementations, and illustrates the process with diagrams and code snippets.
The article reviews Meituan‑Dianping’s tech blog evolution since 2013, highlights the ten most‑read posts of 2016 across backend, big data, mobile, and AI, and outlines emerging focus areas such as testing, cloud storage, and algorithmic innovations for the coming year.
To keep its rapidly expanding hotel‑direct platform consistent despite unstable supplier interfaces, Meituan evolved from full‑batch pulls to segmented fetching, predictive trigger‑based updates, and finally supplier‑initiated pushes, creating a hybrid pull‑push architecture that ensures low‑latency, reliable product and inventory data.
This article introduces QBus, a Kafka‑derived, highly‑available message queue built for 360, detailing its origins, core features, architectural design, performance advantages over traditional queues, and Java SDK usage examples for producers and consumers.
This tutorial provides a comprehensive, practical introduction to ZooKeeper, covering command‑line operations, native Java API usage, popular client libraries, and real‑world examples such as naming services, leader election, and distributed locks, all with online learning resources.
This guide walks through the fundamentals, installation steps, configuration details, and Python integration for three essential backend services—Memcached for high‑performance caching, Redis for persistent key‑value storage, and RabbitMQ for reliable messaging—complete with command‑line examples, code snippets, and best‑practice tips.
This article introduces ZooKeeper’s fundamental concepts, design goals, architecture, key features, common use cases such as service registry and configuration management, and provides step‑by‑step instructions for installing and configuring ZooKeeper in standalone mode on CentOS 7.
This article explains RPC fundamentals, its advantages, serialization processes, and provides a step‑by‑step TCP‑based Java RPC implementation with code examples and performance comparisons, helping backend developers understand and build simple remote procedure call systems.
This article explores Tomcat's dominant market share, its modular top‑level structure of Server, Service, Connector and Container, and details the step‑by‑step startup sequence from Bootstrap through Catalina to the Server and Service components.
The article presents a serverless‑style solution that replaces a heavy backend with a lightweight, automatically generated CRUD layer, detailing RESTful API conventions, extensions for batch operations, query parameters, foreign‑key handling, and a Rails‑based code‑generation pipeline to streamline development of a high‑availability supply‑chain system.
This comprehensive guide outlines the core technical competencies, project experience details, management practices, system architecture components, third‑party tools, common interview questions, and effective interview strategies that every aspiring Java backend developer should master before a job interview.
This article introduces phptrace, an open‑source PHP execution tracing tool, explains how to print a PHP process's call stack and perform real‑time tracing, and shows practical use cases for debugging and performance analysis in development and production environments.
This article explains the concepts of service buses and OSGi, describes how business components can be built as loosely coupled bundles, and outlines the architecture of a component container that uses a Java class bus to manage dynamic module loading and service registration.
This article explains why solid design patterns are crucial for EJB‑based J2EE projects and reviews several common patterns—including Session Facade, Message Facade, Command, DTO Factory, Generic Attribute Access, and Business Interface—detailing their structures, advantages, drawbacks, and best‑practice usage.
This comprehensive guide outlines the core Java programming competencies, web development frameworks, project experience, management tools, system architecture components, interview questions, and personal evaluation tips that aspiring Java engineers should master before a job interview.
This article explores the fundamentals and advanced techniques of building web crawlers, covering crawler types, essential features, RSS/ATOM harvesting, custom scraping methods, PHP header manipulation, regex extraction, and concurrency, providing actionable code examples for backend developers.
This guide explains the fundamentals of creating a PHP web crawler, covering server communication basics, interpreting robots.txt and sitemap files, and providing practical code examples using file_get_contents and cURL for efficient content retrieval.
The article examines the technical challenges encountered during the service‑oriented decomposition of Qunar's payment platform—including development efficiency, interface conventions, concurrency, security, monitoring, database sharding, read‑write separation, and asynchronous processing—and presents concrete solutions and best‑practice recommendations.
This article explains what web crawlers are, why they’re essential for content recommendation systems, the technical approaches across languages, practical use‑cases like price monitoring and news aggregation, and best practices for building efficient, ethical crawlers.
This article explains how the latest Node.js LTS release introduces the process.release.lts property, details the alphabetical chemical element codenames for versions like Argon and Boron, and shares interesting facts about the elements Actinium, Argon, and the discarded Astatine codename.
This article explains Laravel’s underlying architecture by detailing PHP’s execution phases, Laravel’s request lifecycle, the bootstrap process, the service container, dependency injection, binding mechanisms, and the role of contracts and facades, providing practical code examples for each concept.
This article examines typical Java backend performance problems such as database deadlocks, overly long transactions, thread‑pool misuse, and excessive logging, and provides concrete optimization strategies—including Redis distributed locks, short‑lived transactions, proper thread‑pool configuration, and disciplined log formatting—to dramatically improve throughput and stability.
Facing over 140 million monthly active users, Weibo evolved from a LAMP stack to a sophisticated third‑generation architecture that separates interface, service, and resource layers horizontally and adds vertical dimensions of business, technology, monitoring, and governance, leveraging Java, SOA, custom RPC, message queues, SSD caching, and a distributed tracing system to ensure high availability and performance.
This guide walks you through adding a Maven proxy repository, setting its remote URL and identifiers, and updating its index, providing clear step‑by‑step instructions with screenshots to help Java backend developers configure their build environment quickly.
Spring Boot, the revolutionary Java framework, simplifies coding, configuration, deployment, and monitoring for backend developers by eliminating XML, offering embedded servers, starter POMs, auto‑configuration, and cloud integration, and this guide walks through its core features, code examples, and a step‑by‑step project setup in IntelliJ IDEA.
This article explains how to measure the execution time of Java methods by first using an intrusive approach that embeds timing code directly in each method, then introduces a cleaner solution based on Java's dynamic proxy mechanism to separate performance monitoring from business logic.
Dubbo, an extensible Java RPC framework, evolves from simple single‑app setups to distributed service and dynamic resource governance architectures, offering RESTful calls, high‑performance serialization, flexible protocols, various clustering strategies, load‑balancing options, and a modular SPI‑based core, all detailed with diagrams and code snippets.
This article explains the JVM as Java's operating system, outlines its class loading process, and provides a detailed walkthrough of each runtime memory region—including program counter, stacks, heap, method area, and direct memory—highlighting their purposes and related error conditions.
This article presents nine practical npm recommendations—from quick project initialization and module discovery to version locking, production installs, and secure configuration—designed to help developers manage Node.js applications efficiently throughout their entire lifecycle.
This article explains Nginx's role as a high‑performance HTTP and reverse‑proxy server, its event‑driven design, key features, internal process model, request handling flow, and real‑world deployments, providing a comprehensive overview for developers and operations engineers.
The article reviews the Node.js Interactive Europe presentation, outlining Node.js v7’s planned V8 upgrade, new language features like async/await, a beta release strategy, ecosystem stability tools, web standard adoption, IoT suitability, VM neutrality, and community inclusivity initiatives.
This article chronicles the design, evolution, and architectural decisions of Qunar's hotel supply‑chain system from its 2014 inception, detailing workflow automation, contract digitization, cross‑category integration, and the resulting backend infrastructure that supports hotel product onboarding and sales.
This article introduces Nginx as a high‑performance, open‑source HTTP and reverse‑proxy server, explains forward and reverse proxy differences, outlines server types, highlights key features and modules, describes its multi‑process model and request handling, and showcases real‑world deployments.
When writing integration tests that involve database operations, developers must ensure that test execution does not pollute the original data, and the article explores strategies such as using transaction rollbacks, recreating databases, and mocking database interfaces to maintain data integrity.
This guide walks you through three Node.js debugging methods—built‑in debugger, VSCode integration, and node‑inspector—detailing step‑by‑step commands, remote debugging setup, watch management, and common security pitfalls for seamless server‑side debugging.
This article fills the gap of detailed tutorials by chronologically documenting how the author constructed a Django‑powered operations platform, adding monitoring, dashboards, log viewing, task submission, and various management features, each illustrated with screenshots and brief explanations.
Distributed queue programming treats a queue as a fundamental, cross‑process abstraction, guiding developers to select synchronous or asynchronous, decoupled, persistent messaging solutions and offering four core models—point‑to‑point, producer‑consumer, publish‑subscribe, and MVC—while the article illustrates real‑world designs for billing, cache updates, and ticket processing.
PayPal reports that migrating its high‑traffic web services from Java to Node.js doubled development speed, cut code size by a third, reduced file count by 40%, and achieved roughly twice the request throughput and 35% faster page rendering, highlighting the benefits of full‑stack JavaScript.
The Meitu Technology Salon’s second offline session, held on July 24 2016, gathered senior R&D engineers to explore practical Golang applications through three case studies—Meitu’s high‑performance services, Panda TV’s live‑streaming architecture overhaul, and NetEase’s P2P cache system redesign—offering insights and networking for 100 participants.
Node.js streams provide four core types—Readable, Writable, Duplex, and Transform—plus an objectMode for arbitrary data, and by using .pipe() they enable flow‑controlled processing with back‑pressure, as illustrated through detailed explanations, Gulp and Browserify case studies, and a hands‑on changelog generator example.
This tutorial shows how to install json-server, create a db.json file, run the mock REST API, and perform GET and POST requests to simulate backend data, enabling front‑end developers to work without waiting for a real server.
This article explains MySQL's overall logical architecture, details each component such as connectors, connection management, parser, optimizer, caches, and the pluggable storage engine framework, and provides examples of the storage engine API functions for creating, opening, scanning, indexing, and handling transactions, plus guidance on building a custom engine.
NGINX achieves top‑tier performance and scalability through a multi‑process architecture that limits worker processes to one per CPU core, employs single‑threaded non‑blocking workers handling many connections via an event‑driven state machine, and isolates privileged tasks in a master process.
This article explains how startup engineers can design a scalable web system by separating services onto multiple servers, using load balancers, distributed caches, master‑slave replication, and team‑splitting strategies, ensuring performance and reliability as user traffic and data volumes surge.
This article outlines the essential mindset, problem‑solving approach, solid PHP fundamentals, and comprehensive internet application and project‑management knowledge required for developers aspiring to senior PHP engineer roles.
This article outlines 25 critical areas—from object‑oriented design and core Java libraries to JVM internals, web frameworks, middleware, and project experience—that aspiring Java developers must master to become senior backend engineers and succeed in modern enterprise environments.
This guide walks you through the essential concepts of building robust RESTful APIs—including request/response handling, serialization, validation, authentication, CORS, and URL design—so you can create secure, standards‑compliant services from scratch.
This article explains how Spring MVC integrates web capabilities by configuring web.xml, initializing the root WebApplicationContext via ContextLoaderListener, creating a child context for DispatcherServlet, and managing the hierarchical relationship between the two contexts to share beans across a Java web application.
This article explains how Kafka's LogManager loads existing logs, manages background threads for flushing, checkpointing, cleaning, and compaction, and details the code implementations and strategies for log retention, segment cleanup, and log compression in a distributed storage environment.
Presented by Hulu’s senior software development lead, this talk outlines the evolution of Hulu’s full‑platform video system—covering its origins, scaling challenges, multi‑device support, DRM complexities, and the innovative MPEG‑DASH architecture that powers seamless streaming across desktops, mobiles, and living‑room devices.
This guide walks you through locating PHP internal function definitions in the source tree, using strpos as an example, and explains the surrounding C code structure, parameter parsing, error handling, and macro usage for deeper insight into PHP's backend implementation.
This article introduces developers to the fundamentals of locating, navigating, and understanding PHP 5.4's C source code, covering the repository, directory structure, essential C concepts, and the role of the Zend engine and extensions.
Under high‑concurrency loads, disk I/O becomes a bottleneck, prompting the use of caches; this article explains the fundamentals of caching, the role of memcached, and details its distributed implementation, covering simple modulo hashing, consistent hashing, and optimized virtual‑node techniques.
This article explains PHP Traits—introduced in PHP 5.4—as a fine‑grained code‑reuse mechanism, illustrates their definition, shows practical examples of extracting reusable methods into traits, compares trait usage with inheritance, and offers tips for effective trait design.
This article demonstrates how to employ Java's java.lang.instrument API together with Javassist to create a Java agent that instruments bytecode at runtime, enabling performance monitoring without modifying the original application code.
This article outlines the extensive technology stack behind Airbnb, covering its programming languages, client and server libraries, web server, data storage solutions, server services, and underlying hardware infrastructure that support its operations across 190 countries.
This article explains how to use Alibaba's open‑source Dubbo framework to configure various cluster fault‑tolerance modes and load‑balancing strategies, provides practical XML and Java code examples, and demonstrates a real‑world chat‑room application deployment.
This article explains how to perform code‑level performance measurement in Java services, compares the traditional intrusive approach with a cleaner solution using JDK dynamic proxies, and demonstrates how to decouple timing logic from business code.
Over eight years of building and evolving a service framework, the author reflects on fourteen critical design mistakes—from intrusive XML configurations and poor technology choices to insufficient versioning, load‑balancing flaws, and inadequate monitoring—highlighting the importance of comprehensive, forward‑looking architecture for backend engineers.
This comprehensive guide outlines the core Java programming skills, project experience, development processes, tools, interview questions, and personal evaluation tips that candidates should master to succeed in Java developer interviews and advance their careers.
This article explains MySQL's widely used MEM_ROOT memory allocator, detailing its macros, the MEM_ROOT and USED_MEM structures, initialization routine, allocation algorithm, and pointer handling, while illustrating how free and used blocks are managed via linked lists.
This article outlines the mindset, problem‑solving approach, core PHP knowledge, and project‑management expertise required to transition from a junior or mid‑level developer to a competent PHP senior engineer.
This article explains why PHP arrays consume far more memory than their C equivalents and demonstrates a technique that stores a double array in a string using pack/unpack, which can dramatically lower memory consumption at the cost of some performance.
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 article presents a comprehensive list of 17 essential PHP best‑practice tips—ranging from using absolute paths and custom loaders to proper output buffering, character encoding, session handling, and file permission management—to help developers write cleaner, more maintainable, and secure backend code.
LinkedIn grew from a single monolithic Leo server handling all web requests to a complex ecosystem of over 750 independent services, employing graph databases, read replicas, caching layers, Kafka pipelines, Rest.li APIs, and multi‑data‑center deployments to support billions of daily queries.
The article shares practical lessons from a year of backend R&D experiments at Weibo, describing how a bottom‑up hybrid‑cloud solution, cross‑team collaboration, and systematic team‑building transformed the Feed service’s scalability, cost efficiency, and alignment with business goals.
This article introduces fifteen powerful PHP libraries—from testing tools like Mink to HTTP clients such as Requests and caching solutions like Stash—highlighting their key features and how they can accelerate backend development and improve web application performance.
This article introduces the Spring Framework, explains its layered architecture and core modules, and details fundamental concepts such as Dependency Inversion Principle, Dependency Injection, BeanFactory, BeanDefinition, and ApplicationContext, along with practical Java‑based configuration and annotation‑driven wiring examples.
This article examines the kernel‑mode iSCSI Enterprise Target (IET), detailing its component modules (ietadm, ietd, iscsi_trgt), the interaction flow between initiators and the target, and the internal I/O processing pipeline, including thread allocation, work queues, and backend storage handling.
This article explains the layered architecture of Alibaba's open‑source Dubbo framework, detailing its service, config, proxy, registry, cluster, monitor, protocol, exchange, transport, and serialization layers, as well as service definition, registration, monitoring, communication protocols, and package organization for building distributed backend services.
This article explains why consistent PHP coding standards—covering line breaks, spacing, naming, and habits like method chaining and array formatting—are essential for readable, maintainable code, and offers practical examples and tools to enforce them across a development team.
Drawing on fourteen years of hands‑on experience, the article chronicles how a website’s architecture matures from a simple personal homepage to a billion‑page‑view enterprise system, highlighting the essential principles, design patterns, operational practices, and scalability strategies that underpin successful large‑scale web platforms.
This article shares a 14‑year journey of building and evolving website architectures, from a simple personal homepage to billion‑page platforms, highlighting essential accumulation, knowledge structuring, design principles, infrastructure, software engineering practices, and the nuanced differences across business systems.
The article outlines VIP's transition from a simple outlet‑style e‑commerce platform to a multi‑brand flash‑sale service, detailing each architectural phase—from a monolithic LAMP stack through vertical silo and distributed service‑oriented designs—to a cloud‑native, platform‑plus‑application model that supports scalable, high‑availability operations.
This article details Tuniu’s transformation from a single‑machine system to a large‑scale distributed architecture, covering the step‑by‑step serviceization process, the evolution of its price‑calculation service, the implementation of a service‑governance platform, data‑center migration challenges, performance‑optimization tools, and the technical evolution of its mobile app client.
This article introduces Sina Weibo's Motan RPC framework, compares RPC with other remote‑call technologies, explains Motan's modular architecture and high‑availability features, and details recent hybrid‑cloud adaptations such as traffic compression, dynamic group‑based routing, and extensible command‑driven traffic control.
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 explores Python's role in Industrial Light & Magic's visual effects for Star Wars, introduces the Star Wars API, and demonstrates Python scripts that query film data and build a simple Star Wars-themed game.
The article shares a veteran engineer’s fourteen‑year journey from a simple personal homepage to a billion‑page‑view e‑commerce platform, outlining essential principles, knowledge structures, design philosophies, infrastructure choices, and operational practices needed to build and maintain large‑scale web systems.
This article explains how to install PHP 7, configure key performance features such as Opcache, HugePages and PGO, compares its speed with PHP 5.6 and HHVM using real‑world benchmarks, and discusses compatibility considerations for popular platforms like WordPress and Magento.
The article presents nine speculative trends for the next five years in programming—covering REST‑based IoT, a resurgence of binary protocols, video overtaking HTML, ever‑more capable smartphones, massive databases, JavaScript dominance via code‑generation bots, PHP’s comeback, widespread coding education, and managerial overreach—while stressing the inherent uncertainty of tech forecasts.
Learn how to quickly set up a Python 3.4.3 development environment using pythonbrew, create a virtual environment, and install essential packages like Django 1.7 and Selenium, with step‑by‑step commands and tips for efficient workflow.
This article explains how microservices emerged to address low development efficiency, technology incompatibility, and resource waste, and describes their benefits such as faster deployment, technology flexibility, optimal resource use, and improved stability, while also noting performance challenges.
This article explains the challenges of ensuring data consistency across multiple databases during operations like Alipay transfers, introduces local and distributed transactions, details the two‑phase commit protocol, and shows how reliable messaging can replace heavyweight distributed transactions for high‑concurrency systems.
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 shows how to create a minimal Python WSGI server that can run Django, Flask, and Pyramid applications without modifying server or framework code, explains WSGI fundamentals, provides step‑by‑step setup, code snippets, testing commands, and demonstrates the server‑framework interaction.
The article explains the internal and external drivers behind website architecture evolution, outlines the U‑N‑S‑C model, describes scaling steps such as service separation, caching, clustering, load balancing, database read/write splitting, CDN, and highlights the operational and organizational challenges of each phase.
The article examines the fundamentals of message‑based distributed architecture, explains core messaging patterns such as Message Channel, Publisher‑Subscriber and Message Router, and provides practical application scenarios, technology‑selection criteria, and challenges for building robust enterprise integration solutions.
Facing massive traffic spikes during events like Double‑11, Haier’s e‑commerce platform adopted a SOA architecture built on Dubbo, designed a flexible product service with a DSL‑driven query engine, and achieved high performance, linear scalability, and extensibility across diverse product categories.
The article chronicles a developer’s journey from a simple personal homepage to managing billion‑visit web platforms, sharing practical insights on architecture evolution, knowledge structures, design principles, infrastructure, and software engineering practices essential for building and operating large‑scale websites.
This article explains how a unified LAMP-based solution enables fast development, automated testing, and streamlined operations for large‑scale online services, detailing the architecture’s layers, tooling, and future directions for standardization and platformization.
This article presents a step‑by‑step case study of locating and fixing a memory‑leak problem in Baidu's Bigpipe Broker backend by analyzing a running leaking process with GDB, pmap, and custom scripts, highlighting the pitfalls of Valgrind and the importance of clear function naming.
This article describes how to create a “fastest‑first” load‑balancing algorithm for NGINX using OpenResty and Lua, including the design principles, modifications to lua‑upstream‑nginx‑module, weight‑adjustment logic, Docker build steps, and practical considerations for handling latency‑based server weighting.
In this interview, Xiaomi R&D architect Ouyang Chen shares the design philosophy, evolution stages, core modules, pitfalls, and future challenges of the Xiaomi advertising platform, offering practical insights for building scalable backend systems.
Learn a comprehensive set of 30 practical PHP best‑practice tips covering file inclusion, path handling, debugging, output buffering, security, performance, database interactions, session management, and code organization to improve maintainability, efficiency, and reliability of your backend applications.
