The article shares painful real‑world cases of poorly written SQL and Java code, explains how tangled microservice dependencies and missing transactions cripple maintainability, and offers concrete guidelines for clean architecture, modular design, and effective code governance to boost team efficiency.
The article explains software architecture by distinguishing the business and computer problems it must solve, outlines the responsibilities of owners and engineers, and describes how increasing scale leads to layered deployment, code, and organizational structures.
This article explores the origins of software as a human‑simulation tool, examines how cost reductions and technological advances have driven its widespread adoption, and explains how increasing complexity led to the emergence of specialized roles and architectural practices in modern software development.
This article explains the principles and benefits of Domain-Driven Design (DDD), describing how strategic and tactical design, layered and hexagonal architectures, CQRS, and bounded contexts help manage complex business logic, improve scalability, and align software development with evolving business requirements.
The article examines why software architectures inevitably degrade as projects grow, outlines the stages of decay, critiques common quick fixes, and proposes strategic solutions such as adopting new technologies, refactoring into isolated components, using separate processes, and building loosely coupled platforms to sustain long‑term maintainability.
This article explains DDD terminology by using a peach‑tree analogy to illustrate how a business can be divided into domains, subdomains, core, generic, and supporting domains, and provides step‑by‑step guidance for identifying and structuring these layers to focus development effort effectively.
This article uses a peach‑tree analogy to explain how to break down complex business logic into domains, subdomains, core, generic, and supporting domains, illustrating the practical steps and benefits of applying Domain‑Driven Design in software projects.
This article explains the fundamental concepts of software architecture—including systems, subsystems, modules, components, frameworks, and architecture itself—by defining each term, illustrating their relationships with real‑world examples, and clarifying common misconceptions for technical professionals.
This article examines the purpose of software architecture by identifying its diverse stakeholders, detailing the refinement process, illustrating the 4+1 view model with diagrams, outlining documentation practices, summarizing key takeaways, and previewing the next installment on deployment architecture.
This article explains the essence of software architecture, its core elements, why clear diagrams are crucial for communication and quality, and presents practical principles, patterns like UML, 4+1, C4, arc42, and tools such as draw.io and PlantUML to help engineers create accurate, consistent, and maintainable architectural documentation.
The article explains the rise of Domain-Driven Design by tracing architectural evolution from monolithic to microservices, highlighting DDD’s role in defining business boundaries, its strategic and tactical components, and practical steps for modeling domains to guide microservice design.
This article traces the evolution of software architecture from monolithic applications through vertical splitting, distributed services, and SOA to modern microservices, and then details the essential technology stack—including service communication, API gateways, authentication, fault tolerance, logging, configuration, containers, orchestration, and CI/CD—required to build scalable, resilient cloud‑native systems.
This article explains software architecture concepts, the 4+1 view model, various architectural styles, the evolution of layered client‑server architectures, and the MVC/MVP patterns, providing a comprehensive overview of design principles and their practical implications.
Domain-Driven Design (DDD) has surged in popularity as microservices dominate, and this article traces its historical background, explains the architectural shifts that created its need, outlines strategic and tactical design concepts, and provides a three‑step method for defining domain models and service boundaries.
This article introduces ten fundamental software architecture patterns—layered, client‑server, master‑slave, pipe‑and‑filter, broker, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical applications, advantages, and drawbacks to help engineers choose the right architecture for large‑scale enterprise systems.
The article explains how the evolution from monolithic to microservice architectures created a need for clear business boundaries, why DDD gained traction after the microservice boom, and outlines the strategic and tactical steps to apply DDD for effective service decomposition.
This article explains how to instantly improve program design by mastering the five SOLID principles, understanding three common architectures, using diagrams, choosing clear names, and optimizing nested if‑else logic, all illustrated with Python code examples and visual diagrams.
This article presents typical examples of software architecture diagrams—including application, technical, security, and deployment views—to help developers understand and reference common architectural patterns in everyday project development.
This article explains the Chain of Responsibility design pattern, covering its concept, UML class diagram, Java code examples, advantages, disadvantages, typical application scenarios, extensions, and comparison with the Decorator pattern in software development.
This article explains the concept of domain models, why they are crucial business assets, how to create and use them with UML diagrams and simple examples, highlights common misconceptions, and shows how explicit modeling improves communication, code readability, and software adaptability.
This article humorously illustrates 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by mapping each to everyday relationship scenarios.
This article explains the Chain of Responsibility design pattern by linking a historical story of Guan Yu’s five passes with an OA leave‑approval workflow, provides a clear definition, discusses its pros and cons, and presents comprehensive Java code examples illustrating abstract handlers, concrete handlers, and client usage.
An extensive diagram presents a panoramic view of an enterprise technology middle‑platform architecture, illustrating its layered components, data flow, service governance, capability services, and integration points, offering a comprehensive visual guide for architects and engineers designing scalable internal platforms.
The article explains why scalability is crucial for software systems, outlines the difficulty of accurately predicting future changes, and presents two architectural approaches—layer separation and abstraction/implementation layers—illustrated with diagrams and design‑pattern examples to help architects manage complexity.
This article explains the essence of software architecture, outlines its main components, classifies various architecture layers such as business, application, code, and technical architecture, discusses evolution stages, measurement criteria, common pitfalls, and provides a comprehensive knowledge framework for architects.
This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
This article explores the definition of software architecture, reviews essential technologies such as distributed systems, clustering, caching, queues, multithreading, and rate limiting, discusses security threats like SQL injection and XSS, and highlights common design mistakes to avoid.
This article examines how evolving software requirements can lock systems into rigid data models, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when CQRS is beneficial or detrimental, helping architects decide if separating read and write models will improve scalability and maintainability.
In this interview, senior architect Li Zunjing shares his two‑stage journey at JD.com—from stabilizing e‑commerce systems to pioneering B‑PaaS—highlighting the importance of technical fundamentals, a "empty‑cup" mindset, collaborative execution, and self‑driven learning for engineering success.
Domain-Driven Design (DDD) offers a systematic approach to separate business complexity from technical concerns, using ubiquitous language, bounded contexts, layered and hexagonal architectures, CQRS, and strategic and tactical patterns, enabling teams to build flexible, scalable systems that quickly adapt to evolving requirements.
This article introduces the Builder design pattern, explains its role in separating object construction from representation, provides UML class diagrams and Java code examples, outlines typical application scenarios, and discusses its advantages and disadvantages.
This article introduces the concept of software architecture and compares four major styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, disadvantages, and typical use cases, helping developers understand how architectural choices affect scalability, maintainability, and operational complexity.
This article walks through a real‑world scenario of extending trial‑user eligibility rules, explains the logical flow using AND/OR short‑circuiting, and presents a modular Java rule engine design with abstract templates, concrete rules, a service builder, and a test case, highlighting its advantages and drawbacks.
This article examines how Qunar’s technology director applied Domain‑Driven Design to reshape business processes, the challenges faced, tools used, and practical steps for teams to adopt DDD effectively in a large micro‑service environment.
This article explores how to combine typed functional concepts with traditional object‑oriented dependency injection in Python, using a Django‑based word‑guessing game to illustrate naive parameter passing, its drawbacks, and a functional approach based on factories, transparent dependencies, and static typing.
The article analyses the rise and fall of UML, tracing its origins in the 1990s, the impact of CASE tools, the shift toward agile development, and the technical and cultural reasons for its decline, while also exploring emerging lightweight modeling alternatives such as C4 and masala diagrams.
This article shares a senior backend engineer's insights on why code review is essential, common pitfalls that degrade code quality, and a set of concrete principles—ranging from simplicity and composition to transparency and error handling—to guide developers in writing maintainable, scalable Go code and robust system designs.
This article provides a comprehensive overview of behavioral design patterns—including Chain of Responsibility, Command, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—explaining their motivations, class diagrams, advantages, disadvantages, and typical scenarios for applying each pattern in software development.
This article outlines the evolution of software architecture—from monolithic to distributed, microservice, and serverless models—detailing each pattern’s structure, advantages, and drawbacks, helping developers understand how architectural choices impact scalability, maintenance, and innovation in modern software projects.
This article explains behavioral design patterns—how they manage complex runtime interactions among classes or objects, outlines the eleven classic patterns with their motivations, class diagrams, advantages, disadvantages, and typical scenarios, and shows why object‑based patterns offer greater flexibility than class‑based ones.
This article explains twenty‑three classic software design patterns—including Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using humorous real‑world scenarios to illustrate their intent and structure.
This comprehensive tutorial explores the origins, concepts, classifications, and practical applications of software design patterns—including the classic 23 GoF patterns—and explains the seven SOLID principles with clear Java code examples, helping developers write more reusable, readable, and maintainable code.
This article explains the fundamental notion of software architecture, why it is needed, the responsibilities of architects, various architecture classifications, typical application architectures such as layered, CQRS, hexagonal and onion models, and introduces Alibaba's open‑source COLA framework with its layered design, extension mechanisms and standards.
This article explains the Singleton design pattern, its core concept of ensuring a single instance, presents nine Java implementations with code examples, compares their advantages and disadvantages, discusses real‑world usage in Android and general development, and offers guidelines for when to apply the pattern.
This article explores why traditional if‑else constructs often lead to tangled, hard‑to‑maintain code and presents five progressively sophisticated techniques—including removing unnecessary else blocks, using guard clauses, value‑assignment shortcuts, dictionary‑based dispatch, and strategy‑pattern refactoring—to write cleaner, more readable software.
This article explains what software architecture is, why it is needed, the responsibilities of architects, various architecture classifications, common architectural styles such as layered, CQRS, hexagonal and onion, and introduces the COLA application architecture with its layered design, extension mechanisms and normative guidelines.
The article outlines twenty‑four essential capabilities across continuous delivery, architecture, product and process, lean management, and culture, derived from the Accelerate research, providing practical guidance for organizations seeking high‑performance software delivery.
This article chronicles the six‑year evolution of the Tian'e Home Service order platform—from its early embedded form in 2015 to a unified, multi‑service order system—detailing architectural milestones, functional upgrades, and the testing challenges faced by the QA team throughout each phase.
This article traces the evolution from machine code to high‑level languages, explains the two software crises, defines system, subsystem, module, component and framework, and clarifies the true purpose and goals of software architecture for modern developers.
This comprehensive guide explains what design patterns are, why they matter, the fundamentals of object‑oriented programming, ten core SOLID principles, a mnemonic for 23 patterns, and detailed examples of creational, structural, and behavioral patterns with real‑world code snippets to help developers write cleaner, more maintainable software.
This article explains how to design and implement a rule engine in Java using abstract base rules, template methods, and logical connectors (AND, OR, NOT), providing code examples, execution flow, and a discussion of its advantages and drawbacks.
This article examines common pain points in building and maintaining business applications, proposes a design specification that standardizes technical details, encourages component reuse, promotes continuous refactoring, and introduces a service orchestration engine to streamline complex workflow integration.
This article explains the fundamentals of software architecture diagrams, introduces the 4+1 view taxonomy and the C4 model, describes how to choose the right diagram for different audiences, and shares practical tips, common pitfalls, and tool recommendations for clear, self‑describing architecture visuals.
The article explains the progression of software architecture from simple monolithic designs through distributed applications and microservices to modern serverless solutions, outlining each model's structure, advantages, disadvantages, and impact on development, deployment, and operational complexity.
This article explains Uber’s Domain‑Oriented Microservice Architecture (DOMA), describing why the company adopted it, how domains, layer design, gateways and extensions are organized, the operational benefits achieved, and practical advice for companies of different sizes considering a similar evolution.
This article outlines the four main software architecture styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, drawbacks, and how each impacts development, maintenance, scalability, and operational costs for modern software engineers.
This article explains why mastering the underlying logic of design patterns—recognizing what changes and how to encapsulate those changes—is essential for developers to select appropriate patterns, improve object‑oriented design, and solve real‑world software problems effectively.
Software developers need to understand the evolution of software architectures—from simple monolithic designs to distributed applications, microservices, and serverless platforms—because each model has distinct advantages and drawbacks that affect scalability, maintainability, deployment frequency, operational complexity, and overall cost.
This article explores the evolution of software development—from machine language and assembly to high‑level languages—examines the two software crises that spurred structured and object‑oriented programming, and explains how software architecture emerged to manage system scale, coupling, and complexity.
This article explains the fundamentals of Domain-Driven Design, describing how a shared ubiquitous language and a well‑crafted domain model drive software architecture across presentation, application, domain, and infrastructure layers, and it covers key patterns such as aggregates, entities, value objects, repositories, CQRS, Event Sourcing, and DCI.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines software architecture by clarifying related concepts such as systems, subsystems, modules, components, and frameworks, ultimately highlighting architecture as a solution to system complexity.
This article explores the evolution of software development from machine language to high‑level languages, explains the two software crises, and defines software architecture by distinguishing systems, subsystems, modules, components, and frameworks, emphasizing architecture as a top‑level structural solution for managing complexity.
This article analyses how MyBatis applies nine classic design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete Java examples to deepen understanding of software design in backend development.
This article explains why architecture diagrams are essential for communication, defines key concepts, introduces the 4+1 view classification, outlines criteria for good diagrams, and presents the C4 modeling method with practical examples to help teams produce self‑describing, audience‑focused system visuals.
This article explains the evolution of software development from machine code to high‑level languages, describes the two software crises that led to structured programming and OOP, and defines software architecture as the top‑level structure that manages system complexity through clear components, modules, and rules.
Learn a step‑by‑step methodology for drawing effective software architecture diagrams, covering the purpose of different diagram types, common pitfalls, audience‑focused design principles, and a detailed introduction to the C4 model with practical examples and visual guidelines.
The article explains the difference between anemic (transaction‑script) and rich (domain‑model) designs in DDD, outlines their historical origins, advantages and drawbacks, and argues why embedding behavior in domain objects aligns better with object‑oriented principles despite added complexity.
The article explains the fundamental differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, disadvantages, and provides concrete examples to help developers decide when to apply each model in software architecture.
This article explains how to apply classic design patterns and the six SOLID principles—Liskov Substitution, Single Responsibility, Dependency Inversion, Interface Segregation, Law of Demeter, and Open‑Closed—to design a maintainable, extensible message‑sending system with task scheduling and dynamic provider configuration.
This article explains the distinction between technical and business domains, defines domains and subdomains, describes how to identify core, generic, and supporting subdomains, and outlines practical methods such as domain vision statements and highlighted cores for effective domain‑driven design.
This article explains how layered thinking and layered models guide architecture design, covering decomposition and integration, cloud three‑tier (IaaS‑PaaS‑SaaS) and SOA layering, the role of service and data layers, and how to combine cloud and SOA concepts into coherent architectural diagrams.
This article explains the concept of layered architecture thinking, covering decomposition and integration, cloud three‑tier models, SOA layering, application‑level three‑tier patterns, and how to combine cloud and SOA approaches into a coherent, multi‑view architectural blueprint.
The article explains seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical structures, strengths, weaknesses, and suitable application scenarios.
Many companies attempt microservice transformations only to end up with a “distributed monolith” that looks like microservices but retains monolithic flaws, leading to increased complexity, reduced stability, and minimal performance gains, as this article explains the root causes and how to avoid them.
This article distills essential software design knowledge—covering the five SOLID principles, three common architecture styles, effective diagramming, naming conventions, and techniques for simplifying nested if‑else logic—providing concrete Python examples and visual aids to help developers write more maintainable and robust code.
This article explains why clear application layering matters, outlines Alibaba's recommended layers, proposes an optimized layering approach, details domain model mappings for each layer, and offers practical tips to improve maintainability and team collaboration in backend development.
This article explains the purpose and types of software architecture diagrams, introduces the C4 modeling approach, highlights common pitfalls, and offers a step‑by‑step methodology to create clear, self‑describing diagrams that effectively communicate system structure to the right audience.
This article explains the cloud native paradigm—originating from Matt Stine in 2013—and its core components such as DevOps, continuous delivery, microservices, agile infrastructure, and the Twelve‑Factor App, showing how they enable resilient, scalable applications built directly on cloud services.
Effective API design is crucial for microservice architectures, reducing communication overhead, preventing API decay, and ensuring scalability; this article outlines common pitfalls, core design principles such as simplicity, focus, extensibility, compatibility, thorough testing, and documentation to help developers build robust, maintainable services.
The author reflects on their path from a senior Java developer to a software architect, describing early misconceptions, the pitfalls of over‑focusing on code, the importance of mastering existing components, and how design patterns and maintainability become essential when assembling high‑concurrency, distributed architectures.
The article traces the evolution of software architecture—from monolithic applications through vertical splitting, distributed services, and finally microservices—detailing their advantages, drawbacks, and the essential technology stack such as service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD, while providing practical examples and references.
The article shares a senior Alibaba engineer’s reflections on what architecture means, the architect’s role, essential skills, and the challenges faced, offering practical insights for developers aspiring to become effective software architects.
The iQIYI Knowledge Web front‑end team built a developer‑oriented component library that splits UI and business logic into reusable basic and business Vue components, enforces clear input/output contracts, uses on‑demand loading and Storybook documentation, achieving high code reuse, maintainability, and consistent UI across independent projects while tackling bundle size and CI/CD challenges.
This article explains the twenty‑one key non‑functional characteristics of software architecture—such as performance, reliability, scalability, security and maintainability—detailing their definitions, typical metrics, and practical techniques for improvement, while linking each trait to ISO‑25010 and real‑world engineering practices.
This article presents a detailed Java learning roadmap covering fundamentals, core language features, the Spring framework, microservices, databases, DevOps tools, project experiences, and soft skills, guiding beginners to become proficient backend developers.
This article explains the definitions of domain and data models, illustrates why they are often confused, shows real‑world examples of misusing each, and provides practical guidance on separating them to improve system design, scalability, and maintainability.
In this detailed case study, a team describes how they successfully refactored a 30,000‑line advertising engine within a month, covering the system's legacy challenges, preparation steps, execution tactics, testing strategies, and the seven critical takeaways that ensured a smooth, low‑risk rollout.
The article examines the tangled code and maintenance pain points of multi‑store (chain) product management, then proposes separating generic and chain‑specific logic into distinct services—mei‑goods for single‑store functions and mei‑chain for cross‑store rules—using OCP, SRP, and domain‑driven design to achieve decoupling, isolated deployment, clearer responsibilities, and improved system stability and developer productivity.
The article analyzes Alibaba's recent decision to dismantle and thin its mid‑platform, tracing its origins, evaluating its impact on business agility and innovation, and discussing why a leaner architecture suits combination‑style innovation while disruptive breakthroughs require a different approach.
The article explains how the YuanShi platform was created to address front‑end talent shortage by standardising tools, redefining team structures, introducing component‑based cooperation, and outlining the evolution, benefits, challenges, and future directions of this approach within a large B‑end organization.
This article explains the abstract nature of software architecture, why it is essential for any system, the responsibilities of architects, various architecture classifications, typical patterns such as layered, CQRS, hexagonal and onion, and introduces the open‑source COLA architecture with its layered design, extension and specification concepts.
This article compares ancient warfare logistics with modern software delivery, defines DevOps and microservices, presents survey data on DevOps adoption, explains microservice characteristics, outlines suitable scenarios, and discusses the benefits and challenges of adopting a microservice‑based DevOps approach.
This article introduces seven common software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their context, typical problems they address, core solutions, inherent drawbacks, and suitable application scenarios for developers and system designers.
The article explains how monolithic drawbacks—complexity, technical debt, and scaling issues—drive the shift to microservices, then details applying Domain‑Driven Design principles such as bounded contexts, aggregates, and layered architecture to design cohesive, loosely‑coupled services, illustrated with e‑commerce examples and code snippets.
This article explains seven fundamental software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, drawbacks, and ideal use cases for developers seeking robust system designs.
This article introduces the Chain of Responsibility design pattern using a whimsical Qing dynasty south‑tour scenario, walks through class design, UML diagrams, and Java code examples—including abstract officials, a singleton emperor, and a prime minister orchestrating the travel—demonstrating flexible, extensible workflow construction.
The article analyzes how the relentless pursuit of high performance drives both single‑machine and cluster‑level architectural complexity, explaining the evolution from batch processing to multi‑core CPUs, the trade‑offs of processes, threads, SMP/NUMA/MPP, and the challenges of task allocation and decomposition in large‑scale systems.
This article explains common software architecture patterns—including traditional three‑tier, cluster (horizontal scaling), distributed (vertical splitting), and microservice (vertical division) architectures—detailing their components, advantages, drawbacks, and configuration examples such as Tomcat clustering with Nginx load balancing.
This article outlines a comprehensive knowledge framework for software architects, covering nineteen essential areas such as responsibilities, foundational concepts, internet system challenges, distributed caching, messaging, load balancing, performance testing, operating systems, algorithms, networking, database design, JVM internals, flash-sale systems, microservices, domain‑driven design, security, high‑availability, big data, and blockchain.
This article examines common misconceptions about software architecture, explains that its core purpose is to manage system complexity, offers practical guidance for identifying complexity hotspots, and presents a concrete university student‑management system case study to illustrate effective architectural decision‑making.
