BestHub
Sign in
Tagged articles
265 articles
Page 1 of 3
Tech Freedom Circle
Tech Freedom Circle
Mar 19, 2026 · Artificial Intelligence

Failed Alibaba Interview: The 4 RAG Modules and 6 Design Principles You Need

The article dissects a failed Alibaba second‑round interview where the candidate answered only “vector‑search‑enhanced” for a RAG design, and then presents a systematic, four‑module RAG architecture together with six design principles, detailed indexing, query understanding, multi‑path recall, and context generation techniques to help candidates demonstrate comprehensive technical depth.

AI ArchitectureKnowledge GraphMulti‑Path Recall
0 likes · 22 min read
Failed Alibaba Interview: The 4 RAG Modules and 6 Design Principles You Need
AI Waka
AI Waka
Feb 27, 2026 · User Experience Design

Designing Invisible AI Assistants: 7 Principles for Effective Agentic UX

This article outlines seven practical design principles for building agentic AI experiences that operate invisibly within existing workflows, emphasizing systemic thinking, seamless integration, proactive collaboration, contextual continuity, reuse of familiar patterns, timely data collection, and transparent human control.

Agentic AIContextual UIProduct Design
0 likes · 15 min read
Designing Invisible AI Assistants: 7 Principles for Effective Agentic UX
java1234
java1234
Feb 7, 2026 · Backend Development

Why Service Layer Should Not Return a Result Object in Java

The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.

Domain-Driven DesignException HandlingJava
0 likes · 13 min read
Why Service Layer Should Not Return a Result Object in Java
vivo Internet Technology
vivo Internet Technology
Feb 4, 2026 · Artificial Intelligence

Why Chat Mode Feels So Natural: The Secret of Intent‑Density Matching

The article explores how chat‑style AI interactions create a comfortable experience by aligning user intent density with AI understanding, introduces the concept of intent‑information density matching, compares chat with one‑click generation, examines successful patterns like cursor tab completion and Granola notes, and offers design guidelines for appropriate interaction densities.

AI interactionChat modeIntent density
0 likes · 10 min read
Why Chat Mode Feels So Natural: The Secret of Intent‑Density Matching
Woodpecker Software Testing
Woodpecker Software Testing
Jan 5, 2026 · User Experience Design

Comprehensive Usability Testing Framework: Six Core Dimensions and Practical Test Cases

This guide outlines a systematic six‑dimensional usability testing framework—including recognizability, learnability, operability, error protection, visual appeal, and accessibility—provides detailed test scenarios, concrete test‑case examples, expected metrics, a combined testing matrix, key success factors, and a real‑world enterprise collaboration software case study.

UX MetricsUser experienceaccessibility
0 likes · 15 min read
Comprehensive Usability Testing Framework: Six Core Dimensions and Practical Test Cases
Top Architect
Top Architect
Nov 15, 2025 · R&D Management

Why Most Developers Struggle to Become Software Architects

Most programmers never become architects because the role only fits a small fraction of teams, requires a system‑level mindset distinct from coding, and is limited by lack of real‑world architectural opportunities and the need for broader design thinking.

Career DevelopmentSoftware Architecturedesign principles
0 likes · 10 min read
Why Most Developers Struggle to Become Software Architects
Su San Talks Tech
Su San Talks Tech
Nov 2, 2025 · Fundamentals

Unraveling Complex Systems: Key Architecture Principles and Design Strategies

This article explains what constitutes a complex system, defines software architecture, explores various architecture types, outlines key design factors, presents analysis methods like DDD, and reviews typical solutions such as microservices, cloud‑native, DevOps, and big‑data architectures for building robust, scalable systems.

Complex SystemsDomain-Driven DesignMicroservices
0 likes · 16 min read
Unraveling Complex Systems: Key Architecture Principles and Design Strategies
Architect
Architect
Nov 1, 2025 · Fundamentals

What Makes a Complex System? Unveiling the Core Principles of Software Architecture

Complex systems are composed of many interacting components, and understanding their architecture—from business and application layers to technical, data, microservice, cloud‑native, and DevOps designs—requires grasping core principles, requirements, and design patterns that ensure reliability, scalability, and long‑term value.

Complex SystemsDomain-Driven DesignMicroservices
0 likes · 17 min read
What Makes a Complex System? Unveiling the Core Principles of Software Architecture
We-Design
We-Design
Oct 31, 2025 · Fundamentals

Why Effective Feedback Is the Secret to Seamless UI Interactions

This article explains why timely, clear, and appropriate feedback is essential for user interfaces, outlines a systematic process for identifying feedback nodes, classifying feedback types, and designing feedback expressions, and illustrates the approach with real‑world case studies from an AI voice‑cloning project.

Interaction DesignProduct DesignUI feedback
0 likes · 14 min read
Why Effective Feedback Is the Secret to Seamless UI Interactions
Architect
Architect
Oct 13, 2025 · R&D Management

Why Past Success Patterns Can Mislead Modern Architecture Design

The article argues that software architecture must be grounded in current conditions, not copied from past successes, and offers four practical recommendations on aligning design with implementation, market dynamics, team resources, and ecosystem considerations to ensure effective, adaptable product strategies.

R&D managementSoftware Architecturedesign principles
0 likes · 16 min read
Why Past Success Patterns Can Mislead Modern Architecture Design
Architect
Architect
Sep 26, 2025 · Backend Development

Refactor Payment Logic: Replace if‑else with Java Enums & Strategy

This article demonstrates how to replace cumbersome if‑else chains in payment processing with Java enums that encapsulate behavior, leveraging functional interfaces, the strategy pattern, and Spring integration to achieve cleaner, extensible, and testable code while adhering to the Open/Closed principle.

JavaStrategy Patternclean code
0 likes · 10 min read
Refactor Payment Logic: Replace if‑else with Java Enums & Strategy
IT Architects Alliance
IT Architects Alliance
Sep 19, 2025 · Fundamentals

Why Loose Coupling Is the Secret Sauce Behind Scalable Architecture

Loose coupling, a design principle that minimizes inter-component dependencies, enables scalable, testable, and flexible systems by using clear interfaces, event-driven architectures, API gateways, and service meshes, while also presenting trade‑offs such as added complexity, performance overhead, and consistency challenges in distributed environments.

MicroservicesScalabilitySoftware Architecture
0 likes · 12 min read
Why Loose Coupling Is the Secret Sauce Behind Scalable Architecture
High Availability Architecture
High Availability Architecture
Aug 28, 2025 · Fundamentals

5 Architecture Elements, 15 Design Principles & 6 Common Pitfalls

This article explains the essential components of software architecture—elements, structure, and connections—while presenting fifteen universal design principles, practical guidelines for monolithic, distributed, and microservice systems, and six common architectural mistakes to avoid, helping teams build scalable, reliable, and maintainable solutions.

Distributed SystemsMicroservicesScalability
0 likes · 21 min read
5 Architecture Elements, 15 Design Principles & 6 Common Pitfalls
Tencent Cloud Developer
Tencent Cloud Developer
Aug 27, 2025 · Fundamentals

Mastering Software Architecture: 15 Universal Principles, Common Pitfalls, and Evolution from Monolith to Microservices

This article explains the core concept of software architecture as elements, structure, and connections, distinguishes systems, subsystems, modules, components and frameworks, compares architecture classifications, describes the evolution from monolithic to distributed and microservice designs, presents fifteen practical design principles, and warns about six typical architectural pitfalls.

Distributed SystemsMicroservicesSoftware Architecture
0 likes · 23 min read
Mastering Software Architecture: 15 Universal Principles, Common Pitfalls, and Evolution from Monolith to Microservices
JD Cloud Developers
JD Cloud Developers
Aug 18, 2025 · Fundamentals

Boost Architecture Efficiency: Stability, Performance, and Clean Code Strategies

This article examines how software architecture can be made more efficient by focusing on three core dimensions—stability, performance, and code quality—offering practical insights, orthogonal design principles, and layered coding practices to achieve a robust, fast, and maintainable system.

Software Architecturecode qualitydesign principles
0 likes · 14 min read
Boost Architecture Efficiency: Stability, Performance, and Clean Code Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Jul 22, 2025 · Fundamentals

Why Good Software Architecture Is the Key to Solving Complex Business Problems

This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.

Domain-Driven DesignSoftware Architecturecomplexity management
0 likes · 47 min read
Why Good Software Architecture Is the Key to Solving Complex Business Problems
DataFunSummit
DataFunSummit
Jul 17, 2025 · Artificial Intelligence

Empowering Ethical AI: Multi-Agent Systems Design & Real-World Cases

In this talk, Lenovo HCI researcher Sun Jingwei explores how the rapid rise of large language models is shifting human‑computer interaction toward multi‑agent systems, presents two practical case studies—one enhancing cognitive diversity and another fostering emotional connection for seniors—and distills design principles and future AI‑for‑good directions.

AI AgentsAI for gooddesign principles
0 likes · 13 min read
Empowering Ethical AI: Multi-Agent Systems Design & Real-World Cases
Tencent Cloud Developer
Tencent Cloud Developer
Jul 2, 2025 · R&D Management

From Task Executor to Value Creator: Mastering the Full Development Lifecycle

This article guides engineers on evolving from merely executing requirements to creating business value by understanding the entire product lifecycle—covering requirement discovery, collaborative design, safe release, data‑driven operation, and continuous personal growth—offering practical questions and actionable principles for each stage.

Career GrowthR&D mindsetdesign principles
0 likes · 11 min read
From Task Executor to Value Creator: Mastering the Full Development Lifecycle
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Jun 15, 2025 · Fundamentals

Mastering Software Architecture: From Core Concepts to Practical Design Laws

The article explores the broad, evolving nature of software architecture, emphasizing the need for contextual thinking, continuous learning, and understanding of architecture styles, characteristics, decisions, and design principles, illustrated with diagrams and key laws that guide architects in balancing trade‑offs and focusing on why over how.

Software Architecturearchitectural thinkingarchitecture fundamentals
0 likes · 8 min read
Mastering Software Architecture: From Core Concepts to Practical Design Laws
php Courses
php Courses
May 30, 2025 · Backend Development

Design Principles, Best Practices, and Hidden Pitfalls of PHP Interfaces in 2025

This article examines the core design principles, modern best practices, and common hidden pitfalls of PHP interfaces in the 2025 ecosystem, providing concrete code examples and guidance on contract‑first design, single responsibility, interface segregation, dependency injection, versioning, testing, and advanced patterns such as adapters and plugin systems.

Backend DevelopmentInterfacesPHP
0 likes · 9 min read
Design Principles, Best Practices, and Hidden Pitfalls of PHP Interfaces in 2025
Architecture Breakthrough
Architecture Breakthrough
Mar 31, 2025 · Fundamentals

Why Mastering Abstraction Is the Real Skill Behind Great Software Design

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.

CohesionCouplingDomain-Driven Design
0 likes · 10 min read
Why Mastering Abstraction Is the Real Skill Behind Great Software Design
Ma Wei Says
Ma Wei Says
Mar 11, 2025 · Big Data

Mastering DWS Layer Design: Principles, Steps, and Best Practices

This article explains the role of the DWS layer in data warehouses, outlines design principles, step‑by‑step modeling, naming conventions, field design, provides concrete DDL/ETL examples, common pitfalls, and how to build reusable, performant summary tables for analytics.

Big DataDWS LayerData Warehouse
0 likes · 15 min read
Mastering DWS Layer Design: Principles, Steps, and Best Practices
Liangxu Linux
Liangxu Linux
Feb 23, 2025 · Fundamentals

Why Good Code Depends on Data Structures, Logic, and Control

The article explains that programming is fundamentally the combination of algorithms and data structures, breaks algorithms into control and logic, and argues that separating logic, control, and data—along with mastering essential design principles and data structures—is key to writing high‑quality, maintainable code.

Data StructuresSoftware Architecturealgorithm design
0 likes · 9 min read
Why Good Code Depends on Data Structures, Logic, and Control
Java Architect Essentials
Java Architect Essentials
Feb 23, 2025 · Backend Development

Designing a Modular Spring Boot Backend Management Project (XiaoLe)

This article explains how to design a modular Spring Boot backend management system called XiaoLe, covering essential design principles such as single responsibility, high cohesion, low coupling, reusability, clear interfaces, layered architecture, and testability, and provides detailed Maven module structures and POM configurations for each component.

Backend DevelopmentJavaSpring Boot
0 likes · 14 min read
Designing a Modular Spring Boot Backend Management Project (XiaoLe)
Tencent Cloud Developer
Tencent Cloud Developer
Dec 17, 2024 · Fundamentals

38 Practices for Managing Technical Debt and Improving Software Development

The article outlines 38 actionable practices—ranging from treating technical debt like a loan and emphasizing simple, well‑named code to rigorous code reviews, systematic refactoring, comprehensive testing, automation, clear documentation, continuous learning, professional conduct, and solid design principles—to help teams reduce debt, improve quality, and sustain long‑term software health.

Software Engineeringcode qualitydesign principles
0 likes · 37 min read
38 Practices for Managing Technical Debt and Improving Software Development
Architecture and Beyond
Architecture and Beyond
Oct 19, 2024 · R&D Management

How Consistent Architecture Prevents System Decay: Style, Solution, and Form

The article explains why architectural consistency—across style, implementation solutions, and formal design—is essential for preventing decay in evolving enterprise systems, and provides concrete practices such as unified patterns, standardized tech stacks, documentation, code reviews, and toolchain standardization to maintain flexibility and maintainability.

ConsistencyR&D managementSoftware Architecture
0 likes · 18 min read
How Consistent Architecture Prevents System Decay: Style, Solution, and Form
Architect
Architect
Sep 22, 2024 · Fundamentals

Understanding Software Architecture: Definitions, Vertical Layers, Three‑Layer, Four‑Layer, and Horizontal Designs

This article explains what software architecture means, breaks down its constituent elements such as systems, modules, components and subsystems, and then details vertical layered architectures (including three‑layer and four‑layer models), horizontal modular architectures, complexity evaluation, design principles, and cross‑platform considerations for modern mobile applications.

Software Architecturedesign principleslayered architecture
0 likes · 11 min read
Understanding Software Architecture: Definitions, Vertical Layers, Three‑Layer, Four‑Layer, and Horizontal Designs
DevOps
DevOps
Sep 19, 2024 · Fundamentals

Understanding Software Architecture: Concepts, Layers, and Design Principles

This article explains the fundamentals of software architecture, covering its definition, key components such as systems, modules, components, and subsystems, and explores vertical (layered) and horizontal (modular) architectures, design principles, complexity evaluation, cross‑platform considerations, and practical guidelines for building maintainable applications.

App DevelopmentLayered DesignSoftware Architecture
0 likes · 10 min read
Understanding Software Architecture: Concepts, Layers, and Design Principles
DevOps
DevOps
Sep 12, 2024 · Fundamentals

Advantages, Disadvantages, and Principles of Layered Architecture

This article examines the common benefits, drawbacks, and design principles of layered architecture across micro‑service, data‑warehouse, and protocol designs, illustrating each point with real‑world examples and offering practical guidance on when and how to apply layering effectively.

Data Warehousedesign principleslayered architecture
0 likes · 11 min read
Advantages, Disadvantages, and Principles of Layered Architecture
DevOps
DevOps
Jul 18, 2024 · Fundamentals

Architectural Thinking: Five Core Principles for Managing Complexity

The article explains architectural thinking as a systematic approach to decompose problems, highlighting five core principles—abstraction, global perspective, layered design, evolutionary mindset, and standardization—that help engineers manage complexity, improve design quality, and adapt software systems over time.

Software Architectureabstractioncomplexity management
0 likes · 10 min read
Architectural Thinking: Five Core Principles for Managing Complexity
58UXD
58UXD
Jul 15, 2024 · Artificial Intelligence

Unlocking AI Design: 23 Principles from Google & Microsoft for Smarter UX

This article introduces the key AI design principles from Google’s People + AI Guidebook and Microsoft’s Human‑Centred AI guidelines, covering explainability, privacy, user‑focused value, scenario‑based services, easy activation, and clear communication to help create intelligent, humane user experiences.

AI designdesign principlesexplainability
0 likes · 6 min read
Unlocking AI Design: 23 Principles from Google & Microsoft for Smarter UX
Cognitive Technology Team
Cognitive Technology Team
Jul 12, 2024 · Fundamentals

Ten Philosophical Principles of Operating System Design

The article outlines ten design philosophies for operating systems—covering correctness, functionality, efficiency, fairness, layered architecture, the relativity of right and wrong, lazy copying, burden allocation, reserved space, illusion of infinite memory, space‑time trade‑offs, policy‑mechanism separation, simplicity, and moderation—illustrated with real‑world software architecture examples.

Software Engineeringdesign principleslayered architecture
0 likes · 12 min read
Ten Philosophical Principles of Operating System Design
php Courses
php Courses
Jul 11, 2024 · Fundamentals

Understanding SOLID Principles with Java Examples

This article explains the five SOLID design principles—SRP, OCP, LSP, ISP, and DIP—detailing their definitions, common violations, and Java code examples that demonstrate how to refactor classes for better modularity, extensibility, and maintainability.

JavaObject-OrientedSOLID
0 likes · 7 min read
Understanding SOLID Principles with Java Examples
Qunhe Technology User Experience Design
Qunhe Technology User Experience Design
Jul 1, 2024 · Product Management

What Makes Productivity Tools Effective? Design Principles and Future Trends

This article explores the definition, core characteristics, design principles, and emerging trends of tool‑type products—especially productivity software—highlighting how clear purpose, stable frameworks, efficient interaction phases, AI integration, PLG strategies, and cloud collaboration shape their success.

design principlesproduct-managementproductivity tools
0 likes · 19 min read
What Makes Productivity Tools Effective? Design Principles and Future Trends
Tencent Cloud Developer
Tencent Cloud Developer
Jun 26, 2024 · Fundamentals

Why System Thinking and Architecture Matter: A Deep Dive into Complexity and Design

This article explores how a systematic, high‑dimensional view of software systems—covering system theory, architectural models like 4+1, C4 and TOGAF, micro‑service design, and the Cynefin complexity framework—helps developers move from code‑writing to strategic architecture while managing complexity.

C4 ModelCynefin frameworkMicroservices
0 likes · 21 min read
Why System Thinking and Architecture Matter: A Deep Dive into Complexity and Design
We-Design
We-Design
May 15, 2024 · Artificial Intelligence

6 Essential Design Principles for Generative AI Applications

This article outlines six core design principles—responsibility, mental‑model support, trustworthiness, diversity, co‑creation, and handling imperfection—each with practical strategies to help designers build safe, effective, and user‑centered generative AI experiences.

AI ethicsdesign principlesgenerative AI
0 likes · 11 min read
6 Essential Design Principles for Generative AI Applications
Big Data Technology & Architecture
Big Data Technology & Architecture
May 15, 2024 · Big Data

How to Effectively Answer Data Model Design Questions in Interviews

The article explains that data model design interview questions are open‑ended and lack a single correct answer, then outlines a structured approach covering model layering, domain division, naming conventions, and detailed design principles for dimension, detail, and summary layers, emphasizing real‑world scenarios and clear thinking.

business scenariodesign principles
0 likes · 5 min read
How to Effectively Answer Data Model Design Questions in Interviews
JD Tech
JD Tech
Feb 16, 2024 · Fundamentals

Understanding Software Architecture: Definitions, Boundaries, and Design Principles

This article explores the core concepts of software architecture, presenting various definitions from IEEE, Martin Fowler, Ralph Johnson and Neil Ford, and discusses architecture boundaries, the relationship between architecture and detailed design, patterns versus styles, and the knowledge models needed for architects and developers.

Architecture PatternsSoftware ArchitectureSoftware Engineering
0 likes · 16 min read
Understanding Software Architecture: Definitions, Boundaries, and Design Principles
21CTO
21CTO
Jan 25, 2024 · Fundamentals

Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design

This article explains how entropy, the broken‑window effect, and accumulated complexity erode software systems, compares behavior and architecture value dimensions, and presents fundamental principles such as Ockham's razor, SOLID, layering, and anti‑corruption layers to build maintainable, low‑cost architectures.

SOLIDSoftware Architecturecomplexity
0 likes · 17 min read
Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design
Architect
Architect
Jan 25, 2024 · Fundamentals

Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies

This article explains essential software architecture concepts such as entropy and broken‑window effects, the sources and symptoms of complexity, the importance of orthogonality and consistency, and classic design principles like SOLID, DRY, and layered abstraction to guide architects in building maintainable, flexible systems.

DRYLayered DesignMicroservices
0 likes · 18 min read
Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies
DevOps
DevOps
Jan 22, 2024 · Fundamentals

Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls

This article explains the fundamental concepts of software architecture, distinguishes between systems, subsystems, modules, components, frameworks and architectures, outlines the evolution from monolithic to distributed and micro‑service designs, presents fifteen universal design principles, and highlights typical mistakes architects should avoid.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 21 min read
Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls
VMIC UED
VMIC UED
Jan 18, 2024 · Frontend Development

Master Layout Design: 4 Essential Principles Every UI Designer Must Know

This article explains what layout design is, why it matters, and walks you through the four fundamental principles—contrast, alignment, grouping, and repetition—illustrated with real UI examples to help designers create clear, engaging, and visually balanced interfaces.

UI designdesign principlesfrontend
0 likes · 12 min read
Master Layout Design: 4 Essential Principles Every UI Designer Must Know
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 8, 2024 · Fundamentals

Master Diagramming: Design Principles to Make Your Tech Charts Stand Out

This guide shares practical methods for creating clear, attractive, and complete diagrams—covering code, architecture, business process, flow, and sequence charts—by applying four design principles, color‑wheel techniques, golden‑ratio composition, and an end‑to‑start mindset to improve developers’ visual communication.

DiagramSoftware Engineeringcolor theory
0 likes · 8 min read
Master Diagramming: Design Principles to Make Your Tech Charts Stand Out
DevOps
DevOps
Jan 2, 2024 · Fundamentals

Understanding Software Architecture: Principles, Design, and Practices

This article explores the fundamentals of software architecture, discussing entropy, the dual value of behavior and structure, core design principles such as SOLID, DRY, layering, orthogonality, component coupling, boundary definition, communication patterns, and modeling tools, while also offering practical guidance for building maintainable systems.

DRYSOLIDSoftware Architecture
0 likes · 18 min read
Understanding Software Architecture: Principles, Design, and Practices
Tencent Cloud Developer
Tencent Cloud Developer
Dec 21, 2023 · Fundamentals

Software Architecture Design: Principles, Complexity, and Best Practices

The article explains that good software architecture must be deliberately designed and continuously refactored to combat entropy and the broken‑window effect, balancing behavior and architecture value while managing complexity through principles like Ockham’s razor, orthogonality, DRY, stable dependencies, layered abstractions, and clear boundaries, supported by UML visualizations.

DRYSOLIDSoftware Architecture
0 likes · 19 min read
Software Architecture Design: Principles, Complexity, and Best Practices
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 19, 2023 · Fundamentals

Understanding Layered Architecture: Benefits, Drawbacks, and Implementation Guidelines

This article explains the concept of layered architecture in software systems, covering common patterns like MVC and three‑tier designs, illustrating examples from networking and operating systems, and discussing the advantages, design considerations, potential drawbacks, and practical guidelines for implementing effective layer separation.

BackendLayered DesignSystem Design
0 likes · 9 min read
Understanding Layered Architecture: Benefits, Drawbacks, and Implementation Guidelines
政采云技术
政采云技术
Nov 16, 2023 · Fundamentals

Comprehensive Guide to Software Architecture Design and Practices

This article provides an extensive overview of software architecture, covering its definition, history, core concepts, design principles, complexity sources, design process, performance, high availability, scalability, and practical implementation techniques for large‑scale web systems.

MicroservicesPerformance OptimizationScalability
0 likes · 24 min read
Comprehensive Guide to Software Architecture Design and Practices
php Courses
php Courses
Sep 23, 2023 · Backend Development

Applying SOLID Principles in PHP for Maintainable Code

This article explains how to use the SOLID design principles—SRP, OCP, LSP, ISP, and DIP—in PHP, providing clear bad and good code examples for each principle to help developers write more reliable, extensible, and maintainable backend applications.

BackendPHPSOLID
0 likes · 8 min read
Applying SOLID Principles in PHP for Maintainable Code
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 1, 2023 · Fundamentals

Mastering Software Analysis & Design: Logic, Methods, and Real‑World Cases

This article explains the logical framework of software analysis and design, outlines practical methods and principles, introduces essential UML tools, and demonstrates the concepts with two concrete case studies—a logging framework and a task‑scheduling framework—providing a complete guide for developers.

UMLdesign principleslogging framework
0 likes · 20 min read
Mastering Software Analysis & Design: Logic, Methods, and Real‑World Cases
Tech Architecture Stories
Tech Architecture Stories
Aug 15, 2023 · Cloud Native

Why ‘Microservice Design’ and ‘Systems Thinking’ Are Essential Reads for Architects

The author revisits two concise yet powerful books—‘Microservice Design’ and ‘Systems Thinking’—explaining how the former guides architects through microservice boundaries, deployment, and scaling, while the latter offers a systematic mindset for designing and governing complex software systems, making both indispensable for modern architects.

MicroservicesSoftware Architecturedesign principles
0 likes · 5 min read
Why ‘Microservice Design’ and ‘Systems Thinking’ Are Essential Reads for Architects
DaTaobao Tech
DaTaobao Tech
Aug 9, 2023 · Fundamentals

Understanding Domain-Driven Design: Principles, Challenges, and Practical Insights

The article likens blind adoption of Domain‑Driven Design to Forrest Gump’s run, explains how tangled business logic and over‑abstracted layers increase maintenance, shows DDD’s role in clarifying domains and mapping SOLID principles, offers practical tips for splitting responsibilities and building reusable capabilities, and concludes DDD is a valuable—not magical—lens for sustainable, extensible software.

DDDSoftware Architecturedesign principles
0 likes · 21 min read
Understanding Domain-Driven Design: Principles, Challenges, and Practical Insights
Tech Architecture Stories
Tech Architecture Stories
Aug 8, 2023 · Fundamentals

How Systems Theory Shapes Modern Software Architecture

Systems Theory, originating in the 1940s, provides a holistic framework for understanding and designing complex software architectures, emphasizing component interaction, feedback, and adaptability, with practical examples ranging from microservices and Kubernetes to chaos engineering, illustrating its impact on scalability, resilience, and modular design.

Cloud NativeMicroservicesSoftware Architecture
0 likes · 16 min read
How Systems Theory Shapes Modern Software Architecture
Architect
Architect
Aug 4, 2023 · Fundamentals

What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles

The article systematically defines software architecture, distinguishes systems, subsystems, modules, and components, compares frameworks with architectures, explores TOGAF and RUP classifications, traces the evolution from monoliths to micro‑services, and presents concrete design principles and common pitfalls for building scalable, maintainable systems.

MicroservicesScalabilitySoftware Architecture
0 likes · 25 min read
What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles
KooFE Frontend Team
KooFE Frontend Team
Jul 19, 2023 · Frontend Development

Transform UI Design with 16 Simple Rules for Better Usability

This article translates the "16 Little UI Design Rules" into practical guidelines, showing how applying spacing, consistency, contrast, typography, and accessibility principles can dramatically improve the usability and visual hierarchy of a short‑term rental property detail page.

UI designUsabilityaccessibility
0 likes · 16 min read
Transform UI Design with 16 Simple Rules for Better Usability
58UXD
58UXD
Jul 10, 2023 · Fundamentals

Master Nielsen’s 10 Usability Heuristics for Better UI Design

This article explains Jakob Nielsen’s ten usability principles—covering visibility, real‑world relevance, user control, consistency, error tolerance, easy access, flexibility, simplicity, problem‑solving help, and human‑centered assistance—to guide designers in creating intuitive, efficient user interfaces.

Nielsen heuristicsUsabilityUser experience
0 likes · 10 min read
Master Nielsen’s 10 Usability Heuristics for Better UI Design
Top Architect
Top Architect
Jun 20, 2023 · Fundamentals

Understanding Complex Systems and Software Architecture: Definitions, Classifications, and Design Principles

The article explains what constitutes a complex system, defines software architecture, outlines its essential elements, categorizes various architecture types, discusses key factors such as functional and non‑functional requirements, and presents design principles and typical solutions for building robust, scalable systems.

Cloud NativeComplex SystemsDomain-Driven Design
0 likes · 15 min read
Understanding Complex Systems and Software Architecture: Definitions, Classifications, and Design Principles
Architects' Tech Alliance
Architects' Tech Alliance
Jun 19, 2023 · Fundamentals

Understanding Complex Systems and Software Architecture: Definitions, Types, Principles, and Design Considerations

This article explains what complex systems and software architecture are, outlines various architectural categories, discusses essential functional and non‑functional requirements, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, DevOps, and big‑data architectures for building stable, scalable, and maintainable systems.

Big DataComplex SystemsDomain-Driven Design
0 likes · 13 min read
Understanding Complex Systems and Software Architecture: Definitions, Types, Principles, and Design Considerations
Architects Research Society
Architects Research Society
Jun 16, 2023 · Fundamentals

Understanding SOLID Principles in TypeScript

This article explains the five SOLID design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion—using clear TypeScript examples to show how each principle improves code maintainability and extensibility.

OOPSOLIDTypeScript
0 likes · 11 min read
Understanding SOLID Principles in TypeScript
phodal
phodal
Jun 14, 2023 · Industry Insights

What Are the Four Core Principles for LLM‑Powered Software Architecture?

This article outlines four foundational design principles—user‑intent‑driven design, context awareness, atomic capability mapping, and language‑API integration—for building LLM‑centric software architectures, illustrating each with DSL examples, Kotlin implementations, and practical insights on prompt engineering, dynamic context layering, and API evolution.

DSLLLMPrompt Engineering
0 likes · 10 min read
What Are the Four Core Principles for LLM‑Powered Software Architecture?
Code Ape Tech Column
Code Ape Tech Column
Jun 14, 2023 · Fundamentals

Understanding Complex Systems and Software Architecture: Principles, Types, and Design Considerations

This article explains what complex systems are, defines software architecture, explores its essence and classifications, outlines key architectural factors, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, and big‑data architectures.

Cloud NativeComplex SystemsDomain-Driven Design
0 likes · 14 min read
Understanding Complex Systems and Software Architecture: Principles, Types, and Design Considerations
Amap Tech
Amap Tech
May 18, 2023 · Fundamentals

Software Architecture Design: Principles, Patterns, and Practical Approaches

The article defines software architecture as a business‑driven abstraction of system structure, explains core design principles such as SOLID, Ockham’s Razor, DRY, YAGNI, KISS and POLA, illustrates LSP violations, surveys layered, hexagonal, onion and DDD styles, and shows how applying Dependency Inversion in a large C++ codebase yields a simple, maintainable, business‑aligned architecture.

DDDSOLIDSoftware Architecture
0 likes · 22 min read
Software Architecture Design: Principles, Patterns, and Practical Approaches
Zhaori User Experience
Zhaori User Experience
May 12, 2023 · Frontend Development

Mastering UI Shape Design: Icons, Cards, and Banners Explained

Explore the essential visual elements of UI shape design—including icon, card, and banner forms—by learning their definitions, key principles such as uniformity, semantics, balance, brand relevance, and innovation, and practical guidelines for creating effective, responsive, and engaging interfaces.

UI designbanner designcard design
0 likes · 10 min read
Mastering UI Shape Design: Icons, Cards, and Banners Explained
21CTO
21CTO
May 10, 2023 · Fundamentals

What Makes a System Complex? Unpacking Architecture Principles

This article explains what a complex system is, defines software architecture, explores its essence and classifications, and outlines the key factors, analysis methods, design principles, and typical solution patterns such as DDD, micro‑services, cloud‑native, DevOps, and big‑data architectures.

Complex SystemsDomain-Driven DesignMicroservices
0 likes · 16 min read
What Makes a System Complex? Unpacking Architecture Principles
Architecture Digest
Architecture Digest
Mar 21, 2023 · Fundamentals

Understanding and Controlling Software System Complexity

The article explains the definition of complexity, analyzes its causes and how they manifest in software systems through scale and structure, and proposes domain‑driven design techniques such as bounded contexts, layered architecture, and change‑boxing to manage and reduce software complexity.

System Architecturecomplexity managementdesign principles
0 likes · 8 min read
Understanding and Controlling Software System Complexity
Alipay Experience Technology
Alipay Experience Technology
Mar 14, 2023 · Frontend Development

Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques

This article explains why maintainable, robust, and testable code is essential for front‑end development, shares insights from renowned programmers, defines key quality metrics, outlines SOLID and KISS design principles, identifies common code smells, and demonstrates practical refactoring patterns with real JavaScript examples.

KISSSOLIDSoftware Engineering
0 likes · 35 min read
Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques
政采云技术
政采云技术
Feb 23, 2023 · Fundamentals

Understanding Load Theory in Design: Visual, Action, and Cognitive Load

This article introduces load theory, explains the three common types of load—visual, action, and cognitive—illustrates how designers can reduce, increase, or transform these loads based on design goals and user scenarios, and emphasizes prioritizing cognitive load reduction when trade‑offs are needed.

User experienceaction loaddesign principles
0 likes · 2 min read
Understanding Load Theory in Design: Visual, Action, and Cognitive Load
Architect's Guide
Architect's Guide
Feb 10, 2023 · Fundamentals

The Inevitability of Complexity in Software Design

The essay argues that complexity is an unavoidable, persistent element of software development that cannot be eliminated but must be managed, illustrating this through reflections on build tools, design trade‑offs, resilience engineering, and the need to acknowledge and strategically place complexity within systems.

Resilience Engineeringdesign principlessoftware complexity
0 likes · 10 min read
The Inevitability of Complexity in Software Design
ITPUB
ITPUB
Jan 19, 2023 · Backend Development

16 Essential Principles for Designing, Implementing, and Governing Microservices

This article outlines a seven‑stage microservice lifecycle and presents sixteen practical principles covering planning, design, implementation, invocation, release, governance, scaling, and deprecation to help architects build robust, maintainable microservice systems.

Microservicesarchitecturedesign principles
0 likes · 11 min read
16 Essential Principles for Designing, Implementing, and Governing Microservices
Programmer DD
Programmer DD
Dec 26, 2022 · Fundamentals

20 Essential Software Architecture Principles Every Engineer Should Master

This article presents a concise overview of twenty core software architecture principles—from Dependency Inversion and Separation of Concerns to KISS and Incremental Development—explaining each concept, its purpose, and providing Java code examples to illustrate practical application.

EncapsulationSOLIDSoftware Architecture
0 likes · 12 min read
20 Essential Software Architecture Principles Every Engineer Should Master
Architect's Guide
Architect's Guide
Dec 26, 2022 · Fundamentals

Software Architecture Principles: A Guide for Architects

This article presents a comprehensive overview of essential software architecture principles—including Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, SOLID rules, and more—explaining their purpose, practical impact, and providing Java code examples to illustrate their application in real projects.

Object-OrientedSOLIDSoftware Architecture
0 likes · 11 min read
Software Architecture Principles: A Guide for Architects
Architects Research Society
Architects Research Society
Dec 23, 2022 · Fundamentals

Fundamentals of Software Design: Concepts, Principles, and Modeling Languages

Software design is a systematic process that defines specifications, architectures, and components to solve problems, covering concepts such as abstraction, modularity, design principles, modeling languages, and considerations like scalability, maintainability, and security, providing a comprehensive overview of essential design practices and patterns.

Software ArchitectureSoftware Engineeringdesign principles
0 likes · 15 min read
Fundamentals of Software Design: Concepts, Principles, and Modeling Languages
政采云技术
政采云技术
Dec 15, 2022 · Frontend Development

Visual Hierarchy: Building Effective Information Architecture for UI Design

Visual hierarchy is fundamental to building effective information architecture, helping designers structure and organize interface elements through size, color, contrast, spacing, proximity, and weight to create clear, professional, and visually appealing pages.

UI designdesign principlesinformation architecture
0 likes · 2 min read
Visual Hierarchy: Building Effective Information Architecture for UI Design
Architect's Guide
Architect's Guide
Dec 13, 2022 · Fundamentals

Complexity Must Exist Somewhere: Reflections on Software Architecture and Design

The article argues that complexity is an unavoidable aspect of software development that cannot be eliminated, only managed or transferred, and discusses how design choices, build‑tool trade‑offs, and knowledge models influence the way engineers cope with inevitable complexity.

Resilience EngineeringSoftware Architecturecomplexity management
0 likes · 7 min read
Complexity Must Exist Somewhere: Reflections on Software Architecture and Design
21CTO
21CTO
Dec 6, 2022 · Fundamentals

Master the 23 Core Software Architecture Principles Every Engineer Should Know

This article presents a concise overview of 23 essential software architecture principles—from Dependency Inversion and Separation of Concerns to Bounded Context and KISS—explaining each concept, its practical impact, and providing code examples to help developers design clean, maintainable systems.

SOLIDSoftware Architectureclean code
0 likes · 12 min read
Master the 23 Core Software Architecture Principles Every Engineer Should Know
IT Architects Alliance
IT Architects Alliance
Dec 5, 2022 · Fundamentals

Essential Software Architecture Principles with Example Implementations

This article outlines core software architecture principles such as Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, Single Responsibility, DRY, Open‑Closed, Persistence Ignorance, and many others, and illustrates them with Java code examples for actions and converters.

SOLIDSoftware Architecturedependency-injection
0 likes · 11 min read
Essential Software Architecture Principles with Example Implementations
Top Architect
Top Architect
Dec 5, 2022 · Fundamentals

Essential Software Architecture Principles Explained by a Senior Architect

The article presents a concise overview of core software architecture principles—including Dependency Inversion, Separation of Concerns, Inversion of Control, Dependency Injection, Single Responsibility, DRY, Open‑Closed, and many others—supplemented with Java code examples and references for deeper study.

Dependency InversionInversion of Controlclean code
0 likes · 12 min read
Essential Software Architecture Principles Explained by a Senior Architect
IT Architects Alliance
IT Architects Alliance
Nov 24, 2022 · Fundamentals

Why Code Reuse Often Fails to Improve Efficiency in System Design

The article examines the common belief that reusing code and components boosts productivity, explains the flawed reasoning behind it, highlights the hidden costs of excessive abstraction, and proposes autonomy and consistency metrics as guidelines for sensible system design.

ConsistencySoftware Architectureautonomy
0 likes · 9 min read
Why Code Reuse Often Fails to Improve Efficiency in System Design
The Dominant Programmer
The Dominant Programmer
Nov 1, 2022 · Fundamentals

Understanding SOLID Design Principles with Java Code Examples

This article explains the seven SOLID software design principles—Open‑Closed, Dependency Inversion, Single Responsibility, Interface Segregation, Law of Demeter, Liskov Substitution, and Composite/Reuse—illustrating each rule with clear Java code snippets, refactorings, and practical scenarios such as product pricing, purchasing workflows, and database access.

Dependency InversionJavaObject-Oriented
0 likes · 17 min read
Understanding SOLID Design Principles with Java Code Examples
Architect
Architect
Oct 30, 2022 · Fundamentals

Managing Complexity in Software Architecture

The article argues that complexity in software systems is unavoidable and must be consciously placed, managed, and reduced through thoughtful architectural decisions, prioritizing high‑frequency changes, eliminating duplication, and accepting that perfect local consequences are impossible.

Software Architecturecode organizationcomplexity
0 likes · 9 min read
Managing Complexity in Software Architecture
Architect
Architect
Oct 29, 2022 · Fundamentals

Embracing Complexity: Reflections on Software Architecture

The article argues that complexity is an unavoidable aspect of software development and architecture, urging engineers to acknowledge, manage, and strategically place it rather than trying to eliminate it, while illustrating the trade‑offs in tooling, abstractions, and micro‑service design.

MicroservicesResilience EngineeringSoftware Architecture
0 likes · 7 min read
Embracing Complexity: Reflections on Software Architecture
Programmer DD
Programmer DD
Oct 8, 2022 · Fundamentals

Eight Timeless Computer Architecture Principles Every Designer Should Know

This article outlines eight enduring ideas—from designing for Moore's Law and using abstraction to speeding up common cases, leveraging parallelism, pipelining, prediction, memory hierarchy, and redundancy—that have shaped computer architecture over the past six decades.

Moore's LawParallelismPipeline
0 likes · 11 min read
Eight Timeless Computer Architecture Principles Every Designer Should Know
Top Architect
Top Architect
Sep 27, 2022 · Fundamentals

Fundamentals of Software Architecture: Concepts, Layers, and Classifications

This article provides a comprehensive overview of software architecture, defining core concepts such as system, subsystem, module, component, framework, and architecture itself, and detailing the various layers—including business, application, data, code, technical, and deployment architectures—along with their design principles and practical considerations.

ModulesSoftware ArchitectureSystem Design
0 likes · 9 min read
Fundamentals of Software Architecture: Concepts, Layers, and Classifications
政采云技术
政采云技术
Sep 22, 2022 · Fundamentals

Applying User Psychology to Industrial Design for Better User Experience

The article explains how understanding user psychology—such as perception, reading, and memory—can guide industrial design to create more satisfying experiences, improve retention, and increase software activity by aligning design elements with users' mental expectations.

User experiencecognitive psychologydesign principles
0 likes · 3 min read
Applying User Psychology to Industrial Design for Better User Experience
Architect's Guide
Architect's Guide
Sep 13, 2022 · Fundamentals

30 Architectural Principles for Software Engineers

The article presents thirty concise architectural principles covering simplicity, iterative development, automation, ROI, user focus, concurrency, distributed system design, configuration management, and practical guidance, aiming to help architects and developers build maintainable, scalable, and user‑centric software systems.

Backend DevelopmentSoftware Architecturedesign principles
0 likes · 11 min read
30 Architectural Principles for Software Engineers
58UXD
58UXD
Aug 25, 2022 · Fundamentals

How Modular Design Boosts Agile Online‑Offline Product Iteration

This article explains the origins and principles of modular design, outlines its four key attributes—agility, flexibility, richness, and extensibility—and demonstrates how applying a modular approach can accelerate product updates and improve user experiences across online and offline scenarios through real‑world case studies.

Agile DevelopmentCase StudyUX methodology
0 likes · 10 min read
How Modular Design Boosts Agile Online‑Offline Product Iteration
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 22, 2022 · Fundamentals

Key Principles for Code Review and Software Architecture

This extensive article discusses essential software engineering concepts such as code review value, architectural principles, SOLID, dependency inversion, documentation practices, testing strategies, and practical guidelines for writing maintainable, decoupled, and self‑explanatory code across various programming languages.

Dependency InversionGolangSOLID
0 likes · 44 min read
Key Principles for Code Review and Software Architecture
Architect
Architect
Aug 14, 2022 · Databases

42 Lessons Learned from Building a Production Database – Translated Summary

This article translates Mahesh Balakrishnan’s 42 practical lessons on building a production database, covering customer focus, project management, design principles, code review, strategy, observability, and research, offering actionable guidance for infrastructure engineers and architects.

InfrastructureSoftware Architecturedesign principles
0 likes · 12 min read
42 Lessons Learned from Building a Production Database – Translated Summary