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.
This article explains how treating software projects as disciplined design processes—using shared language, realistic estimation, systematic system modeling, and test‑first development—helps create clean, maintainable code while avoiding the pitfalls of over‑engineering and rushed delivery.
This article explores the philosophy of clean code, emphasizing disciplined design, clear domain language, realistic estimation, collaborative system modeling, and test‑first development to produce maintainable, efficient software that meets client needs while avoiding unnecessary complexity.
UML class diagrams feature six primary relationships—Generalization, Realization, Dependency, Association, Aggregation, and Composition—each with distinct visual notations and semantics, and this guide explains their definitions, code representations in Java, and practical examples to help developers model system structures accurately.
The article explains why clear separation of responsibilities among controller, service, manager, and DAO layers is essential for maintainable backend code, outlines Alibaba's layered architecture guidelines, proposes an optimized layering model, and discusses domain model conversions across layers to avoid excessive object transformations.
This article explains the core concepts of microservice architecture, outlines its components and pros‑and‑cons, and uses Uber's evolution from a monolithic system to a distributed microservice platform as a detailed case study.
From the basics of three‑tier architecture to the challenges of scaling, this article explains why monolithic designs become problematic, how fine‑grained and coarse‑grained microservices address complexity, and offers practical refactoring steps for high‑concurrency systems.
This guide explains UML's core relationship notations, the nine essential diagram types and their purposes, detailed insights into class, object, use‑case, sequence, collaboration, state, activity, component, and deployment diagrams, and how they map to fundamental object‑oriented concepts such as boundary, entity, and control classes.
This article explores the concept of software architecture for mobile apps, sharing personal reflections, industry case studies, design principles, modularization strategies, development practices, testing, risk management, and agile processes to help developers build maintainable, scalable, and high‑quality applications.
This article explains the common maintenance challenges in UI automation, introduces the PageObject pattern as a solution, describes its layered architecture—including appium, pages, operation, and test layers—and highlights how it improves code reuse, readability, and reduces effort when UI changes occur.
The Story Scenario Tree is presented as a practical tool that guides developers to apply simple design principles—defining tasks, external interfaces, and upfront test cases—to create isolated, high‑quality code that evolves healthily, with progress measured objectively and defects minimized across changes.
This article presents a curated list of twelve influential programming books—ranging from classic software design and algorithms to practical coding guides—explaining why each title is essential for developers seeking to deepen their craft regardless of language or experience level.
The article shares practical experiences on writing high‑quality code by emphasizing logical correctness, the necessity of handling the else branch, techniques for lowering logical complexity, and strategies for decoupling business logic from implementation, all illustrated with clear Java examples.
This article enumerates twenty‑two typical code smells—from duplicated code and long methods to speculative generality—and provides concrete refactoring tactics such as Extract Method, Pull Up Method, Introduce Parameter Object, and Move Method to improve design, readability, and maintainability of object‑oriented software.
This article explains what refactoring is, why it improves code quality, readability, and development speed, when to apply or avoid it, the typical refactoring workflow, its relationship with design, and how it impacts software performance.
This article explains the concept of software architecture, its definition, lifecycle, importance, characteristics of good and bad designs, essential technical knowledge for Java architects, functional versus non‑functional requirements, types of architects, required hard and soft skills, and guidance on becoming and maintaining an effective software architect.
The article shares a developer's hard‑won lessons from refactoring a ten‑year‑old core system, emphasizing the crucial role of mindset, careful business‑logic analysis, selective task handling, and the use of design patterns to achieve clean, extensible code.
The article reflects on a decade of programming experience to demystify object‑oriented programming, arguing that OOP should be taught as a practical tool for reducing complexity rather than an abstract doctrine, and discusses how to organize functions into classes, avoid misuse of inheritance and design patterns, and focus on solving real problems.
This article traces the evolution of application architectures—from vertical monolithic designs through RPC and SOA to modern microservices—explaining the motivations, key characteristics, deployment patterns, and trade‑offs of each approach for scalable, maintainable backend systems.
This article outlines the historical evolution of application architecture—from early vertical monolithic designs through RPC and SOA approaches to modern microservice architectures—highlighting their characteristics, deployment models, and the motivations behind each transition.
This article presents thirty practical Java coding guidelines covering naming conventions, class design, method granularity, encapsulation, documentation, error handling, and performance considerations to help developers produce clean, robust, and maintainable software.
This article explores the blurry line between development and software architecture, outlines the responsibilities and evolution of a software architect, and provides practical guidance on defining architecture, managing non‑functional requirements, selecting technologies, evaluating designs, and leading teams toward successful releases.
This article explains why refactoring is essential for maintaining legacy systems, defines refactoring, outlines when to start and stop, describes the step‑by‑step process, discusses code smells and techniques, and offers resources for mastering clean, maintainable software.
The article explains why refactoring is essential for maintaining and evolving legacy code, defines refactoring, outlines when to start and stop, lists prerequisites, describes a step‑by‑step process with testing and version control, and connects refactoring to design principles and large‑scale systems.
This guide outlines the key components, step‑by‑step process, and quality‑assurance measures for evaluating software and hardware system architectures to ensure reliability, scalability, security, and cost‑effectiveness while reducing risk and guiding future design decisions.
This article explains the core concepts of a .NET plugin framework, illustrates its structure with diagrams, demonstrates practical development and deployment workflows, enumerates its advantages for team collaboration and modularity, and compares OSGi.NET with other popular .NET plugin solutions.
The article explores whether effective software architecture stems from upfront design or gradual evolution, presenting viewpoints from senior architects, discussing stakeholder concerns, non‑functional requirements, real‑world evolution cases like 58.com and Google, and urging readers to share their own conclusions.
The article outlines twenty‑five practical principles for becoming an excellent software model designer, emphasizing the importance of people over technology, thorough requirement analysis, humility, low coupling, high cohesion, portability, scalability, performance, proper documentation, and continuous learning to build robust, maintainable systems.
This article explains the nine GRASP patterns and key object‑oriented design principles—such as Information Expert, Creator, Low Coupling, High Cohesion, Controller, Polymorphism, Pure Fabrication, Indirection, and Protected Variations—showing how they form the foundation for effective software architecture.
The article reflects on the shift from pure coding to embracing requirement analysis, testing, and especially diagramming, explaining how visual representations externalize information, foster exploration, support global thinking, and make abstract concepts intuitive, ultimately improving software quality and collaboration.
This article explains core OO architecture principles such as low coupling and high cohesion, outlines methods to reduce coupling, advocates composition over inheritance, and provides concise overviews of widely used design patterns like MVC, MVVM, Factory, Singleton, Builder, and many others.
The article argues that treating lines of code as a cost rather than a product encourages writing disposable, loosely‑coupled software, and it walks through practical stages—from avoiding code entirely to using feature flags—to build systems that are easier to modify, replace, or discard.
This article identifies why most code remains low‑quality despite many guidelines and presents four practical principles—single abstraction level, minimized indentation, clear expressions, and effective use of helper classes—that dramatically improve a team's coding standards.
The article explains how to design clean, decoupled system architectures by isolating concerns, using AOP, dependency injection, factory methods, and DSLs, while illustrating concepts with city‑building analogies and Java code examples.
This article explores how an ideal web framework—featuring a unified data model, reusable code, event‑driven logic, and language‑agnostic architecture—can be realized in practice, discussing frontend and backend realities, graph‑based data modeling, and the benefits for maintainability and extensibility.
The article explains how building low‑latency applications relies on simplicity, minimizing data transformations, using lightweight libraries, and separating business from infrastructure code to achieve high performance, maintainability, and reduced operational costs.
The article reveals four common programming pitfalls—premature or late optimization, over‑complex abstractions, misuse of tools, and misguided cross‑platform efforts—and provides practical patches to keep developers from sinking into endless deadlines and frustration.
The article examines why software architectures inevitably degrade over time in long‑running projects, analyzes the stages of decay, and presents practical strategies—including environment upgrades, phased and distributed builds, component isolation, and platform‑plus‑app designs—to keep systems maintainable and performant.
While many languages recommend importing specific classes and programming to interfaces, these practices often add maintenance overhead without tangible benefits, especially in Java, and can even hinder readability; the article critiques such rules, urging developers to evaluate the real value of coding conventions.
This article presents eighteen core programming principles—from DRY and KISS to the Open/Closed and Law of Demeter—that help developers write cleaner, more maintainable code, reduce bugs, and adapt to change effectively.
This article explains the Extract Method refactoring technique, its definition, benefits, and step‑by‑step PHP examples that show how to split a long method into smaller, well‑named methods, improving readability, reusability, and adherence to the Single Responsibility Principle.
This article provides a comprehensive checklist for code reviewers, covering formatting, design, readability, functionality, security, testing, performance, and resource usage, while explaining why many of these aspects can be automated and how to balance manual inspection with tooling.
Learning the core programming language rather than relying on heavy frameworks, building small independent modules, and keeping code minimal and readable improves flexibility, performance, maintainability, and reduces bugs, ultimately leading to higher productivity and better collaboration among developers.
This article compiles ten provocative programming viewpoints—from the primacy of using your brain over rigid best‑practice checklists to the limits of unit testing—offering practical reflections on mindset, learning, tooling, and design that can sharpen any developer’s approach.
The article examines the evolution from traditional SOA and ESB to modern microservices, outlining key characteristics such as componentization via services, business‑aligned team structures, treating services as products, lightweight communication, decentralization, automation, failure‑tolerance, and evolutionary design, while discussing practical adoption challenges.
The article presents Uber engineering leader Raffi Krikorian’s twelve practical rules for planning, executing, and managing software architecture refactoring, emphasizing clear purpose, measurable goals, incremental delivery, data‑driven decisions, technical debt control, realistic technology choices, and stakeholder communication.
The article presents Uber engineering manager Raffi Krikorian’s twelve practical rules for planning, executing, and evaluating software architecture refactoring, emphasizing clear purpose, measurable goals, incremental delivery, current state assessment, data‑driven decisions, and diligent management of technical debt.
The article explains how over‑complex mental models, poor translation of semantic ideas into code, inadequate naming, missing design chunks, unclear usage patterns, and lack of smooth model transitions cause code to decay, and offers practical principles such as DDD, SRP, good naming, testing, and reusing existing algorithms to maintain readability.
