This article explains why clear architecture diagrams are essential for communication, defines core concepts, categorizes diagram types, outlines common pitfalls, and introduces the C4 model with practical tips to create self‑describing, audience‑focused diagrams that align with code.
This article explores how Alibaba’s groups have adopted Flutter for rapid, cross‑platform mobile development, detailing its efficiency gains, UI expressiveness, infrastructure build‑outs, business deployments, and future plans to make Flutter a core development model across the company.
This guide explains how developers can efficiently get up to speed with an unfamiliar system by covering business learning, technical learning across five architectural views, operational concerns, and hands‑on practice, offering concrete questions and steps for each stage.
This article shares practical advice on improving a programmer's design ability, covering coding practice, theory study, hands‑on implementation, revisiting concepts, summarizing lessons, sharing knowledge, and additional tips such as designing before coding and avoiding blind reliance on patterns.
This article compiles 99 practical guidelines for software architects, covering everything from continuous learning, simplifying complexity, effective communication, performance awareness, requirement analysis, coding discipline, design trade‑offs, testing, and team leadership, offering a comprehensive roadmap to becoming a high‑impact architect.
The article reviews the rapid rise of Serverless as the next evolution of cloud computing, citing Gartner forecasts, real‑world case studies, best‑practice recommendations, and perspectives from global experts on its benefits, challenges, and future impact on development and operations.
WeChat Pay’s new C++ cross‑platform framework unifies iOS and Android payment flows, reducing code by 45%, cutting development time, improving crash stability, and introducing a routing mechanism, use‑case abstraction, and disciplined data handling to boost productivity and quality across mobile payment services.
Long‑running software projects inevitably see their initially clean architectures degrade as codebases grow, teams expand, and build times increase, but by understanding the stages of architectural decay and applying practices such as modular isolation, incremental builds, tooling upgrades, and disciplined refactoring, teams can slow or reverse this corrosion.
This article explains the fundamental concepts of software architecture, distinguishes systems, subsystems, modules, components, and frameworks, outlines various architecture layers and classifications, describes architecture levels, tracks the evolution from monolithic to micro‑services, and discusses how to evaluate and avoid common architectural pitfalls.
This article explains the seven SOLID design principles, illustrates dependency inversion with a car analogy, introduces inversion of control and IoC containers, and shows how these concepts improve code maintainability and modularity in software development.
This article explains the classic definition of patterns, introduces architecture patterns, and reviews five common software architecture styles—layered, microservices, microkernel, event‑driven, and cloud‑native—detailing their principles, advantages, drawbacks, and typical use cases, helping developers choose the right structure for complex systems.
This article outlines how to create solid software architectures by presenting a process for forming design principles, detailing fifteen universal architecture guidelines, and explaining service‑splitting and key design rules that together help build scalable, maintainable, and resilient systems.
This reading note explains the definition of architecture, its three essential elements, the role of an architect, how to distinguish problems, means and challenges, and how model‑thinking complements architectural thinking through concrete examples and classic models such as the cognitive pyramid and the Solow growth model.
This article explains the hierarchical architecture levels, contrasts strategic and tactical design, and walks through the evolution from monolithic applications to distributed services and micro‑services, highlighting benefits, drawbacks, and key metrics for evaluating a sound system architecture.
This article outlines frequent software architecture misconceptions, traces the evolution of large‑scale system designs, presents core architectural patterns and essential elements, and recommends key books to help engineers create high‑performance, reliable, and secure applications.
This article explains the fundamental definition of software architecture, distinguishes related concepts such as system, subsystem, module, component, and framework, and outlines the various architectural layers—including business, application, data, code, technical, and deployment—while highlighting the architect's responsibilities and when architecture design is needed.
The article explains four major software architecture patterns—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, drawbacks, and suitable scenarios to help developers broaden their architectural knowledge and make informed design choices.
The article explores various microservice decomposition approaches—vertical vs. horizontal, business‑driven, stability‑based, reliability‑focused, and performance‑oriented—highlighting trade‑offs, team size considerations, and practical guidelines for achieving scalable, maintainable service architectures.
The article argues that the common belief that architects need not code is a misconception, explaining how hands‑on coding improves architectural decisions, team collaboration, design quality, and product ownership while also addressing potential drawbacks and offering practical solutions.
Clear, layered software architecture diagrams prevent misunderstandings, and the C4 model—covering Context, Container, Component, and Code levels—offers a simple, universal language for visualizing static system structures, guiding teams from high‑level overviews to detailed code maps across diverse audiences.
This comprehensive guide explains the true essence of software architecture, covering definitions, system vs. subsystem, modules vs. components, frameworks vs. architecture, various architectural layers (business, application, data, code, technical, deployment), evolution from monolith to microservices, common pitfalls, and recommended reading, all aimed at helping architects design suitable, efficient, and maintainable systems.
This article examines the evolution of the mid‑platform concept in Chinese tech giants, outlines how companies like Tencent, Baidu, Xiaomi, Didi, JD, NetEase, Yonyou and Zhihu implement and differentiate front‑end, back‑end, and mid‑platform layers, categorizes platform types, and discusses common challenges and organizational pitfalls.
The article shares practical insights from a year‑long experience in an internet company, comparing the work attitudes, technical foundations, and responsibilities of architects versus senior developers, and offers concrete steps and resources for engineers aiming to upgrade to an architect role.
This article explains the evolution from traditional three‑layer monolithic architecture to microservice architecture, detailing the concepts, advantages, disadvantages, key characteristics, and practical challenges such as distributed complexity, DevOps, testing, and dependency management.
This article recounts how a developer transformed a massive three‑thousand‑line C# data‑center monitoring client into a concise fifteen‑line solution by applying reflection, generics, and systematic refactoring, while sharing practical advice on avoiding code generators, reinventing the wheel, and using unit tests to foster clean architecture.
An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.
This article traces the origin of the mid‑platform concept, examines how major Chinese tech giants implement and classify their mid‑platforms, explains the distinction between front‑end, back‑end, and mid‑platform layers, and outlines common pitfalls and practical challenges in building and operating such platforms.
The article reviews the major software‑architecture changes in 2019, covering the emergence of the middle platform, the shift to cloud‑native and microservice designs, the rise of reactive and serverless computing, and the evolving front‑end landscape, while reflecting on future directions.
The article explains a software architect's core duties, contrasts them with developers, outlines how to become an architect, and provides practical advice on topics such as UML, Spring Cloud vs Dubbo, distributed tasks, high concurrency, rate limiting, data synchronization, and large‑scale data updates.
The article explains why using enums as API return values is often criticized, highlighting their lack of extensibility, potential serialization errors when newer enum values appear, and contrasting this with the safety they provide as input parameters, illustrated with Java examples and community opinions.
The cloud native tech salon in Chengdu gathered experts from Meituan, Huawei, and G7 to discuss platform evolution, container innovations, and the convergence of cloud native with IoT, while showcasing sponsor support, a book signing, and vibrant community activities.
The Gaode App full‑chain dependency analysis system parses source code across JS, C++, Android and iOS into ASTs, extracts forward and reverse dependencies, stores them for GraphQL queries, and uses the data to guide regression testing, API deprecation, migration trends, and package‑size optimization, improving codebase governance.
This article explores the true nature of problems, explains why precise problem definition is essential for success, introduces a three‑dimensional framework for assessing severity, categorises problems, and presents "layered" and "dimensional" thinking techniques that help engineers and managers generate innovative solutions.
This article distills the core concepts of the book “Clean Architecture,” outlining software system value, architecture goals, programming paradigms, design principles such as OCP, SRP, DIP, and practical guidelines for component splitting, dependency handling, and boundary design to build maintainable systems.
This guide outlines the duties of a software architect, the essential technical and soft‑skill competencies required, a detailed technology stack covering collections, frameworks, security, JVM, concurrency, databases, big data, and distributed systems, and provides a curated learning‑material package for aspiring architects.
In this detailed recap of the 2019 GOPS Shanghai conference, three seasoned DevOps experts dissect what makes a successful DevOps practice, covering business goals, product design, delivery pipelines, reducing wait times, automation, cultural change, tooling, and practical implementation steps.
The Singleton pattern ensures a class has only one instance, providing a global point of access, and is explained with its definition, implementation steps, advantages, disadvantages, thread‑safety concerns, usage guidelines, and typical real‑world scenarios such as configuration management, logging, and resource pooling.
This article explores the definition of architecture, its three essential elements, the role and workflow of an architect, and how model‑thinking complements architectural practice by using abstract models to identify and solve underlying contradictions in complex systems.
The article explains the progression of software architecture from simple monolithic systems to distributed applications, microservices, and finally serverless platforms, outlining the advantages and disadvantages of each model for developers and organizations.
In this article, Meituan‑Dianping expert Mu Zongyan’s GIAC conference talk highlights that while Domain‑Driven Design has become popular with microservices, its true power lies in strategic design rather than rigid tactical patterns, urging architects to focus on broader business contexts.
The article explains how traditional front‑end/back‑end structures limit agility, introduces the concept of a middle platform (中台) that centralizes common services, showcases successful examples like SuperCell, Alibaba and Huawei, and outlines when and how organizations should adopt such a platform.
This article explains the strategic benefits of using interfaces in software design—standardization, abstraction, and decoupling—illustrates when and why to apply them, and shows how the Dependency Inversion Principle enables flexible, testable, and maintainable architectures.
The article reflects on the parallels between urban planning and software design, critiques the pitfalls of unplanned legacy systems, outlines a typical three‑layer development workflow, and introduces domain‑driven design concepts as a disciplined approach to building maintainable backend architectures.
This article reflects on the redesign of a large‑scale transaction system, describing a decision‑making routine that starts from purpose and goals, discusses programming paradigms, SOLID principles, domain‑driven design, bounded contexts, component splitting, layering, and the trade‑offs of patterns such as State and CQRS to achieve a flexible, maintainable backend architecture.
This article outlines Alibaba’s approach to scaling R&D efficiency across its 50,000‑engineer workforce, detailing the challenges of large‑scale development, agile and DevOps practices, value‑focused delivery, and systematic tools that enable sustained high‑quality software production.
The article argues that simple, term‑free design processes—focused on business problems, whiteboard brainstorming, concise documentation, and iterative feedback—outperform formal architecture tools, patterns, and dedicated architects in large‑scale systems like Uber, emphasizing engineering culture over rigid methodologies.
This article outlines the "golden five years" concept for Java programmers, offering stage‑by‑stage advice—from mastering fundamentals and design patterns to exploring distributed systems and boosting professional influence—culminating in a roadmap toward becoming a Java architect.
This article explains Conway’s Law and its four principles, showing how an organization’s communication patterns dictate system design, affect microservice adoption, agile practices, and the need for political navigation in large‑scale software architecture.
The article explains Conway’s Law and its four derived principles, showing how communication structures shape system design, why small teams reduce complexity, how agile and micro‑service approaches address time and scalability constraints, and why architecture decisions are inherently political.
The article explains how leading tech companies like Uber and Skype design massive systems using simple, informal diagrams and collaborative documentation instead of formal architecture tools or dedicated architects, emphasizing simplicity, team autonomy, and practical trade‑offs over rigid patterns.
This article explains the distinction between software design and architecture, outlines core principles for building service‑oriented systems, provides a step‑by‑step method for creating new services, and shares practical strategies for refactoring and migrating legacy code without creating future technical debt.
This article recounts a product manager’s year‑long journey creating an education‑focused middle platform, detailing the initial challenges, design principles, technical architecture, organizational hurdles, value‑quantification methods, and the broader strategic insights gained from the experience.
This article explores how reading classic source code, from SPI implementations to framework internals, can reveal architectural principles, offering a three‑level approach to deepen understanding, extract universal patterns, and apply them to design scalable, extensible systems.
The article explores how senior technical managers, from directors to CTOs, need deep technical detail awareness to succeed in fast‑growing companies, illustrating the pitfalls of neglecting details through personal anecdotes, hiring experiences, and practical advice on team structure and leadership.
This article examines how MyBatis applies classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by analysing source code snippets and explaining each pattern's role in the framework's configuration, execution, caching, and dynamic SQL generation.
This announcement outlines a new series on software design patterns, detailing its origin, purpose, structured article format, and a comprehensive roadmap covering object‑oriented fundamentals, design principles, and individual patterns such as Singleton, Factory, Adapter, and many more, with Java examples.
This article presents a practical methodology for handling complex business logic by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a detailed product‑on‑sale use case, code examples, and guidance on avoiding over‑reliance on tooling.
This article explains what software architecture is, why it is essential for any system, the responsibilities of architects, various architecture classifications, and introduces the COLA open‑source framework that combines layered, hexagonal, and onion architectures with CQRS and extensibility to separate business logic from technical details.
This article introduces the core concepts of software design patterns, explaining the three main categories—creational, structural, and behavioral—through concise definitions, real‑world analogies, and code examples to help developers build more reusable and robust systems.
The article explores how software architecture, traditionally depicted with static diagrams, must be continuously operationalized and evolved—illustrated by a thought experiment of a dormant computer, real‑world airline case, and the rise of microservices and DevOps practices—to remain viable in a constantly changing ecosystem.
This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up domain modeling, illustrated through Alibaba's retail‑to‑store product onboarding case, complete with code examples and architectural guidance.
A startup founder hires a high‑paid P8 engineer expecting a full‑stack miracle, only to discover the mismatch between specialist expertise and the broad, unrealistic demands of a full‑stack role, highlighting the pitfalls of hiring for breadth over depth in fast‑growing teams.
This article outlines ten frequent errors that Java backend developers make—from over‑focusing on low‑level details and leaking internal structures to neglecting separation of concerns, proper exception handling, multithreading, validation, XML configuration, profile management, dependency injection, and testing—offering practical guidance to prevent each pitfall.
This article examines the concept of a technical middle platform, outlining its purpose, the prerequisites for its adoption, the challenges of implementation, and the trade‑offs between over‑engineering and under‑delivering, while sharing real‑world examples of organizational friction and best‑practice recommendations.
The article explains what a software architect does, outlines their responsibilities such as architecture design, technology selection, managing non‑functional requirements, solving technical challenges, and guiding teams, describes different types of architects, and offers advice on the skills and experience needed to become one.
This article introduces the six fundamental object‑oriented design principles—SRP, OCP, LSP, DIP, ISP, and LoD—explains their definitions, benefits, and real‑world Java examples, and shows how they together form the SOLID guidelines for clean software architecture.
This article presents thirty practical architecture principles—from keeping designs simple and avoiding unnecessary features to embracing automated testing, ROI, user‑centric decisions, and distributed system fundamentals—offering a comprehensive guide for backend developers to build scalable, maintainable, and user‑friendly software.
The article argues that investing in internal software quality—clean architecture, low technical debt, and well‑structured code—lowers long‑term development costs and speeds up feature delivery, contradicting the common belief that higher quality always means higher expense.
The talk outlines Foxconn Cloud’s industrial‑internet practices, explaining why microservices, DevOps and cloud computing dominate industries, detailing unique microservice design versus traditional SOA, and showcasing real‑world cloud‑native architectures and development approaches for manufacturing and IoT applications.
Facing massive codebases, hundreds of developers, and rapid release cycles, Baidu App adopted a multi‑stage componentization strategy—spanning compile isolation, library standardization, runtime distribution, service layers, and degradation control—to improve parallel development, reduce complexity, and boost build speed and quality.
The article explains how to evolve a microservice‑based transaction system’s testing framework from a simple all‑in‑one approach to a modular, aspect‑oriented architecture with separate action, assertion, and proxy layers, enabling scalable, reusable, and maintainable test cases across expanding business scenarios.
At the 2019 GMTC Beijing Global Front‑End Conference, Beike engineers shared practical approaches to extreme front‑end performance optimization, Node.js service stability, comprehensive mobile crash and network monitoring, and the challenges and solutions of integrating Flutter into their existing mobile apps.
This article introduces Domain‑Driven Design, explains why traditional MVC‑based CRUD approaches lead to heavy, hard‑to‑maintain services, and shows how DDD concepts such as aggregates, bounded contexts, event sourcing and CQRS can clarify business logic, improve micro‑service boundaries, and reduce system complexity.
Becoming a software architect requires more than high‑concurrency knowledge; it demands comprehensive abilities such as requirement analysis, system decomposition, technology selection, design, communication, and leadership across all development phases, balancing business understanding with technical expertise to deliver effective architectural solutions.
The article analyzes current and emerging software architecture trends such as evolutionary architecture, microservices adoption, event sourcing, serverless, and the evolving role of architects, highlighting which concepts are moving toward mainstream adoption and which remain niche.
The article explains why pure coding expertise alone doesn’t make a top‑level architect, emphasizing hands‑on experience, forward‑looking design, product awareness, domain modeling, deep technical foundations, and high‑availability practices as essential for evolving robust software systems.
This article explains the Composite design pattern, detailing its definition, benefits, and implementation through JavaScript examples such as a startup command sequence and an employee‑department hierarchy, while highlighting key considerations, common pitfalls, and best practices for effective use.
This article explains how abstract, layered, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools that enable software architects to manage complexity, design scalable systems, and continuously evolve architectures in response to changing requirements.
This article traces the evolution of software architecture—from monolithic applications through vertical and SOA designs to modern microservices—detailing each style’s characteristics, advantages, and drawbacks to help developers understand when and why to adopt each approach.
This article examines Alibaba’s journey to achieve a 7 × 24 hour continuous delivery channel, detailing how system design, architecture evolution, configuration management, testing automation, and cultural shifts together boost R&D efficiency and enable rapid, reliable code iteration across large-scale teams.
This article distills the core ideas of "Clean Architecture"—explaining software system value, architecture goals, programming paradigms, design principles, component splitting, dependency handling, and boundary management—to help engineers build maintainable, extensible systems that stand the test of time.
This comprehensive guide explains software architecture methodologies, system decomposition techniques, core design principles, common patterns, and the 4+1 view model, offering readers a solid foundation for purposeful learning and application in modern software projects.
This article explores the challenges of API design, outlines fundamental principles such as clear mental models, simplicity, multiple implementations, and idempotency, and provides concrete best‑practice recommendations illustrated with the classic POSIX File API example.
This article introduces ten widely used software architectural patterns, explains their structure and key characteristics, and lists typical application scenarios for each, helping developers choose appropriate architectures for large‑scale enterprise systems.
The article analyzes the evolution of technology architecture, explains the origin and purpose of the mid‑platform concept from Alibaba and JD, outlines future software trends such as AI‑driven logic, IoT UI, blockchain data, and quantum infrastructure, and proposes a layered application model for the emerging industry internet.
This article provides concise explanations, real‑world usage tips, and visual illustrations for 23 classic design patterns—including structural, creational, and behavioral patterns—helping developers understand when and how to apply each pattern in everyday Java projects.
The article outlines the design of a prepaid‑card marketing platform that uses configurable rule templates, condition‑behavior chains, and rule orders to manage membership recharge rewards and gift‑card usage limits, providing a generic core engine with adapters for merchants while supporting future migration to payment systems.
By applying micro‑frontend principles and DDD‑based microservice design, the article explains how insurance companies can build modular, reusable front‑end components that integrate with backend middle‑platform services, thereby lowering integration complexity, improving scalability, and enabling unified, cross‑product order sales across multiple channels.
This article explains why clear architecture diagrams are essential for communication, defines key concepts, outlines common pitfalls, introduces the 4+1 and C4 modeling approaches, and provides practical tips for creating self‑describing, audience‑oriented diagrams that align with code.
The article explains a practical method for gaining software architecture experience by systematically reading the source code of well‑known open‑source projects, combining documentation with hands‑on code exploration to develop intuition and design skills.
This article explores how to achieve high cohesion and low coupling in distributed systems by examining clean, hexagonal, and CQRS architectures, detailing domain‑driven design layers, microservice boundary design, splitting principles, and practical strategies for data, caching, and resilience in modern backend development.
In this interview, Didi R Lab senior engineer Du Huan discusses his decade‑long Go experience, the language’s low‑cost entry, system‑level performance and cloud‑native strengths, upcoming enhancements like generics, his large‑scale microservice framework design for Gopher China 2019, and practical advice for developers and enterprises adopting Go.
This article explains why clear architecture diagrams are essential for communication, outlines common pitfalls, introduces the 4+1 view and C4 modeling approaches, and provides practical advice on creating audience‑centric, self‑describing diagrams that align with code and improve development efficiency.
Xianyu transformed its product publishing and editing functions by extracting platform code, introducing the SWAK framework, and decoupling services through RPC, resulting in clearer architecture, reduced code coupling, and significantly improved cross‑team development efficiency.
This article explains how event‑driven and microkernel architectures provide flexible, decoupled designs for complex backend systems, comparing centralized and decentralized patterns, outlining their structures, advantages, drawbacks, and suitable scenarios, and offering practical guidance for implementation.
This article explains the essence of high cohesion and low coupling, why they reduce maintenance cost, and provides practical steps—defining responsibilities, categorizing layers, and setting clear boundaries—to achieve a well‑structured, loosely coupled software system.
The article presents a detailed critique of Docker, arguing that despite its marketed benefits of portability, security, and resource management, its design introduces significant complexity, hidden costs, and operational risks that many organizations overlook when adopting it for production workloads.
The article explains essential object‑oriented design principles—SOLID for class design and six package‑level rules—showing how proper dependency management and modular organization create flexible, reusable, and maintainable software, and why developers must understand these concepts beyond basic procedural programming.
This guide walks founders, CEOs, CTOs and other stakeholders through nine actionable steps—from embracing simplicity and assessing personal needs to evaluating open‑source options, ecosystem support, future outlook, hiring, design flexibility, prototyping, and finally launching—helping them make informed technology‑stack decisions for web applications.
EventStorming is a rapid, lightweight group modeling practice that accelerates shared domain understanding and domain‑driven design by using domain events, commands, bounded contexts, and collaborative workshops, making it applicable to any complex technical or business domain.
