This article explains why a custom lightweight workflow engine was built, outlines its micro‑kernel architecture, demonstrates incremental development from a Hello‑World example to a simple approval process with branching, and discusses future enhancements such as exception handling, persistence, and dynamic graph modification.
This article explains what system (software) architecture is, why it is crucial for handling software complexity, invisibility, changeability and conformity, and reviews common architectural patterns such as client‑server, peer‑to‑peer, MVC, layered, distributed‑cluster, micro‑service, event‑source, and hexagonal designs.
The Bidding Team’s DDD layered architecture consolidates all traffic in an Interfaces layer, uses a thin Application service layer to orchestrate use‑cases, places core business rules in Domain aggregates, isolates data access in Infrastructure, adds an Anti‑Corruption adapter, and employs DTOs, entities, and domain events for decoupled, consistent processing.
The article warns that using the vague term “user” in software design creates security flaws and conceptual confusion, illustrated with ticket‑booking, Unix, and SaaS examples, and advises defining precise concepts like “team” and “member” early to avoid costly redesigns.
The article defines componentization (shared JAR) and serviceization (independent service), compares their performance, cost, maintainability, and resource trade‑offs, outlines ideal use‑cases such as high‑throughput, no‑DB calls versus DB‑access or lower‑concurrency needs, and provides Vivo case studies to guide selection.
This article reviews Domain‑Driven Design and layered architecture fundamentals, then explains three classic DDD layered patterns—four‑layer, five‑layer, and hexagonal architectures—detailing their layers, responsibilities, advantages, drawbacks, and practical adaptations for microservice development.
This article humorously explains 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 playful dating scenarios to illustrate each pattern’s intent, structure, and trade‑offs.
Effective naming is a critical yet often overlooked aspect of software development that boosts code readability, facilitates communication, reduces cognitive load, and even influences design decisions, as illustrated by real-world examples from Alibaba to POJO, along with practical guidelines for variables, functions, classes, packages, and modules.
The article chronicles the evolution of Coco's layered architecture, detailing the shift from a monolithic Clean‑Architecture‑inspired design to a modular, plugin‑driven structure, and discusses the trade‑offs of infrastructure layering, code reuse, and future adaptability.
This article explains how abstract thinking underpins software engineering, covering definitions, the relationship between language and abstraction, levels of abstraction, layered design, the pitfalls of duplicate code and forced casts, and practical ways to strengthen one’s abstract reasoning skills.
This article provides an in‑depth exploration of programming paradigms—structured, object‑oriented, and functional—tracing their historical evolution, core design concepts, advantages, drawbacks, and how they interrelate within modern software architecture and design principles.
This article explains how Domain‑Driven Design complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and improving scalability, while also discussing microservice drawbacks and practical guidelines for splitting complex systems in modern applications.
This guide explains the most frequent code smells—Long Method, Large Class, Duplicated Code, Long Parameter List, Shotgun Surgery, Speculative Generality, and excessive comments—detailing why they harm readability and maintainability, and provides concrete refactoring techniques with Java examples to produce cleaner, more modular software.
The article discusses three approaches to binding experimental components, critiques their limitations, and proposes a reusable slot‑card model implemented in TypeScript, complete with base classes, Card, Slot, and Engine code to manage assembly and updates.
The article explores why building truly reusable components is challenging by comparing a concise functional F# implementation of FizzBuzz with a more verbose object‑oriented C# version, highlighting how language paradigms and design assumptions affect modularity, coupling, and extensibility.
This article explains why software design documents are essential, outlines the key sections they should contain, offers concrete writing tips, and provides a step‑by‑step process for creating, reviewing, and iterating on design specs to improve project outcomes and reduce risk.
This article presents a comprehensive overview of essential programming principles—including KISS, YAGNI, separation of concerns, DRY, SOLID, inversion of control, and the scout rule—explaining why each matters and offering practical guidance on how to apply them to write clean, maintainable software.
The article explains that while a Service layer may seem unnecessary for simple business logic, it becomes essential as applications grow, offering benefits such as handling complex operations, supporting reuse across controllers, facilitating unit testing, and enabling flexible business logic composition.
The article explains how to design a monolithic Java application with clear business boundaries, modular code organization, MVC layering, and disciplined controller logic so that it can be smoothly refactored into a micro‑service architecture, illustrating the approach with directory trees, package schemes, and sample CommonResult code.
This article compiles core programming principles such as KISS, YAGNI, Separation of Concerns, DRY, Inversion of Control and the SOLID rules, explaining why each matters, how to apply them, and providing reference links for deeper study.
This article explains the concept of refactoring, its motivations and timing, enumerates common code smells, and provides detailed refactoring techniques—including extracting methods, moving functions, encapsulating data, simplifying conditionals, and handling inheritance—to improve software design and maintainability.
This article compiles practical code‑review guidelines, well‑known architecture principles, and personal engineering habits—covering self‑explaining code, DRY, dependency inversion, error handling, testing strategies, and common pitfalls—to help developers write maintainable, high‑quality software.
The article presents a comprehensive guide on why developers and leaders must perform code reviews, identifies common pitfalls such as duplicated code, premature optimization and over‑engineered OOP, and offers concrete principles, model‑design advice, and Golang examples to improve code quality and maintainability.
The article explains how the vague term “user” creates design flaws and security vulnerabilities across domains such as airline booking systems, Unix environments, and SaaS platforms, and argues for precise terminology to avoid costly rework and confused‑deputy attacks.
This article describes how a C++‑based cross‑platform framework was created to unify iOS and Android implementations of WeChat Pay, detailing the architectural challenges, the introduction of UseCase‑driven business flow, a routing mechanism, improved network request handling, and standardized data passing that together reduced code size, improved stability, and boosted development productivity.
This article explains the concept of system architecture, why it matters, the challenges it faces such as complexity and changeability, and reviews major architectural patterns—including client‑server, peer‑to‑peer, MVC, layered, micro‑service, event‑source, and hexagonal—providing a solid foundation for designing robust software systems.
This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.
This article explains UML's six core relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, and how they are expressed in Java or C++ code.
This article explains why excessive if‑else code harms maintainability, introduces polymorphic extension and code‑separation strategies, and presents a matrix‑analysis methodology that uses multi‑dimensional thinking to systematically design, model, and simplify complex business workflows.
This article identifies four common programming patterns—loops, conditional statements, vague variable names, and global scope—that hinder code clarity and maintainability, and shows how to replace them with higher‑order functions, data‑driven structures, purposeful naming, and encapsulation techniques.
Before defaulting to a microservices architecture, developers should evaluate whether their application is large enough, truly needs component scaling, can handle cross-service transactions, and can tolerate increased latency and complexity, as these factors determine if microservices will add value or unnecessary overhead.
This article compares three seasoned experts' approaches to microservice splitting—vertical vs. horizontal, business‑driven, stability‑driven, and performance‑driven—highlighting trade‑offs, team size considerations, and practical guidelines for achieving scalable, maintainable architectures.
This article explains how software architects can use UML modeling to capture domain problems and system designs, produce clear design documents, and communicate functional, non‑functional, and cost requirements across all stakeholders throughout the development lifecycle.
This article explains the six core UML relationship types—Dependency, Association, Aggregation, Composition, Generalization, and Realization—detailing their semantics, visual notations, code representations in Java/C++, and practical distinctions such as lifecycle ownership and usage contexts.
The article explains why developers often end up with excessive if‑else statements, outlines the drawbacks of deep nesting, and presents practical refactoring techniques—including condition merging, early exits, and polymorphism—to produce cleaner, more maintainable code.
An in‑depth exploration of Git’s initial 1,000‑line source code reveals the foundational design principles—workspace, index, objects, and three core object types—showing how early implementations of init‑db, update‑cache, write‑tree, and commit‑tree established the powerful, distributed version‑control system we use today.
The article thoroughly examines the Linux SCSI subsystem architecture, illustrating how abstract hardware topology—hosts, channels, IDs, and LUNs—is modeled in software through structs such as scsi_host and scsi_device, and detailing initialization, scanning, path establishment, power management, and block‑layer integration to guide kernel storage driver design.
This tutorial explains how to use IntelliJ IDEA's built‑in Diagram plugin to automatically generate UML class diagrams for Java classes, covering configuration steps, shortcut keys, example screenshots, and the tool's limitations for software design documentation.
This article examines the widespread popularity of object‑oriented programming, dispels two common myths— that OOP inevitably slows down applications and that using an OOP language automatically means practicing OOP—by presenting performance data, real‑world examples, and a Java procedural code sample.
This article explains how unit testing goes beyond coverage metrics, showing that writing testable code improves design, performance, and robustness, and provides practical guidance on refactoring, mock usage, data‑driven tests, TDD, BDD, and agile development practices.
The article examines microservice architecture as an abstract concept and presents three practical decomposition strategies—vertical/horizontal business split, business‑driven and team‑oriented considerations, and criteria based on logic, stability, reliability and performance—while also discussing cost, release frequency, and team size implications.
The article explains why excessively long classes with many responsibilities hinder readability and extensibility, outlines the problems of redundant code and SRP violations, and provides practical refactoring techniques—such as extracting methods, moving members, and creating new classes—using IntelliJ IDEA.
This article explains how business architecture controls system complexity through layered structures and domain‑driven design, compares traditional three‑tier and microservice architectures, highlights common pitfalls, and offers a lightweight domain‑centric approach for scalable, maintainable backend systems.
The article explains how the vague term “user” leads to design flaws and security vulnerabilities across systems like ticket‑booking platforms, Unix, and SaaS, and argues that precise terminology and early conceptual planning can prevent costly rework.
Refactoring improves code understandability and reduces maintenance costs by reorganizing internal structure without changing behavior, and this guide explains its purpose, timing, principles, common code smells, measurement metrics, and practical techniques across data, statement, subroutine, class, and system levels.
This article explains the value of technical diagramming, defines architecture and architecture diagrams, describes their purposes, outlines common diagram categories such as the 4+1 view, offers criteria for good diagrams, addresses typical pitfalls, and introduces the C4 model with concrete examples and a case study.
The article discusses the importance of clear responsibilities in application layering, compares Alibaba's multi‑layer architecture with an optimized model, explains domain object types across layers, and offers practical guidelines to improve maintainability and reuse in backend systems.
This article explains the purpose and value of architecture diagrams, defines key concepts, outlines five common view types, discusses criteria for good diagrams, highlights common pitfalls, and introduces the C4 modeling approach with examples to help engineers communicate system designs effectively.
This article explains how to correctly draw UML class diagrams by describing the six main relationship types—generalization, realization, aggregation, composition, association, and dependency—using clear examples and visual illustrations to help readers understand and apply each relationship in software modeling.
The article shares a senior engineer's insights on why code review is essential, outlines common pitfalls such as duplicated code, premature optimization, and poor design, and presents concrete principles and practical guidelines—including KISS, composition over inheritance, and disciplined logging—to improve code quality and maintainability in large‑scale backend projects.
The article examines modern application architecture trends, emphasizing service‑oriented and microservice approaches, the need to move beyond three‑tier designs, and adopting patterns, models, and structures that accommodate cloud, mobile, social, and big‑data influences.
This article explains the DRY (Do Not Repeat Yourself) principle, demonstrates how duplicated PHP code in a Report class can be refactored by extracting shared logic into reusable methods, and shows the final clean implementation that improves readability and maintainability.
The article explains the concepts of modules, coupling, and cohesion, outlines key interface design principles such as Single Responsibility and Dependency Inversion, and illustrates these ideas with practical examples of design patterns like Facade, Bridge, and Adapter, including code snippets.
This article explains the concept of interface‑oriented programming, using everyday analogies and Java code examples to show how defining contracts via interfaces decouples components, improves extensibility, and follows solid design principles such as the Open‑Closed Principle.
This article explains why excessively long classes are hard to read and extend, outlines the problems caused by redundant code and multiple responsibilities, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.
The article explains why excessively long classes are hard to read, extend, and maintain, outlines the problems caused by redundant code and multiple responsibilities, and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.
This article presents a comprehensive architecture methodology that guides engineers through problem identification, definition, classification, top‑down and bottom‑up derivation, model layering, and the systematic construction of product, business, logical, and physical architectures to achieve robust, maintainable software systems.
Architecture patterns provide reusable solutions, and this article explains the Pipe‑Filter pattern—where data passes through independent filters like a production line, used in web frameworks, compilers, and serverless functions—and the Microkernel pattern, which separates a minimal core from plug‑in modules to enhance extensibility, maintainability, and configurability.
This article shares a comprehensive architecture methodology from an experienced Alibaba senior engineer, detailing problem identification, various architecture classifications, top‑down and bottom‑up derivation techniques, and practical steps to design logical, physical, and business architectures for reliable software development.
The article examines why a small fraction of developers earn six‑figure salaries while many remain average, outlining seven decisive abilities—raw coding, debugging, simplicity, accurate schedule prediction, low‑level system knowledge, strict key‑design focus, and avoiding perfectionism—that together create a massive performance gap.
This article shares practical advice on improving a programmer's design ability, covering coding practice, theory study, hands‑on implementation, revisiting concepts, summarizing lessons, sharing knowledge, and additional tips such as designing before coding and avoiding blind reliance on patterns.
Long, monolithic Java classes with hundreds of methods become unreadable, hard to extend, and prone to redundant code, so this guide explains the drawbacks of oversized classes and provides step‑by‑step refactoring techniques using IntelliJ IDEA to extract methods, move members, and create new classes.
This article describes how a C++‑based cross‑platform framework was designed and implemented to unify iOS and Android payment flows in WeChat Pay, covering architectural motivation, business‑process abstraction, routing mechanisms, network request management, and standardized data transmission to improve quality and productivity.
This article explains the challenges of maintaining separate iOS and Android implementations for WeChat Pay, and details how a C++‑based cross‑platform framework—featuring abstracted business flows, a unified routing mechanism, managed network requests, and strict data‑transfer standards—dramatically improves code reuse, stability, and development productivity.
The article explores the Unix philosophy, emphasizing the KISS "keep it simple" principle and detailing four practical guidelines—clarity, modularity, composition, and optimization—that help developers build clean, maintainable software.
During the pandemic, Alipay researcher Wang Yi—creator of SQLFlow and ElasticDL—shares his curated list of three influential programming books, explaining how SICP teaches abstraction and composition, how The Art of Unix Programming illustrates Unix design principles, and how Paul Graham's essays offer timeless insights for developers.
The article lists twelve danger signals—ranging from shallow modules and information leaks to vague naming and unreadable code—that reveal hidden complexity in software design and help developers identify and refactor problematic patterns.
This article explains how software architects can use UML‑based modeling to translate functional and non‑functional requirements into clear design documents, covering the essential steps, key concepts, and the seven major UML diagram types across requirement, conceptual, and detailed design phases.
Choosing whether to evaluate feature flags on the server or the client impacts performance, configuration latency, security, and implementation complexity, with server‑side decisions generally offering better speed, reduced cache‑invalidation risks, protected data handling, and simpler architecture, especially for web and mobile applications.
The article argues that while middleware can simplify handling cross‑cutting concerns in HTTP APIs, overusing it leads to tangled, untestable code, and proposes refactoring middleware logic into pure functions with explicit inputs and outputs to improve clarity and maintainability.
The article explains what business architecture is, its evolution from monolithic to micro‑service and platform models, shares 58.com’s real‑world experience, discusses common difficulties, and offers practical guidance for architects on modeling, technology selection, and aligning with cloud and middle‑platform strategies.
This article explains the subtle difference between concurrency and parallelism using a ground‑hog and cart analogy, shows how task decomposition creates concurrent pipelines, and maps the model to scalable web‑service architecture, referencing Rob Pike’s talk “Concurrency is not Parallelism”.
This article distills key principles from John Ousterhout’s “A Philosophy of Software Design”, offering practical guidelines on defining and reducing software complexity through modularization, layering, thoughtful commenting, and disciplined design practices for developers.
The article argues that programmers should devote the majority of their limited time to mastering transferable fundamentals such as clean code, design patterns, and domain‑driven design, while allocating only a small portion to learning ever‑changing frameworks and tools, illustrated through a mentor dialogue and book recommendations.
Drawing on John Ousterhout’s “A Philosophy of Software Design,” this article explores how to lower software complexity through clear definitions, modular design, layering, information hiding, thoughtful commenting, and strategic development practices, offering actionable principles for building maintainable systems.
This article distills the core principles from John Ousterhout's *A Philosophy of Software Design*—defining software complexity, presenting a quantitative model, and offering practical strategies such as layering, modularization, information hiding, and effective commenting—to help engineers build maintainable, low‑complexity systems.
Drawing on Ousterhout’s philosophy, the article defines software complexity as cognitive load multiplied by development effort and offers principles such as iterative design, layered architecture, deep modules, information hiding, and purposeful documentation to systematically reduce ripple effects, dependencies, and unknowns in code.
This article explores the core purpose of system architecture, identifies technical, business, and project-management challenges, and presents a systematic approach—systemic thinking, decomposition, abstraction, and patterns—to effectively design and implement robust architectures.
This article breaks down the concept of system architecture, derives a concise formula—elements plus connections plus solving specific problems—and explores its classifications, characteristics, and practical implications for designing coherent, goal‑oriented software systems.
This article explains what refactoring is, why and when to apply it, lists common code smells with concrete examples, and provides step‑by‑step techniques for reorganizing functions, moving responsibilities, restructuring data, simplifying conditionals, and improving overall software design.
This article explores the essential characteristics of clean code, emphasizing high cohesion, low coupling, readability, proper naming, formatting, concise classes and functions, effective comments, error handling, and common code smells, while providing practical guidelines and examples for developers.
This article explains how microservices differ from traditional monolithic delivery, outlines the five key architectural constraints—scalability, elasticity, composability, minimality, and completeness—and provides practical guidance for designing robust, loosely‑coupled services.
This article explores the principles of Clean Architecture, explains layered thinking and dependency rules, discusses how to apply them in real projects, and reflects on the broader meaning of software architecture, including domain‑driven design and practical advice for developers seeking to improve their design skills.
This article revisits the author’s earlier talk on software architecture, reorganizes and expands it with detailed explanations of Clean Architecture’s layered design, dependency rules, and related concepts such as DDD, while reflecting on how these ideas can reduce code modification difficulty and guide personal growth as an architect.
The article examines the fundamental drawbacks of traditional monolithic applications—such as excessive complexity, slow development speed, poor scalability, and rigid technology stacks—and explains why these issues motivate developers to adopt microservice architectures.
Writing unit-testable code often requires refactoring, and by focusing on minimizing function size, dependencies, and complexity, developers can adopt seven practical techniques—including limiting function lines, single responsibility, dependency injection, avoiding complex parameters, using abstractions, extracting testable units, and handling private functions—to improve testability and team efficiency.
This comprehensive guide explains an architect's duties, the various architectural mindsets, common frameworks like TOGAF and Zachman, design principles such as OCP and SRP, and evolution patterns from monolithic to microservices and serverless, helping engineers build robust, scalable systems.
This article explains the Open‑Closed Principle of design patterns, illustrates it with Java code that models a hospital’s medicine‑selling process, compares naive and extensible implementations, and shows how to keep software open for extension while closed for modification.
The article explains how the vague term “User” leads to poor requirements, hidden security flaws like the Confused Deputy problem, and costly redesigns, urging developers to adopt precise terminology such as “team” and “member” early in a project.
This article distills the core ideas of "Clean Architecture"—explaining software system value, architecture goals, programming paradigms, design principles, component splitting, dependency handling, and boundary management—to help engineers build maintainable, extensible systems that stand the test of time.
Learn how leveraging familiar design patterns like Singleton, Observer, and Facade can create a common language that streamlines idea sharing and improves collaboration among software development team members.
This article explains the six core UML class diagram relationships—generalization, realization, aggregation, composition, association, and dependency—illustrating each with clear diagrams and practical examples, and also recommends popular UML tools for creating these models.
Using the vague term “user” to describe diverse actors—passengers, agents, services, or system accounts—creates ambiguous models that lead to design flaws and serious security risks such as the Confused Deputy problem, urging developers to adopt precise terminology like “team” and “member” from the start.
This article analyzes IntelliJ IDEA's rapid market dominance, the product and marketing strategies behind its success, and how its flow‑centric and ergonomic design principles can inspire more efficient software development and better user experiences.
Refactoring transforms messy code into clean, maintainable structures without altering observable behavior, covering principles, common code smells, and step‑by‑step techniques such as extracting functions, moving methods, simplifying conditionals, and reorganizing data, empowering developers to improve design, reduce bugs, and accelerate development.
This article explains the purpose and principles of refactoring, enumerates common code smells, and provides concrete refactoring techniques—including extracting functions, inlining, moving features, reorganizing data, simplifying conditionals and calls—illustrated with Java code examples.
The article shows how to refactor a tangled Xianyu detail‑page built on legacy MVC by isolating each vertical business with the Strategy pattern, extracting shared services, packaging them as libraries or JARs, and then applying domain‑driven design to create a clean, layered, maintainable architecture.
Software architecture defines the structural skeleton of a system, encompassing components, connectors, constraints, and guiding principles; this article explains its essence, various classifications—from business to deployment—and offers practical criteria for assessing stability, efficiency, and security in modern server‑based applications.
The article examines the nuanced challenges of microservices—including governance trade‑offs, reuse considerations, complexity versus complication, and the risks of multi‑master data—while arguing for pragmatic, centrally‑guided design to harness their potential without over‑marketing.
The article critiques the core pillars of object‑oriented programming—inheritance, encapsulation, and polymorphism—illustrating their practical pitfalls with real‑world analogies and code examples, and proposes containment and delegation as safer alternatives before urging a shift toward functional programming.
