This article examines how adopting software frameworks—especially web frameworks—can undermine long‑term maintainability through control inversion, mismatched goals, design trade‑offs, and hidden costs, while also showing how a decoupled approach can retain benefits without the drawbacks.
This article explains what a software architect does, outlines the three levels of architecture, lists daily activities and ten essential skills—including design, decision‑making, communication, documentation, estimation, and marketing—while offering practical advice on design patterns, quality metrics, technology experimentation, documentation automation, conflict resolution, and influencing stakeholders.
This article explains the Adapter Pattern, its core roles, and demonstrates three practical applications—object adapter for document formats, class adapter for component replacement, and interface adapter for large interfaces—complete with Java code examples and key takeaways.
This article outlines the evolving trends in terminal devices and software architecture, argues for unified cross‑platform containers, proposes a streamlined organizational model with fewer, more versatile roles, and introduces the KUN project—a high‑performance, extensible Flutter‑based rendering engine aimed at boosting mobile development efficiency.
This article explains the purpose and classification of software architecture diagrams, introduces the 4+1 view model and the C4 model, and provides practical guidance on choosing the right view for different audiences to produce clear, self‑describing architectural drawings.
This guide explains how to create clear, self‑describing system architecture diagrams by defining architecture concepts, outlining business, application, technical and data layers, and detailing the 4+1 and C4 view models with practical tips for audience‑focused visual communication.
The article explains why a progressive, incremental approach to business architecture—balancing clear primary requirements with flexible handling of secondary and emergent features—helps large‑scale website projects avoid the pitfalls of rigid waterfall planning and enables smoother versioned development.
The article reflects on a visit to BMW’s Leipzig factory, using its just‑in‑time, modular production line as a lens to critique traditional software delivery models and to propose a lean, network‑oriented value‑stream approach for modern product‑focused development.
This article explains what software architecture is, why choosing an architectural style matters, compares monolithic and distributed approaches using a real‑world inventory system case study, and details the step‑by‑step functional and business splitting, CQRS implementation, code refactoring, and handling of distributed transactions.
This article examines common pitfalls in application layering, outlines Alibaba's recommended multi‑layer architecture, proposes an optimized layering approach with clear responsibilities for controllers, services, managers, and DAOs, and discusses domain model conversions to improve maintainability and team collaboration.
The article examines the common belief that reuse improves productivity, explains the logical fallacies behind it, highlights the hidden costs of over‑generalization, and proposes autonomy and consistency metrics as practical guidelines for evaluating when reuse truly adds value.
This article explains the responsibilities, required skills, and career advice for software architects, covering job duties, real‑world examples, essential technical and soft‑skill preparation, and practical tips for advancing toward and succeeding in an architecture role.
The article introduces eight widely used software architecture design patterns—including single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑data‑center modes—explaining their structures, typical use cases, and the pros and cons of each.
This article shares practical experiences and concepts about software architecture, covering stakeholder‑driven definitions, non‑functional requirements, iterative evolution, closed‑loop feedback, microservice adoption, organizational impact, and the soft skills needed for effective architects.
This article introduces eight core software architecture design patterns—including single‑database single‑app, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their structures, typical use cases, advantages, and drawbacks to help developers choose the right architecture for their systems.
This article explains the fundamental concepts of software architecture, distinguishing it from frameworks, defining system, subsystem, module, and component, outlining the four core aspects of architecture, and detailing the various layers such as business, application, data, code, technical, and deployment architectures.
The Strategy design pattern in Java encapsulates interchangeable algorithms behind a common interface, using concrete strategy classes and a context holder to delegate behavior at runtime, which enhances flexibility, adheres to the Open/Closed principle, reduces conditional complexity, though it may increase class count and require client awareness of available strategies.
This article explains the concept of software architecture, its essential nature, and the relationships among systems, subsystems, modules, components, frameworks, and various architectural layers such as business, application, data, code, technical, and deployment architectures.
This article provides a comprehensive overview of software architecture, defining core concepts such as system, subsystem, module, component, framework, and architecture itself, and detailing the various layers—including business, application, data, code, technical, and deployment architectures—along with their design principles and practical considerations.
This guide presents twelve practical steps—from understanding the trade‑offs and planning the transition to adopting monorepos, CI pipelines, API gateways, feature flags, and observability—that help teams safely decompose a large monolithic application into a robust microservices architecture.
This article outlines six key software architecture principles—reuse before build, cloud‑ready design, scalability, complexity reduction, API‑first approach, and frequent small releases—to help organizations make strategic technical decisions and avoid common pitfalls.
The article explains how applying clean separation, layered architecture, and the hexagonal ports‑and‑adapters pattern helps manage complexity, keep core domain logic isolated, and make software easier to change, test, and maintain.
This article outlines twelve practical steps—including planning, adopting a monorepo, setting up CI/CD pipelines, using API gateways, containerizing, feature flags, and adding observability—to help teams transition their large monolithic applications to a robust microservices architecture with minimal disruption.
This article outlines six key software architecture principles—including reuse before build, cloud‑first design, scalability, simplicity, API‑first strategy, and frequent small releases—to help teams create cost‑effective, maintainable, and future‑proof applications.
The article explains why Domain-Driven Design (DDD) is valuable for handling complex business logic, compares it with traditional transaction‑script approaches, introduces core DDD concepts such as ubiquitous language, bounded contexts, entities, value objects, aggregates, factories, repositories and domain services, and provides practical steps and examples for adopting DDD in backend development.
This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architectural classifications, and introduces classic patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design, extension, and specification guidelines.
This article explains the importance of clear software architecture diagrams, defines basic concepts and various diagram types such as context, container, component, and class diagrams, offers practical guidelines for creating self‑describing, audience‑focused diagrams, and shares tools and examples to improve communication among developers, ops, and stakeholders.
The article explains the Factory design pattern family—Simple Factory, Factory Method, and Abstract Factory—showing how each separates object creation from use, presents Java code and UML examples, and compares their advantages such as decoupling and Open/Closed compliance against drawbacks like increased complexity and class proliferation.
This article explains the importance of clear architecture diagrams, defines key concepts such as architecture and architecture diagrams, outlines the 4+1 view taxonomy, offers criteria for good diagrams, addresses common pitfalls, and introduces the C4 modeling approach with practical examples and tool recommendations.
The article maps a technical professional’s journey from engineer to architect and leader, urging deep mastery of code and business logic, proactive incident handling, defensive design, domain expertise, broad architectural thinking, and balanced leadership skills to achieve sustainable career growth.
After more than a year of effort, Uber migrated its entire experimentation and feature‑flag ecosystem—including thousands of developers, dozens of partners, multiple mobile apps, and hundreds of services—to a new, unified platform that improves reliability, flexibility, and data quality while retiring over 50,000 legacy experiments.
This article explains the Chain of Responsibility design pattern, illustrates it with a historical Three Kingdoms story, shows progressive refactorings from procedural code to abstract handlers in TypeScript, and demonstrates practical front‑end scenarios such as flexible location retrieval.
The article presents thirty concise architectural principles covering simplicity, iterative development, automation, ROI, user focus, concurrency, distributed system design, configuration management, and practical guidance, aiming to help architects and developers build maintainable, scalable, and user‑centric software systems.
This article explains the factory design pattern, covering simple factory, factory method, and abstract factory variants, their typical use cases such as document parsing and automated testing, and provides complete Java code examples illustrating each implementation.
This article explains eight core software architecture patterns—from single‑database single‑application to microservices, multi‑level caching, and multi‑datacenter deployments—detailing their designs, typical use cases, advantages, and drawbacks to help engineers choose the right approach for scalable, high‑performance systems.
This article explains how Meituan built a unified, highly available pipeline engine that supports nearly 100,000 daily executions across dozens of services with 99.99% success, detailing the challenges faced, the architectural decisions made, and the future roadmap for further scalability and cloud‑native improvements.
This extensive article discusses essential software engineering concepts such as code review value, architectural principles, SOLID, dependency inversion, documentation practices, testing strategies, and practical guidelines for writing maintainable, decoupled, and self‑explanatory code across various programming languages.
The article examines how design patterns serve as intermediate code conventions, discusses their performance impact, class‑explosion risk, team skill gaps, project environment, and agile constraints, and offers practical advice for balancing code quality with business realities.
This article walks through the progressive evolution of a software system—from a traditional monolithic architecture to a task‑oriented monolith, then to Command‑Query Separation (CQS) and finally to a full CQRS solution—explaining the motivations, trade‑offs, and techniques such as eventual consistency, event sourcing, and read‑model generation.
This article traces the evolution of software architecture from monolithic applications through vertical splitting and distributed services to modern microservices, outlines the key stages of microservice development, and presents a comprehensive technology stack—including communication protocols, API gateways, authentication, fault‑tolerance, logging, configuration, containerization, orchestration, and CI/CD tools—required to build robust backend systems.
The article predicts smartphones will dominate traffic for the next three years, argues that cross‑device frameworks like ReactNative, Weex and Flutter are essential, and proposes a streamlined R&D model at Xianyu with full‑stack mobile engineers and infrastructure engineers supported by a unified container, programming plane, workflow, and the high‑performance, W3C‑compliant KUN rendering engine to boost iteration speed, consistency, and talent efficiency.
This article translates Mahesh Balakrishnan’s 42 practical lessons on building a production database, covering customer focus, project management, design principles, code review, strategy, observability, and research, offering actionable guidance for infrastructure engineers and architects.
This article objectively explains Domain‑Driven Design, compares it with traditional data‑driven approaches, and details how DDD was applied in the architecture, strategic and tactical design, context integration, and business‑logic implementation of ZuanZuan's complex pricing system, including code examples.
This article explains the concept of software‑architecture tradeoffs, why they are inevitable, the key system attributes involved, and how architects can consciously balance scalability, simplicity, interoperability and other “‑ilities” to make informed design decisions.
By exploring popular open-source codebases such as Chromium, Electron, Flutter, React, and Go, developers can deepen their understanding of software architecture, DevOps practices, cross-platform development, and essential programming principles, turning code reading into a powerful self-learning strategy.
The article outlines twenty‑four essential capabilities—spanning continuous delivery, architecture, product and process, lean management, and culture—that research shows drive high performance in software delivery and organizational outcomes.
This article explains how Onion Architecture, built on Domain‑Driven Design principles, organizes software into concentric layers that isolate core business logic, improve maintainability, testability, and flexibility, and outlines its layers, dependencies, services, testing strategies, and applicability to microservices.
This article reviews the rapid growth of software scale and complexity, traces the evolution from monolithic to microservice architectures, and outlines the essential backend technologies—including service communication, API gateways, authentication, fault handling, logging, configuration, containers, orchestration, and CI/CD—that enable modern cloud‑native microservice systems.
This article explains the Chain of Responsibility design pattern in Java, illustrating its use for multi‑level approval workflows during high‑traffic events, provides step‑by‑step code implementations, refactors naive IF logic into modular link classes, and demonstrates testing, highlighting benefits for clean, extensible backend architecture.
The article explains how many microservice migrations end up as “distributed monoliths,” detailing why splitting a monolith without proper domain design and protective mechanisms can worsen stability, increase latency, and fail to deliver the promised efficiency gains.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, and disadvantages for building scalable, high-performance systems.
Shopee’s Merchant Services team created a visual, configurable onboarding platform that abstracts purchase flows into reusable templates and six modular configuration sections, moving product‑launch responsibilities from developers to operators, cutting code changes, boosting launch efficiency by about 75 % and adding import/export and validation tools.
The article examines the typical traits of massive legacy codebases, outlines the technical debt they generate, and proposes practical strategies—from design‑pattern mastery and daily code reviews for small teams to metrics‑driven debt tracking, agile practices, and clean‑architecture principles for million‑line and ten‑million‑line systems—aimed at safely evolving such systems while maintaining team stability.
This article explains why clear architecture diagrams are essential for communication, outlines common pitfalls, defines architecture and its diagram types, introduces the 4+1 view classification and the C4 modeling approach, and provides practical guidance and examples for producing self‑describing, audience‑focused diagrams.
The article explains the importance of measuring software architecture, outlines the granularity of metrics from code to infrastructure, and provides concrete measurement indicators for code implementation, component design, architecture design, and runtime infrastructure to guide effective architecture governance.
This article chronicles the step‑by‑step evolution of a workflow engine, detailing how simple sequential approvers were expanded into hierarchical trees supporting parallel, multi‑sign, conditional, proxy, and scripted nodes, while introducing state management, rejection handling, and progress metrics.
This article explains the Chain of Responsibility design pattern, its use cases, and demonstrates step‑by‑step refactoring in Java—from a verbose conditional example to a clean, extensible handler chain, including abstract handlers, concrete handlers, and a factory‑based configuration.
This article explains how to keep software architecture simple and appropriate by applying KISS principles, balancing completeness, flexibility, and lightness, outlines when pre‑design is sufficient or excessive, presents core design principles such as SOLID, N+1, statelessness, and details a six‑step C4‑based design and review process.
This article explains the Observer design pattern, outlines its advantages and drawbacks, and demonstrates practical implementations through three real‑world scenarios—weather forecasting, payment processing, and data subscription—providing complete Java and PHP code samples that illustrate subjects, observers, and notification mechanisms.
This article explains the basic concepts of software modeling, the role of UML diagrams, and how to organize those models into a coherent software design document that guides architects, developers, testers, and stakeholders throughout the development lifecycle.
This article uses humorous everyday scenarios to illustrate 21 classic software design patterns, explaining each pattern's intent, structure, advantages, and drawbacks, helping readers grasp abstract concepts through relatable analogies.
This article explores the practical challenges of using MVC and related architectural patterns, compares implementations from Microsoft, Apple, and industry experts, discusses controller bloat and view‑model relationships, and proposes solutions such as view‑to‑model factories, multi‑controller designs, and MVVM adoption to improve testability and maintainability.
This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, alongside tactical guidelines for high concurrency, high availability, and business design, and illustrates the concepts with logical and physical architecture diagrams.
This article explains the purpose and benefits of software architecture diagrams, introduces basic concepts and the 4+1 view classification, describes what makes a good diagram, outlines common pitfalls, and presents the C4 modeling approach with practical examples for clear communication among stakeholders.
This article explains the purpose and definition of software architecture diagrams, introduces the 4+1 view classification and the C4 model (system context, container, component, and code diagrams), discusses common pitfalls, and provides practical guidance and tool recommendations for producing self‑describing, audience‑focused architecture visuals.
In a Stack Overflow Podcast interview, former GitHub CTO Jason Warner recounts his unconventional path from a Connecticut farm to leading massive platform scaling, shares insights on engineering leadership, product strategy, venture investing, and the future of cloud, data, and blockchain technologies.
This article introduces the concept of software architectural patterns, explains why they are essential, and details five popular patterns—layered, microkernel, event‑driven, microservices, and space‑based—along with guidance on when and where to apply each.
The article details how NetEase Yanxuan applied Domain‑Driven Design to reconstruct its Product Center middle‑platform, using strategic and tactical design, COLA layered architecture, and an event‑driven mechanism to eliminate duplicated logic and heavy coupling, cutting code volume by roughly two‑thirds while addressing entity scope, model richness, and microservice granularity challenges.
This article explains the Chain of Responsibility design pattern, illustrates common misuse with a multi‑if game‑level example, and then shows step‑by‑step refactorings—including linked handlers, an abstract base class, a factory and enum‑based configuration—to produce clean, extensible Java code.
This article introduces ten common software architecture patterns—layered, client‑server, master‑slave, pipe‑filter, proxy, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical use cases, and advantages to help developers choose suitable designs for large‑scale systems.
This article explains the evolution of programming—from machine code, assembly, and high‑level languages—to the software crises that led to structured programming, object‑oriented design, and ultimately the emergence of software architecture as a solution for managing system complexity.
This article traces the evolution of software development—from machine language and assembly to high‑level languages—explores the two software crises, explains why software architecture emerged, and clarifies core concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises and their solutions, defines system, subsystem, module, component, framework and architecture, and concludes that software architecture is a strategic response to system complexity requiring careful judgment and trade‑offs.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, disadvantages, and practical considerations for building scalable, reliable systems.
This article explains eight widely used software architecture design patterns—including single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, database sharding, elastic scaling, and multi‑data‑center—detailing their typical scenarios, advantages, and disadvantages for backend developers.
The article introduces eight widely used software architecture design patterns—including single‑database, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their typical structures, suitable scenarios, and the key pros and cons of each.
This article explains how to design clear, consistent API return codes and messages by referencing HTTP status codes, defining code‑message pairs, supporting personalized messages for different clients, and using unified handling for monitoring and alerting, ultimately improving communication and maintenance costs.
This article explains the Decorator design pattern, contrasting it with inheritance, and shows how to dynamically extend Java classes—especially I/O streams—using composition, complete with code examples, class diagrams, advantages, drawbacks, and practical usage scenarios.
In this interview, Meituan Selection architect Xu Po shares his 14‑year journey, explains how logistics architecture balances process and result quality, outlines the four pillars for successful architecture implementation, discusses the core value of architects, team organization models, essential skills, and the role of domain‑driven design.
This article shares the author’s experience and reflections on software architecture, covering its definition, iterative evolution, closed‑loop feedback design, microservice adoption, the impact of organizational culture, and the mindset and soft skills required of modern architects.
The article analyses low‑code platforms by defining low‑code as visual programming, contrasting declarative and imperative approaches, examining front‑end and back‑end implementation schemes, interaction models, storage options, workflow engines, and future trends, ultimately showing that declarative foundations drive both strengths and limitations.
The Singleton design pattern guarantees a single, globally accessible instance, reducing memory overhead and global variables, with eager (init) and lazy (sync.Once) thread‑safe implementations in Go, and practical uses such as configuration management in Python, shared DB connections in PHP, and UI components like toasts in JavaScript.
This article explains the differences and similarities between the Factory and Strategy design patterns in Java, provides complete code examples, compares their execution results, and discusses how Strategy can resemble micro‑service composition while reducing code redundancy.
This article details a year‑and‑a‑half of boundary‑governance work on a supplier platform, explaining why fragmented responsibilities hurt efficiency, how the team expressed, identified, and solved boundary issues through clear domain definitions, unified language, and staged migration, and the measurable improvements achieved.
The article explains that becoming a software architect requires more than years of experience—it demands a blend of deep technical expertise, strong business insight, and effective management skills to build a personal moat and avoid being left behind as the industry evolves.
This article compares Java's Factory and Strategy design patterns, explaining their concepts, showing UML diagrams, providing complete code examples, and demonstrating how each pattern affects code structure, flexibility, and maintainability, while drawing parallels to micro‑service architecture.
This article explains how to design robust technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams for real‑world systems.
The article reflects on a dozen years of software development experience to propose three evolving definitions of a software architect, classify various architect roles, and compare centralized versus collaborative work styles, highlighting why the term is often misused in the industry.
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—using everyday relationship scenarios to make each pattern’s intent and structure easy to grasp.
This article examines the evolution of cross‑platform frontend technologies, outlines key criteria for selecting a solution, compares major approaches such as WebView, native rendering, and self‑rendering, and presents a practical low‑code, Flutter‑based implementation that delivers fast, consistent multi‑device applications.
This article presents thirty practical software‑architecture principles—from keeping designs simple and avoiding unnecessary features to mastering concurrency, distributed systems, and user experience—providing a comprehensive guide that helps architects make informed, ROI‑driven decisions while fostering scalable, maintainable solutions.
The article reflects on a dozen years of software development experience to propose three evolving definitions of a software architect, examines why the term is often misused, categorises different architect types, and compares centralized versus connective work styles for effective R&D management.
This article explains common misconceptions about application layering, outlines essential principles for maintainable layers, details Alibaba's multi‑layer architecture, proposes optimized layering with service and manager responsibilities, discusses domain model conversions, and concludes with practical guidance for clear, reusable backend design.
This article examines the concept of business architecture, its origins in TOGAF, and presents a detailed case study of Qunar’s activity capability layer design, highlighting pain points, architectural solutions, and a step-by-step methodology for building robust, reusable activity systems.
During the Chinese New Year, the author reflects on the declining state of Chinese football and draws parallels to large‑scale digital transformation projects, exploring how component‑based, cloud‑native architecture and domain‑driven design can address the complexities of enterprise business systems, improve modularity, and enable rapid, resilient evolution.
This article explains what microservices are, how they differ from traditional monolithic apps, illustrates their benefits and drawbacks with an Amazon product‑page example, describes containers and Docker, and shows why Kubernetes is a natural platform for managing microservice‑based systems.
This article presents thirty concise architectural principles covering simplicity, YAGNI, iterative development, testing, ROI, user focus, modular design, configuration, server concurrency, distributed system challenges, and user experience, offering practical guidance for engineers to build scalable, maintainable software systems.
This article reviews key concepts from the book "Software Architecture with Patterns" and discusses how architectural patterns such as layered architecture, microkernel, and GoF design patterns can guide the decomposition of monolithic applications and improve the extensibility of complex systems.
The article critiques traditional software architects as bottlenecks, shares personal experiences at eBay and Alibaba, argues that dedicated architecture departments often cause more harm than good, and advocates that every engineer develop architectural thinking, offering guidance for engineers, team leads, and CTOs.
This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, detailing strategic and tactical patterns, bounded contexts, domain events, and the translation of domain models into microservice architectures, while highlighting the benefits of clear communication and modular design.
