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.
This article explores the seven core competencies—technical expertise, abstraction, design foresight, systematic thinking, problem‑solving depth, cross‑domain knowledge, and communication—that distinguish a successful software architect and guide how to develop them.
This article explores the role of software architects, outlining their responsibilities, essential qualities, differences between internet and traditional enterprises, team dynamics, common optimization practices, and practical advice on growing into an architect and advancing your career.
This comprehensive guide explains software architecture fundamentals, the responsibilities and skills of architects, key architectural patterns, evaluation methods like ATAM, risk identification and mitigation, practical view models, domain‑specific frameworks, and common enterprise architecture styles.
This article explains what software architecture is, why it is essential, the responsibilities and qualities of software architects, various architect specializations, the software‑requirements lifecycle, the ADMEMS‑based architecture process, multi‑view and 5‑view design methods, key drivers, common pitfalls, and reference resources.
This article explains the six core SOLID principles, introduces additional design guidelines such as composition, acyclic dependencies, and Hollywood principle, and lists other essential software design rules like DRY, KISS, high cohesion, and separation of concerns to help developers build robust, maintainable systems.
The article critically examines micro‑services, outlining their promised benefits such as independent development, deployment and scaling, while exposing the hidden operational, dev‑ops, state‑management, communication, versioning and distributed‑transaction challenges that can turn them into a fragile, overly complex system.
This 2017 survey‑based report analyzes why traditional enterprises are turning to microservices, examines their adoption levels, challenges, Docker usage, emerging Service Mesh technologies, and offers practical guidance for planning and implementing microservice architectures in legacy IT environments.
This article explains what software architecture is, its lifecycle, why a solid architecture is crucial, how to distinguish good from bad designs, the roles and responsibilities of architects, and the skills—both technical and soft—needed to become an effective software architect.
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.
This article shares a payment company's experience planning and executing a microservice transformation, covering the initial blueprint, implementation roadmap, current architectural challenges, key design debates, and the final target architecture diagram to guide a systematic migration.
The author reflects on his journey from developer to software architect, arguing that architecture must be accessible to programmers, integrated with agile practices, and guided by lightweight, incremental methods that balance theoretical rigor with practical, real‑world solutions.
The article explores why many programmers feel lost amid rapid tech change, arguing that true mastery comes from understanding the business‑technology‑software value chain, aligning architecture with business goals, and prioritizing cost‑benefit to become owners of technology rather than its slaves.
This essay explores why many programmers feel confused and powerless, linking personal career anxiety to a lack of understanding of the business‑technology‑software value chain, and proposes a value‑driven architectural mindset to align learning, work, and true impact.
The article reflects on programmers' sense of bewilderment, explains how understanding the business‑technology‑software value chain and adopting a value‑driven architectural mindset can help engineers prioritize learning, align with business goals, and reduce wasted effort while enhancing system service capability.
The article records a Meituan‑Dianping Q&A on Domain‑Driven Design, where engineers discuss using domain events with transactions, designing RPC interfaces, separating domain and application layers, handling cross‑aggregate operations, and defining bounded contexts, illustrating how DDD guides microservice architecture and business modeling.
iQiyi’s big playback core, created in 2013 under architect Gavin, unified fragmented players across PC, mobile and TV by evolving from a C/C++ XBMC‑based V1 to feature‑rich V3 with DRM, Dolby, hybrid P2P‑CDN, VR, multi‑instance support and major performance gains, paving the way for an intelligent next‑gen native player.
This article explains that the essence of internet layered architecture is the movement of data, detailing each layer—from client to service to database—how protocols and data formats shape the flow, and why encapsulation and reuse are key principles for evolving scalable systems.
The article describes how Dada Mall and its crowdsourcing task platform adopted a flexible plugin architecture to modularize product-specific logic, simplify maintenance, enable dynamic configuration, and support rapid business expansion without extensive refactoring.
This article explains how the Yuewen Game SDK was transformed into a pluginized architecture, detailing the motivation, core technical challenges such as class, resource, and Android component identification, implementation strategies, testing procedures, and the benefits and new issues arising from large‑scale deployment.
The article describes how a large, budget‑constrained software project with vague requirements can be successfully delivered by adopting Scrum, clarifying requirements through collaborative backlog grooming, handling defects immediately, splitting stories vertically, and coordinating multiple feature and platform teams to ensure incremental value delivery.
This article presents concise, one‑sentence summaries of common design patterns—Simple Factory, Factory Method, Abstract Factory, Builder, Prototype, Singleton, Adapter, Bridge, Composite, Facade, Flyweight, Decorator, and Proxy—offering quick insights for beginners to form an initial impression and for experienced developers to refresh their knowledge.
The article explains software architecture as a top‑down, macro view of systems—covering business decomposition, domain modeling, technical and system design, deployment considerations, and the skills architects need to create scalable, maintainable solutions.
This article completes and supplements the earlier “Architecture Design Principles” post by presenting the concepts, forms, and design principles of software architecture, accompanied by a full‑length PPT from a recent internal training session.
The article explains that software architects focus first on server environment, concurrency, security, and quality attributes rather than UI layout, outlining key functional and non‑functional concerns, evaluation methods, and scaling strategies for systems such as MMOs.
The article outlines essential software architecture concerns—including functionality, variability, performance, capacity, ecosystem integration, modularity, buildability, productization, and security—while also discussing evaluation methods and scaling strategies for large‑scale systems such as MMOs.
The article chronicles CTO Wei Xiangjun's journey from Microsoft to Kingsoft and Sina Weibo, highlighting his team‑building strategies, agile product development, architecture innovations, and practical career advice for engineers seeking growth and effective management.
This article compiles an extensive set of technical knowledge maps—covering architecture, JVM, Java concurrency, big data, cloud computing, mobile, frontend, backend, DevOps and more—to help engineers and architects quickly locate and master essential concepts across the software development spectrum.
In this talk, chief architect Li Yanpeng shares his career background, outlines the goals and design principles of distributed service architecture—including high availability, performance, scalability, extensibility, security, and consistency—and offers a methodology for cultivating both technical and personal inner skills for engineers.
This article explains the fundamental ideas of Domain‑Driven Design, showing how to build expressive domain models, use a ubiquitous language, map bounded contexts, apply strategic and tactical patterns, and implement the concepts with C# code, UML sketches, and architectural guidelines.
The article explains the fundamental architectural factors of large‑scale web systems—performance, availability, scalability, extensibility, and security—detailing practical optimization techniques, measurement metrics, and design principles that guide robust software architecture decisions.
The article explains how introducing the Observer pattern into an order‑completion module improves code readability, separates responsibilities, and enhances extensibility by turning post‑order actions into independent observers that react to a single subject’s state change.
This article explains software architecture as the composition and interaction of components, outlines its ANSI/IEEE definition, describes UML diagrams for modeling, discusses validation through testing, and shares practical development rules, offering a concise learning summary for engineers.
The article examines the evolution of integration architectures, identifies persistent data‑search, adaptation, and system‑linkage challenges, and proposes AI‑driven solutions such as knowledge‑graph self‑service and deep‑learning UI automation, illustrating how intelligent integration can reshape software development pipelines.
The article argues that making "architect" a permanent job title is misguided, advocating instead that architecture be treated as a flexible role shared by senior developers who stay involved in coding and collaborate on design decisions to avoid over‑design and team friction.
In the AI era, engineers need more than cutting‑edge algorithms—they must understand infrastructure, deployment, scalability, and team collaboration, as illustrated by four practical reasons and Google’s architectural breakthroughs that bridge big data, machine learning, and deep learning.
This article explores the real day‑to‑day responsibilities of a startup CTO, debunking myths and outlining five concrete skills—from platform selection to fostering technical leaders—that enable technology strategy to align with business goals.
This article explains that an architectural style is a set of high‑level principles that provide an abstract framework for families of systems, discusses common styles such as client‑server, layered, pipe‑and‑filter, event‑driven, and REST, and examines their benefits, trade‑offs, and open design questions.
