The article explains how to evolve a microservice‑based transaction system’s testing framework from a simple all‑in‑one approach to a modular, aspect‑oriented architecture with separate action, assertion, and proxy layers, enabling scalable, reusable, and maintainable test cases across expanding business scenarios.
At the 2019 GMTC Beijing Global Front‑End Conference, Beike engineers shared practical approaches to extreme front‑end performance optimization, Node.js service stability, comprehensive mobile crash and network monitoring, and the challenges and solutions of integrating Flutter into their existing mobile apps.
This article introduces Domain‑Driven Design, explains why traditional MVC‑based CRUD approaches lead to heavy, hard‑to‑maintain services, and shows how DDD concepts such as aggregates, bounded contexts, event sourcing and CQRS can clarify business logic, improve micro‑service boundaries, and reduce system complexity.
Becoming a software architect requires more than high‑concurrency knowledge; it demands comprehensive abilities such as requirement analysis, system decomposition, technology selection, design, communication, and leadership across all development phases, balancing business understanding with technical expertise to deliver effective architectural solutions.
The article analyzes current and emerging software architecture trends such as evolutionary architecture, microservices adoption, event sourcing, serverless, and the evolving role of architects, highlighting which concepts are moving toward mainstream adoption and which remain niche.
The article explains why pure coding expertise alone doesn’t make a top‑level architect, emphasizing hands‑on experience, forward‑looking design, product awareness, domain modeling, deep technical foundations, and high‑availability practices as essential for evolving robust software systems.
This article explains the Composite design pattern, detailing its definition, benefits, and implementation through JavaScript examples such as a startup command sequence and an employee‑department hierarchy, while highlighting key considerations, common pitfalls, and best practices for effective use.
This article explains how abstract, layered, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools that enable software architects to manage complexity, design scalable systems, and continuously evolve architectures in response to changing requirements.
This article traces the evolution of software architecture—from monolithic applications through vertical and SOA designs to modern microservices—detailing each style’s characteristics, advantages, and drawbacks to help developers understand when and why to adopt each approach.
This article examines Alibaba’s journey to achieve a 7 × 24 hour continuous delivery channel, detailing how system design, architecture evolution, configuration management, testing automation, and cultural shifts together boost R&D efficiency and enable rapid, reliable code iteration across large-scale teams.
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.
This comprehensive guide explains software architecture methodologies, system decomposition techniques, core design principles, common patterns, and the 4+1 view model, offering readers a solid foundation for purposeful learning and application in modern software projects.
This article explores the challenges of API design, outlines fundamental principles such as clear mental models, simplicity, multiple implementations, and idempotency, and provides concrete best‑practice recommendations illustrated with the classic POSIX File API example.
This article introduces ten widely used software architectural patterns, explains their structure and key characteristics, and lists typical application scenarios for each, helping developers choose appropriate architectures for large‑scale enterprise systems.
The article analyzes the evolution of technology architecture, explains the origin and purpose of the mid‑platform concept from Alibaba and JD, outlines future software trends such as AI‑driven logic, IoT UI, blockchain data, and quantum infrastructure, and proposes a layered application model for the emerging industry internet.
This article provides concise explanations, real‑world usage tips, and visual illustrations for 23 classic design patterns—including structural, creational, and behavioral patterns—helping developers understand when and how to apply each pattern in everyday Java projects.
The article outlines the design of a prepaid‑card marketing platform that uses configurable rule templates, condition‑behavior chains, and rule orders to manage membership recharge rewards and gift‑card usage limits, providing a generic core engine with adapters for merchants while supporting future migration to payment systems.
By applying micro‑frontend principles and DDD‑based microservice design, the article explains how insurance companies can build modular, reusable front‑end components that integrate with backend middle‑platform services, thereby lowering integration complexity, improving scalability, and enabling unified, cross‑product order sales across multiple channels.
This article explains why clear architecture diagrams are essential for communication, defines key concepts, outlines common pitfalls, introduces the 4+1 and C4 modeling approaches, and provides practical tips for creating self‑describing, audience‑oriented diagrams that align with code.
The article explains a practical method for gaining software architecture experience by systematically reading the source code of well‑known open‑source projects, combining documentation with hands‑on code exploration to develop intuition and design skills.
This article explores how to achieve high cohesion and low coupling in distributed systems by examining clean, hexagonal, and CQRS architectures, detailing domain‑driven design layers, microservice boundary design, splitting principles, and practical strategies for data, caching, and resilience in modern backend development.
In this interview, Didi R Lab senior engineer Du Huan discusses his decade‑long Go experience, the language’s low‑cost entry, system‑level performance and cloud‑native strengths, upcoming enhancements like generics, his large‑scale microservice framework design for Gopher China 2019, and practical advice for developers and enterprises adopting Go.
This article explains why clear architecture diagrams are essential for communication, outlines common pitfalls, introduces the 4+1 view and C4 modeling approaches, and provides practical advice on creating audience‑centric, self‑describing diagrams that align with code and improve development efficiency.
Xianyu transformed its product publishing and editing functions by extracting platform code, introducing the SWAK framework, and decoupling services through RPC, resulting in clearer architecture, reduced code coupling, and significantly improved cross‑team development efficiency.
This article explains how event‑driven and microkernel architectures provide flexible, decoupled designs for complex backend systems, comparing centralized and decentralized patterns, outlining their structures, advantages, drawbacks, and suitable scenarios, and offering practical guidance for implementation.
This article explains the essence of high cohesion and low coupling, why they reduce maintenance cost, and provides practical steps—defining responsibilities, categorizing layers, and setting clear boundaries—to achieve a well‑structured, loosely coupled software system.
The article presents a detailed critique of Docker, arguing that despite its marketed benefits of portability, security, and resource management, its design introduces significant complexity, hidden costs, and operational risks that many organizations overlook when adopting it for production workloads.
The article explains essential object‑oriented design principles—SOLID for class design and six package‑level rules—showing how proper dependency management and modular organization create flexible, reusable, and maintainable software, and why developers must understand these concepts beyond basic procedural programming.
This guide walks founders, CEOs, CTOs and other stakeholders through nine actionable steps—from embracing simplicity and assessing personal needs to evaluating open‑source options, ecosystem support, future outlook, hiring, design flexibility, prototyping, and finally launching—helping them make informed technology‑stack decisions for web applications.
EventStorming is a rapid, lightweight group modeling practice that accelerates shared domain understanding and domain‑driven design by using domain events, commands, bounded contexts, and collaborative workshops, making it applicable to any complex technical or business domain.
Drawing on over a decade of experience from a biology graduate turned Alibaba architect, this article outlines the three stages of programming skill development—basic, intermediate, advanced—and shares practical insights on system design, troubleshooting, and career progression for aspiring professional developers.
The article presents a step‑by‑step roadmap guiding software engineers from junior coding roles through senior engineering and technical expertise to junior, mid‑level, and senior architect positions, emphasizing mentorship, systematic study, deep experience, and the three core architect skills—judgment, execution, and innovation—underpinned by the 10,000‑hour practice rule.
This article explains the six SOLID design principles—Single Responsibility, Liskov Substitution, Dependency Inversion, Interface Segregation, Law of Demeter, and Open‑Closed—using iOS‑oriented examples, code snippets, and practical advice to help developers write cleaner, more maintainable software.
This article explains how software complexity arises from both business requirements and quality attributes, discusses the challenges of technical and business complexity, and demonstrates how Domain‑Driven Design—through layered and hexagonal architectures, bounded contexts, and micro‑service decomposition—helps isolate concerns and manage complexity in large systems.
This article explains how to formulate an architecture vision and goals, outlines the hierarchical levels of vision from system-wide to code-level, describes the process of deriving vision from requirements, and details quality attributes and design principles for effective software architecture.
Discover 15 timeless architecture principles—from redundancy and rollback design to monitoring, horizontal scaling, and non‑intrusive components—that guide engineers in creating robust, scalable, and maintainable systems while balancing cost, risk, and future growth.
This comprehensive guide outlines the mindset, methodology, general and professional skills, core architectural concepts, design principles, and essential tools needed for anyone aspiring to become a proficient software architect in modern technology environments.
This article outlines the philosophical mindset, career stages, essential knowledge, and practical habits needed to evolve from a junior programmer to a senior architect, offering concrete steps, role responsibilities, and advice on continuous learning and effective time management.
A software architect must combine strong technical expertise, deep business understanding, forward‑looking design, broad knowledge, effective communication, and systematic thinking to translate business needs into reliable, scalable systems that drive a company's success.
This article explores the definition, duties, and career development of software architects, covering their role in different company stages, system decomposition, technical selection, team collaboration, various architect specializations, essential skills, and practical advice for advancing in the field.
The article explains how identifying problem spaces and mapping them to solution spaces through domain and domain‑model modeling helps businesses design software systems that directly address core operational challenges, illustrated with HR, expense, e‑commerce, and hotel management examples.
This article explores core API design principles—clear mental models, simplicity, multiple implementations—and offers concrete best‑practice guidance, from documentation and resource modeling to idempotency, compatibility, batch updates, and error handling, illustrated with the classic POSIX File API.
The article argues that true developer competence lies in deep architectural and design skills—covering physical storage, caching, data structures, and modular software design—rather than constantly chasing the latest languages or frameworks across backend, frontend, and mobile development.
Navi is an open‑source component‑routing framework that separates routing logic from business code using matcher annotations, allowing developers to define reusable handlers for different client types and versions, thereby reducing code complexity, improving extensibility, and simplifying backend services while supporting future extensions and community contributions.
This article explains how adopting microservices, appropriate architectural patterns, and DevOps practices—ranging from monolithic to cloud‑native designs—can reduce costs, improve scalability, and support rapid development across web, mobile, and IoT platforms, while highlighting key differences between SOA and microservices.
The article explores how rapid business growth and evolving technology have turned software from a deterministic, document‑driven process into a continuously changing infrastructure, urging a shift toward internal determinism, documentation‑as‑code, and object‑oriented business design.
The author reflects on a recent project refactor, emphasizing why object‑oriented programming remains dominant, exploring concepts like control inversion, dependency injection, SOLID principles, composition over inheritance, design patterns, layered architecture, and the balanced relationship between OOP and functional programming.
Software architecture defines the overall structure and components of a system, guiding design decisions, balancing performance, scalability, and maintainability, while fostering team alignment through clear standards and abstractions, and the article outlines its purpose, best practices, evaluation criteria, and a path to becoming an architect.
This article outlines the progressive evolution of a company's software layering strategy—from an initial monolithic approach through webapp, business, base, and core layers—explaining the motivations, definitions, and practical implementations of each stage.
This article explains what a software architect does, outlines their main responsibilities such as requirement analysis, system decomposition, technology selection, and specification writing, and highlights the essential design, technical, and communication skills needed to progress from junior developer to architect.
The article explains how domain‑driven design helps software teams reach a shared understanding of the problem domain by cultivating requirements through visual collaboration, structured inception and iteration activities, and continuous feedback loops, ultimately improving architecture, reducing miscommunication, and delivering higher‑quality software.
The article explains how abstraction, layered design, divide‑and‑conquer, and evolutionary thinking form the four essential mental tools for architects to manage complexity, illustrating each concept with real‑world examples, diagrams, and practical advice for cultivating these skills.
This article recounts Alibaba middleware leader Bi Xuan’s reflections from the 2018 Hangzhou Cloud Expo, highlighting three key projects—HSF, HBase, and Pouch Container—while exploring the broader impact of open‑source technologies such as Linux, Kubernetes, Dubbo, RocketMQ, and OpenMessaging on modern cloud‑native software development.
This article explains what software architecture is, why it matters for growing teams, outlines key responsibilities, presents practical best‑practice diagrams and decision criteria, and offers guidance on how engineers can evolve into effective architects.
This comprehensive guide outlines the essential technical and soft‑skill roadmap for programmers, covering computer fundamentals, data structures, Java basics, multithreading, JVM internals, databases, distributed systems, architecture, learning methods, personal branding, English importance, and ways to stay competitive.
This article clarifies the core distinctions between Service‑Oriented Architecture (SOA) and microservices, covering their origins, communication models, bounded contexts, scalability, and suitable use‑cases, helping developers decide which architectural style best fits their application’s size, complexity, and deployment needs.
This article explains the fundamentals of microservices, contrasts them with monolithic architectures, outlines the pros and cons of each approach, and highlights key characteristics, benefits, and challenges of adopting a microservice‑based backend design.
This article explains the MVC, MVP, and MVVM architectural patterns, detailing their structures, interaction flows, advantages, disadvantages, and suitable scenarios, helping developers choose the right pattern for their projects.
This article explains what software architecture means, outlines how to start designing an architecture that aligns with business needs, describes the key characteristics of a good architecture, highlights common misconceptions, and offers concluding advice for architects seeking practical, business‑driven design guidance.
The author reflects on a four‑year journey of refactoring a complex system into a lightweight, service‑oriented architecture, emphasizing how breaking down monolithic deployments, adopting modular services, and enforcing disciplined conventions can restore simplicity, flexibility, and efficiency in backend development.
This article shares practical methodologies for building software systems that remain stable for a decade, covering goal setting, holistic design, operator and data‑center choices, cross‑region active‑active challenges, server and platform selection, comprehensive monitoring, and the importance of continuous personal improvement.
The article explains why software architects need to create clear diagrams, describes the problems they solve, lists nine typical diagram types—including use case, robustness, mind map, DFD, flowchart, class, state, E‑R, and sequence diagrams—with their appropriate scenarios, advantages, and drawbacks, and outlines a step‑by‑step workflow for applying them in real projects.
The article outlines the essential qualities of a software architect, emphasizing business understanding, abstraction, strong coding ability, comprehensive system thinking, global impact awareness, and balanced decision‑making to ensure robust, scalable, and maintainable system designs.
This article explains what software architecture is, why it matters for growing teams, outlines common challenges, presents best‑practice modeling techniques, offers criteria for boundary and middleware decisions, describes characteristics of a good architecture, and outlines how to grow into an architect role.
The article traces the evolution from early Service‑Oriented Architecture and monolithic applications to modern microservice architectures, highlighting their limitations, the rise of containers and Docker, and how these technologies enable scalable, language‑agnostic, and cloud‑native deployments for complex systems such as e‑commerce platforms.
This article explains how abstraction, layered thinking, divide‑and‑conquer, and evolutionary design serve as the four fundamental mental tools that architects use to manage complexity in software systems, illustrated with everyday analogies, diagrams, and practical interview examples.
Understanding and documenting the system context—its external users, roles, channels, and interacting systems—provides a foundational view that links business context to architecture, guides information flow modeling, and ensures traceability throughout the software development lifecycle.
This article explains the discipline of software architecture, its historical roots, key definitions, the importance of comprehensive documentation, various architectural views, and essential documentation components that help teams communicate designs, educate new members, and maintain system quality over time.
This article explores the evolution from Service‑Oriented Architecture to microservices, explaining why microservices succeed, how they differ from traditional monolithic designs, and the practical considerations for adopting them in large‑scale systems.
Liu Lianxiang explains how mini‑program real‑time audio/video can power interactive education despite challenges like missing cameras, cluttered backgrounds, diverse devices, debugging burdens, integration hurdles, and network latency, offering a cross‑platform SDK with sub‑400 ms latency, noise reduction, and unified WeChat ecosystem support.
This article shares practical insights on evolving from traditional three‑tier architecture to microservice‑based designs, discusses fine‑grained versus coarse‑grained service partitioning, addresses high‑concurrency challenges, and proposes refactoring strategies for large‑scale backend systems.
This article explains core microservice concepts—including componentization, modularization, centralized vs. distributed systems, and the architectural principles behind microservices—while comparing them to SOA and highlighting practical distinctions that help developers design loosely‑coupled, reusable services.
The article shares the author’s personal learning path toward becoming a Java architect, highlighting early misconceptions, the importance of using existing components, avoiding deep dives into low‑level details, integrating multiple technologies, and focusing on reusability and maintainability through design patterns and high‑concurrency practices.
The article explains how software architecture relies on coordinated roles—business owners, architects, team leads, and developers—highlighting the importance of a dedicated technical lead to bridge business requirements and framework implementation, reduce design friction, and ensure effective communication within the team.
This article explains the purpose of software architecture design, identifies sources of complexity such as performance, availability and scalability, outlines three guiding principles—appropriateness, simplicity, and evolution—and presents a practical step‑by‑step design process illustrated with diagrams.
FinTech firms should replace monolithic systems with microservices because the modular style delivers greater agility, maintainability, scalability, availability, and code reuse—crucial for rapid market demands and regulatory change—while acknowledging migration costs, monitoring complexity, and the need for phased refactoring of legacy assets.
This article summarizes the core object‑oriented design principles—including SOLID, the Law of Demeter, and composition/aggregation reuse—explaining their definitions, analyses, advantages, and real‑world examples to help developers write more maintainable and extensible software.
This article explains what a software architect really does, clears common misconceptions, outlines the essential skills and experience a senior Java developer needs to become an architect, and describes the typical daily responsibilities and communication challenges of the role.
Ant Group engineers Yang Bing and Huang Ting discuss the evolution of their SOFA middleware platform—from early service‑oriented architecture to a full‑stack DevOps ecosystem—highlighting microservice governance, Service Mesh integration with Kubernetes/Istio, open‑source strategies, and the cultural emphasis on reliable, commercially‑savvy engineering talent.
The article debunks three prevalent misconceptions—treating a development framework as a substitute for an architect, assuming high concurrency and big‑data challenges are inherently difficult, and believing microservice architecture is a universal solution—by emphasizing the importance of proper design, testing, and realistic evaluation of trade‑offs.
This article explains the common misconceptions about software architects, outlines the essential conditions and skills required for senior developers to upgrade, describes practical learning paths, and details the daily responsibilities and interpersonal abilities needed to succeed as an architect.
This article introduces core architecture analysis methods—including system engineering, system decomposition, process‑oriented, and object‑oriented approaches—and compares monolithic (ALL IN ONE) and distributed system structures, providing practical examples and visual diagrams.
This article explains how design patterns, frameworks, software architecture, and platforms each contribute to different levels of code reuse—from class-level patterns to system-wide architectures—while also detailing key design principles, framework basics, and Java platform classifications for developers seeking deeper engineering insight.
The article presents a structured framework for problem solving and architectural thinking, defining problems as goal‑state gaps, warning against common pitfalls, introducing a “what‑how‑why” learning loop, detailing root‑cause analysis for anomalous issues and goal‑driven stakeholder mapping for improvement tasks, and emphasizing emotional intelligence in human‑centric solutions.
The article explains how to describe system architecture from various perspectives, introduces logical and physical views, presents the 5‑view method, and outlines six practical steps—from requirement analysis to architecture validation—guiding architects to create adaptable, scalable, and maintainable designs.
The article outlines how engineers can sustain continuous learning amid heavy workloads and rapid tech change by applying four proven principles—persistence, hands‑on practice, communication, and systematic summarization—while dispelling common career myths and introducing a seven‑skill architect model covering programming, debugging, deployment, performance, business architecture, online operations, and management.
The article argues that software architecture is fundamentally the practice of uncovering a problem’s essence—its context, goal, and obstacle—classifying it as abnormal or improvement, and then converting the open‑ended gap between current state and desired outcome into a concrete, implementable solution.
This article compares traditional waterfall and agile software architecture, examining the roles, timelines, and deliverables of architects, sharing real‑world challenges, and offering practical guidelines for building sustainable, adaptable architectures in modern development teams.
This article explores software architecture fundamentals, covering object‑oriented design principles, SOLID, DRY, KISS, logical vs. physical layers, service and business logic layers, SOA, data access strategies, stored procedures, and the MVC pattern, providing practical insights for building maintainable systems.
This article explores the challenges and essential practices of software architecture, explaining its scope, how to create actionable designs, the architect's role, and ways to cultivate architectural thinking through experience and continuous improvement.
After years of coding without guidance, the author shares practical insights on developing object‑oriented design thinking, when to use interfaces, the limits of OOD, and how continuous refactoring and learning design patterns can gradually build a junior developer’s architectural competence.
This article explains how the complexity of software requirements can be managed using the RUP 4+1 view method, illustrating the approach with a supermarket system and a device debugging system to ensure every functional and non‑functional need is systematically satisfied.
This article explains why domain modeling is crucial for managing complex business logic, compares transaction scripts with domain models using a bank transfer example, outlines the benefits of object‑oriented design, and provides practical steps and best practices for building, evolving, and visualizing domain models.
The article argues that software architecture is a real design discipline composed of multiple topics and logical layers, illustrating its necessity through examples like telephone exchanges and network driver development, and warns against ignoring architectural planning in complex, evolving systems.
The article explores the essence of software architecture as a disciplined process of reducing system entropy through strategic decomposition and recomposition, outlines the roles of business, application, and technical architecture, describes the architect’s capability model, and presents four progressive levels of architectural mastery.
This article introduces the concept of architecture patterns, outlines ten common software architecture styles—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and disadvantages.
In this extensive interview, senior Alibaba engineer Chen Kangxian shares his experiences designing large‑scale distributed systems, live‑streaming platforms, and high‑concurrency architectures, offering practical insights on technology choices, failure handling, and career growth for software architects.
This guide outlines the essential mindset, universal and specialized skills, website architecture evolution, core design principles, and a curated collection of tools, platforms, books, and resources that aspiring architects need to develop a systematic knowledge base and excel in modern software engineering.
Explore ten common software architectural patterns—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and drawbacks, to help you choose the right architecture for enterprise‑scale systems.
This article outlines the philosophical questions, practical steps, and essential knowledge—ranging from object‑oriented fundamentals and design patterns to refactoring, DBA, and operations—that developers need to master in order to evolve into competent web architects.
