This article explores engineering architecture design, emphasizing value‑first decision making, layered and DDD architectures, technology selection criteria, and best practices for consensus, exception, logging, and monitoring to build scalable, maintainable, and secure software systems.
This article explains the three major categories of design patterns—creational, structural, and behavioral—provides concise definitions, typical use‑cases, and clear Java code samples for each pattern so developers can write more maintainable and efficient software.
This article explains how integrating large language models into industrial configuration tools creates AI‑driven features such as knowledge Q&A, automatic application generation, smart drawing, script and material generation, and outlines the three‑layer architecture, prompt engineering, and implementation lessons for developers.
This article explains how Gaode's Information Business team tackled fragmented portal implementations across multiple industries by adopting the Gaode Business Framework (GBF) and domain‑driven design, achieving unified architecture, reduced duplication, improved reusability, and enhanced system stability and maintainability.
This article details how a rapidly expanding B2B fresh‑food company restructured its R&D organization, adopted a matrix management model, and built a comprehensive distributed infrastructure—including task scheduling, service discovery, messaging, logging, file storage, CDN, configuration, sharding, search, caching, and monitoring—to support nationwide warehouse operations and future growth.
This article provides a systematic, example‑driven guide to all 23 classic design patterns—covering creational, structural, and behavioral types—explaining their intent, real‑world analogies, benefits, and offering clear diagrams and runnable code snippets to illustrate each pattern in practice.
The article shares the author’s years of architecture experience at Alipay, arguing that growth into a true architect is a cognitive upgrade, explains what architectural ability really means, illustrates it with a multithreading interview example, and presents systematic thinking methods and practical steps for building architectural competence.
The article examines how applying the open‑closed principle and domain‑driven design in software architecture can lower programmers' cognitive load, streamline development, and enable cost‑effective, scalable evolution of complex systems, especially in fast‑iteration internet services.
This article outlines the definition, motivations, impact levels, planning, communication, layered design, gray‑release techniques, quality improvement measures, and observability considerations for large‑scale backend refactoring in microservice architectures, drawing on practical experience from Ctrip's end‑to‑end refactoring project.
This article explains the Object Factory design pattern, its benefits such as decoupling, extensibility, and centralized instance management, and demonstrates five practical Python examples covering basic product creation, configuration‑driven factories, logger factories, singleton factories, and object caching factories.
This article explains how to apply Domain‑Driven Design (DDD) to a new project, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models.
This article explains the concepts, advantages, disadvantages, and real-world use cases of four essential design patterns—Chain of Responsibility, Template Method, Publish‑Subscribe, and Strategy—providing detailed Java and Spring code examples to help developers apply them effectively.
This article explains how to apply Domain-Driven Design (DDD) from project inception, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models to achieve modular, maintainable systems.
This comprehensive guide clarifies the concept of software architecture, explores related notions such as systems, subsystems, modules, components, frameworks, and various architectural classifications, and outlines design goals, evolution paths, common pitfalls, and recommended reading for building effective, scalable, and maintainable systems.
The article examines the rapid rise of GPT models, their technical capabilities and limitations, and how their integration is reshaping software interaction from command‑line to GUI‑plus‑Language UI, offering frontend engineers new opportunities, practical examples, and guidance on leveraging large‑model AI in product design.
This article explains what architect‑to‑PM transformation means, outlines its characteristic signs and harmful impacts on projects, organizations, and individuals, and offers practical organizational, personal, and cultural measures—including automation pipelines—to keep architects focused on real technical work.
This article analyses the relationship between design patterns, architectural patterns and programming paradigms, explains core concepts and principles, provides extensive examples in Java and Python, presents common pattern catalogs, and offers practical implementation guidelines and case studies for software developers.
The article explains what constitutes a complex system, defines software architecture, outlines its essential elements, categorizes various architecture types, discusses key factors such as functional and non‑functional requirements, and presents design principles and typical solutions for building robust, scalable systems.
This article explains what complex systems and software architecture are, outlines various architectural categories, discusses essential functional and non‑functional requirements, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, DevOps, and big‑data architectures for building stable, scalable, and maintainable systems.
The article explores how an architect’s cognitive upgrade—through systematic thinking, model-driven analysis, and practical design methods—drives effective system architecture, business modeling, and trade‑off decisions, illustrated by a multithreading interview example and a suite of methodological tools.
This article outlines four foundational design principles—user‑intent‑driven design, context awareness, atomic capability mapping, and language‑API integration—for building LLM‑centric software architectures, illustrating each with DSL examples, Kotlin implementations, and practical insights on prompt engineering, dynamic context layering, and API evolution.
This article explains what complex systems are, defines software architecture, explores its essence and classifications, outlines key architectural factors, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, and big‑data architectures.
The article explains what a software architect does, outlines four developmental stages—from entry to team collaboration—emphasizes continuous learning, and promotes the 2023 GIAC Global Internet Architecture Conference covering topics like AIGC, cloud native, and digital transformation.
The article explains why clear application layering—covering controller, service, manager, and DAO levels—is essential for maintainable backend code, reviews Alibaba's recommended layer structure, proposes an optimized layering model, and discusses domain model conversions to avoid excessive object transformations.
The article reviews Scott's presentation on Lexical, the next‑generation Elixir language server, explaining the Language Server Protocol, Lexical's dual‑node architecture, modular design for easy contribution, and upcoming development plans, while inviting the community to explore the video replay and contribute.
This article describes how Qunar's technology center defined, measured, and managed system complexity through a custom modeling framework, implemented a dashboard for continuous monitoring, and established an anti‑corruption governance process that limits complexity growth to maintain low maintenance costs across hundreds of applications and systems.
This article explains why design documents need readability, outlines the three essential writing elements—clarity, conciseness, elegance—presents four key design principles such as trade‑offs, the importance of “why” over “how”, time considerations, and avoiding over‑design, and concludes with a brief promotion for a continuous deployment course.
The article explains Java’s Chain of Responsibility pattern, describing how abstract and concrete handler classes form a linked chain that passes a request until one processes it, outlines the steps to implement and assemble the chain, and discusses its benefits, drawbacks, and typical applications such as approval workflows and filter pipelines.
This article describes the challenges of migrating a long‑running monolithic database to a sharded architecture, presents a two‑stage smooth migration strategy using double‑write, diff verification, and mapping‑key techniques, and details the componentized design, core implementation, and configuration of a reusable sharding framework built on MyBatis and Spring.
This article explains the Chain of Responsibility design pattern, shows why naïve nested if‑statements are problematic, demonstrates a step‑by‑step refactor using linked handlers, introduces an abstract handler hierarchy, and finally presents a factory‑based dynamic configuration for scalable request processing in Java.
This article chronicles Nubank’s architectural evolution—detailing how strategic technology choices, cloud‑native platforms, micro‑service design, and data‑engineering practices were leveraged across startup, growth, consolidation, and expansion phases to achieve massive scalability and business agility.
The article defines software architecture as a business‑driven abstraction of system structure, explains core design principles such as SOLID, Ockham’s Razor, DRY, YAGNI, KISS and POLA, illustrates LSP violations, surveys layered, hexagonal, onion and DDD styles, and shows how applying Dependency Inversion in a large C++ codebase yields a simple, maintainable, business‑aligned architecture.
This article describes JD Supply Chain's self‑developed low‑code rule engine platform, outlining its motivation, high‑concurrency performance challenges, value‑centric design, visual rule‑authoring workflow, SDK integration, and the resulting efficiency gains for both development and business teams.
This article explains the concept of software architecture, distinguishes it from frameworks, outlines its components, design objectives, classification methods such as RUP 4+1 and TOGAF, evolution from monoliths to micro‑services, evaluation criteria, typical misconceptions, and recommends essential reading for architects.
This article explains why architecture design, especially Domain‑Driven Design, is essential for controlling the complexity, cost, and scalability of microservice systems, detailing common misconceptions, sources of complexity, and concrete steps to define clear domain and service boundaries.
This article explains what a complex system is, defines software architecture, explores its essence and classifications, and outlines the key factors, analysis methods, design principles, and typical solution patterns such as DDD, micro‑services, cloud‑native, DevOps, and big‑data architectures.
This article explains why design patterns, while useful for improving code quality and reusability, can lead to over‑design, describes common forms of over‑design, and offers practical guidelines to avoid excessive abstraction in software projects.
The article examines Google’s single‑repository (monorepo) strategy, detailing its technical benefits such as unified version control, code sharing, and atomic changes, while also analyzing the substantial tooling, infrastructure, and maintenance costs, and discussing why alternatives like Git are not adopted.
The article explains that building evolvable software systems—using strategies like microservices and event‑driven architecture—allows teams to adapt to changing workloads and business growth, illustrated with real‑world examples from Amazon, Prime Video, and S3, while emphasizing that no single architectural pattern fits all scenarios.
This article revisits Inversion of Control and SOLID design principles within the JavaScript ecosystem, explains their practical application using InversifyJS, demonstrates a full‑stack example in the Theia IDE framework, and discusses the benefits, challenges, and best‑practice considerations of adopting IOC in modern web projects.
This article explains the concept of enterprise architecture by likening an organization to a massive software system, discusses its importance in digital transformation, outlines its meta‑model and view layers, and highlights why a structured architectural approach is essential for modern enterprises.
This article explores the relationship between design patterns and programming languages, explains various programming paradigms, compares design patterns with architectural patterns, outlines key design principles, and provides extensive Java code examples illustrating factory, strategy, template method, builder, proxy, chain of responsibility, and command patterns in practice.
The article defines pipeline domain design concepts, compares major multimedia frameworks such as FFmpeg, GStreamer, MediaPipe and AVPipeline, and demonstrates a configurable, extensible node‑based architecture that enables fast plugin integration and adaptable audio‑video pipelines across diverse business scenarios and platforms.
The article explains the emerging concept of sustainable or continuous software architecture, outlines six guiding principles, compares it with traditional methods, and describes how it integrates with agile, DevOps, and product‑centric thinking to deliver resilient, adaptable systems over the long term.
The article presents a component‑based integration framework that abstracts partner‑specific data mapping, signature creation, call execution, and response parsing into reusable modules, enabling companies to standardize interfaces, eliminate custom development for most partners, cut integration costs by 86 % and pave the way for a hot‑swappable orchestration platform.
The article explains why layered architectures such as Clean, Onion, and Hexagonal are essential for reducing coupling and improving maintainability, introduces the COLA (Clean Object‑oriented and Layered Architecture) derived from them, and presents a concrete Go project scaffold with clearly defined Domain, Application, Infrastructure, and Adapter layers and recommended directory layout.
The article shares a senior engineer’s reflections on technical architecture at Alibaba, covering top‑level design, physical and application architecture, the evolving role of architects, essential problem‑solving skills, the need for a global perspective, broad technical breadth, continuous learning, and how these insights shape effective R&D management.
This article outlines 24 key DevOps capabilities—covering continuous delivery, loosely‑coupled architecture, product feedback, value‑stream visibility, small‑batch work, lean management, monitoring, and cultural practices—derived from the Accelerate research to improve software delivery performance.
Bilibili’s unified event‑tracking platform now manages over 120,000 definitions and ingests billions of daily events, guiding product, operation and marketing decisions through a full‑lifecycle framework—design, collection, testing, storage, and analysis—while leveraging a Spmid naming scheme, protobuf models, ClickHouse for sub‑second queries, and visual dashboards, with future plans for dynamic TTL, automated DWD tables, and deeper AB‑testing integration.
Continuous testing, performance testing fences, acceptance test nets, and ArchUnit dependency checks are presented as practical strategies to prevent software and architecture decay, illustrated with real project experiences, CI/CD integration, and code examples for robust quality assurance.
This article explains the purpose and classification of software architecture diagrams, introduces the 4+1 and C4 view models, describes business, application, technical, and data architectures, and provides practical guidance on drawing clear, audience‑focused diagrams that accurately reflect system design.
This article explains why design patterns are needed, introduces the Factory Method pattern with its UML roles, provides a step‑by‑step Go implementation—including interfaces, concrete factories, and client code—covers a clothing‑brand example, and discusses the pattern's advantages and drawbacks while also noting its source from a Go design‑patterns book.
This article explains the definition and essence of software architecture, outlines its layers and classifications, describes architectural levels and the evolution from monolithic to micro‑service designs, and discusses how to evaluate architectural rationality while highlighting typical misconceptions and best‑practice guidelines.
The article explains ten key non‑functional quality attributes of software architecture—such as scalability, availability, consistency, resilience, usability, observability, security, persistence, agility, and maintainability—describing their meanings, typical implementation techniques, and why selecting the right attributes is crucial for any system.
This article revisits the concepts of Inversion of Control and SOLID design principles within the JavaScript ecosystem, explains how InversifyJS implements IoC with TypeScript decorators, demonstrates practical steps to configure containers and bindings, and shows how Theia leverages these techniques for modular front‑end and back‑end architecture, while also discussing the benefits and limitations of IoC in modern web development.
The article emphasizes that in the fast‑changing IT field, software engineers must continuously learn and adopt continuous architecture principles—guided by product thinking, quality attributes, and agile practices—to stay relevant, solve problems effectively, and sustain long‑term value creation.
This article explains why and how to decompose large or legacy applications into microservices using business‑capability and sub‑domain (DDD) approaches, outlines their benefits, discusses common challenges such as latency and data consistency, and introduces the Strangler pattern for gradual migration.
This article explores what a software architect does, the different levels of architecture, essential daily activities, key skills such as design, decision‑making, communication, estimation, and marketing, and offers practical advice on continuous learning, documentation, and influencing stakeholders.
This article explains the fundamentals of Domain‑Driven Design, distinguishes strategic from tactical design, outlines core DDD elements such as domains, aggregates and bounded contexts, and demonstrates how four‑color modeling can be applied to real‑world e‑commerce microservice architectures.
The article explains how built‑in quality, a core principle of SAFe and lean‑agile thinking, integrates quality into architecture, design, code, system testing, and release processes to enable fast, reliable delivery of software and hardware solutions while reducing rework and compliance risk.
This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.
The article shares a chief architect's experience on combining a large‑scale waterfall approach with agile iterations, detailing microservice and BFF design, team organization aligned with Conway's law, and practical application‑boundary principles for a distributed enterprise system.
This article compiles practical Java code examples for common design patterns—including Simple Factory, Factory Method, Abstract Factory, Singleton (eager, lazy, static inner class, enum, container), Proxy, Decorator, Prototype, Strategy, Observer, and Adapter—each linked to detailed tutorials.
This article provides a comprehensive guide to software architecture, detailing the three architecture levels, daily activities, ten essential skills, decision‑making techniques, communication strategies, documentation practices, and ways to balance quality, cost, and time while fostering continuous learning and community involvement.
The article argues that only companies with annual revenues exceeding $2 billion truly need microservices, explains the evolution from monoliths to microservices, outlines their key characteristics and trade‑offs, and offers a step‑by‑step framework for aligning architecture with business growth while minimizing complexity.
The article examines why software development, despite modern tooling, still behaves like a handicraft that collapses under scale, explains essential versus accidental complexity, illustrates common sources of random complexity with real cases, and proposes a three‑step strategy—rescue, cure, and maintenance—to control growth.
This article outlines the role of a software architect, describing the different architectural levels, daily activities, essential skills such as design, decision‑making, communication, documentation, estimation, and how to balance technical and non‑technical responsibilities for effective system design.
This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.
This article describes the progressive evolution of a consumer‑finance risk decision engine—from an initial rule‑set implementation, through a Drools‑based configuration, to a fully self‑developed micro‑service engine—detailing architectural changes, component designs, execution flow, operational challenges, and solutions such as empty‑run testing.
This article explains what a software architect does, outlines the three architectural levels (application, solution, enterprise), describes the architect’s daily responsibilities, and details ten essential skills—including design, decision‑making, simplification, programming, documentation, communication, estimation, balancing, consulting, and market awareness—required for a successful career in software architecture.
This comprehensive guide explains what a software architect does, defines the role and its hierarchical levels, outlines daily responsibilities, and details ten essential skills—including design, decision‑making, simplification, programming, and documentation—to help engineers advance toward senior architectural positions.
The article explains what cross‑functional (non‑functional) requirements are, illustrates common scenarios where they cause system failures, outlines the perspectives of different teams in identifying them, and advises Tech Leads on how to proactively address these requirements while noting an upcoming DevOps hackathon.
This article explains the concept of software architecture, why architectural styles are chosen, compares monolithic and distributed architectures, analyzes their pros and cons, and walks through a real‑world inventory system migration from a single‑service design to a micro‑service, CQRS‑based distributed solution with code examples and discussion of distributed transactions.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, the evolution of architecture layers, bounded context concepts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures.
The article reflects on Elon Musk’s criticism of microservices, argues that the architecture is often over‑hyped and misapplied, compares it with monolithic and other service granularity models, and warns that blind adoption driven by trends can lead to costly technical debt.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution from monolith to microservices, bounded context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical design guidelines for backend systems.
The article argues that complexity in software systems cannot be eliminated but only shifted, emphasizing the inevitability of leaks, the limits of local consequence, and the practical value of layering and eliminating duplication to make frequent changes easier and code more understandable.
This article explains the concept of software architecture, compares monolithic and distributed styles, discusses their advantages and drawbacks, and details a real-world inventory system migration from a monolithic design to a distributed architecture using functional and business decomposition, CQRS, and code refactoring.
The article explains how the delegation pattern—combining a fixed core processing path with extensible open interfaces—underpins Java toolkits such as SLF4J, JDBC, and Dubbo, illustrating its implementation steps, when to apply it, and pitfalls like reverse delegation loops.
This article critically examines the microservices movement, tracing its historical roots, debunking common hype, and arguing that the true value lies in modular design, clear team ownership, and disciplined architectural practices rather than merely scaling distributed systems.
This article summarizes key insights from the book “Continuous Delivery 2.0”, covering the double‑loop model, organizational culture principles, practical team processes, software architecture guidelines, requirement collaboration, deployment pipelines, branch strategy, configuration management, low‑risk releases, and real‑world case studies.
This article examines the common perceived benefits of microservices, shows how many of them can be achieved with a well‑designed monolith, and provides concrete criteria and tactics for small, medium, and large teams to decide which architecture best fits their context.
This article provides a detailed introduction to software architecture, covering its definition, essential concepts such as systems, subsystems, modules, components, and frameworks, various architectural layers and classifications, evolution from monolithic to micro‑service designs, common pitfalls, evaluation criteria, and recommended learning resources.
This article explains the SOLID principles, various UML relationship types, and provides detailed descriptions of 22 classic design patterns, illustrating their intents, applicability, and implementation considerations for building clean, maintainable software architectures.
This article explains why midsize tech teams often struggle with outdated infrastructure, outlines a ROI‑driven planning framework, presents real‑world case studies of single‑point breakthroughs and team mergers, and offers a step‑by‑step methodology for systematic technology upgrades and sustainable growth.
This article explains the distinct responsibilities and focus areas of software architects, enterprise architects, solution architects, and technical architects, highlighting how each role contributes to design standards, technology strategy, and project delivery within an organization.
This article presents a concise overview of twenty core software architecture principles—from Dependency Inversion and Separation of Concerns to KISS and Incremental Development—explaining each concept, its purpose, and providing Java code examples to illustrate practical application.
This article presents a comprehensive overview of essential software architecture principles—including Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, SOLID rules, and more—explaining their purpose, practical impact, and providing Java code examples to illustrate their application in real projects.
This article explains the Decorator Pattern—a design pattern that lets developers extend object behavior without modifying existing code—by describing its core components, showing a generic UML diagram, and providing three detailed Java case studies covering task processing, file I/O, and logging systems.
Software design is a systematic process that defines specifications, architectures, and components to solve problems, covering concepts such as abstraction, modularity, design principles, modeling languages, and considerations like scalability, maintainability, and security, providing a comprehensive overview of essential design practices and patterns.
This article explains the Decorator design pattern, presents its UML structure, describes the roles of abstract components, concrete components, and decorators, and demonstrates three practical Java scenarios—task processing, file I/O, and logging—showing how to extend functionality without modifying existing classes.
This article outlines the evolution of software architecture styles, explains how different perspectives define architecture styles, and presents a comprehensive table of architecture domains and sub‑domains ranging from web and mobile applications to integration, data, analytics, and BI architectures.
The article argues that complexity is an unavoidable aspect of software development that cannot be eliminated, only managed or transferred, and discusses how design choices, build‑tool trade‑offs, and knowledge models influence the way engineers cope with inevitable complexity.
This article explains how introducing factories in Domain‑Driven Design with Go separates object creation logic from domain responsibilities, hides implementation details, enforces invariants, and improves validation, while showing practical code patterns and design‑pattern choices for simple and complex domain objects.
The article argues that engineers should focus on thoroughly discussing and understanding the underlying business problem before jumping to favored technical solutions, illustrating this with real‑world anecdotes about solution‑architect roles, .env file debates, micro‑service hype, and the Five Whys technique.
This article outlines the essential requirements for empowering autonomous teams, details the challenges of transitioning and splitting monolithic systems into microservices—including organizational, technical, and cultural hurdles—and presents comprehensive best‑practice recommendations for platform design, service development, deployment, operations, and team management.
This article explains how Aspect‑Oriented Programming (AOP) was introduced into a data construction platform to address high development effort, strong business coupling, and maintenance difficulty by isolating cross‑cutting concerns such as logging, thereby improving modularity, development speed, and code maintainability.
This article systematically explores the challenges of microservice service splitting—from technical choices and architectural reliability to business model validation and team collaboration—offering static and dynamic solutions, design principles, and practical guidelines for effective service decomposition.
This article presents a concise overview of 23 essential software architecture principles—from Dependency Inversion and Separation of Concerns to Bounded Context and KISS—explaining each concept, its practical impact, and providing code examples to help developers design clean, maintainable systems.
This article outlines core software architecture principles such as Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, Single Responsibility, DRY, Open‑Closed, Persistence Ignorance, and many others, and illustrates them with Java code examples for actions and converters.
