BestHub
Sign in
Tagged articles

Software Architecture

1324 articles · Page 4 of 14
Java Tech Enthusiast
Java Tech Enthusiast
Feb 27, 2025 · Artificial Intelligence

Navigating the AI Era: Insights for Senior Engineers and R&D Leaders

A senior technical leader, reflecting on twelve years at a large tech firm, warns that while AI can triple a junior’s output in tasks like refactoring, it cannot replace deep business insight, strategic decision‑making, or mentorship, and urges engineers to treat AI as a helper, focus on high‑level architecture, and expand horizontally into business domains to stay indispensable.

AIProductivitySoftware Architecture
0 likes · 5 min read
Navigating the AI Era: Insights for Senior Engineers and R&D Leaders
Top Architecture Tech Stack
Top Architecture Tech Stack
Feb 27, 2025 · Fundamentals

Understanding the Facade Design Pattern and Its Application in Spring Boot

This article explains the Facade design pattern, illustrating its purpose of simplifying complex systems with real‑world analogies, detailing its benefits, showing UML class diagram relationships, and providing a comprehensive Spring Boot example that encapsulates flight, hotel, and package services behind a BookingFacade, while also including promotional content for IDE licenses.

Design PatternsFacade PatternSoftware Architecture
0 likes · 15 min read
Understanding the Facade Design Pattern and Its Application in Spring Boot
Top Architect
Top Architect
Feb 26, 2025 · Fundamentals

Fundamentals of Software Modeling and Design Documentation

This article introduces the basics of software modeling and design documentation, explaining UML diagram types such as class, sequence, component, and deployment diagrams, and outlines how architects use these models throughout requirement analysis, high‑level design, and detailed design, while also promoting a community and related resources.

Software ArchitectureUMLdesign documentation
0 likes · 17 min read
Fundamentals of Software Modeling and Design Documentation
Architect's Guide
Architect's Guide
Feb 26, 2025 · Backend Development

Why Microservices Are More About Organizational Structure Than Pure Technology

The article critically examines the hype around microservices, arguing that their true value lies in promoting modularity, clear ownership, and organizational clarity rather than solving inherent technical problems, and it traces these ideas back to classic software engineering principles and modern operational challenges.

ModularitySoftware Architecturedistributed systems
0 likes · 22 min read
Why Microservices Are More About Organizational Structure Than Pure Technology
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 StructuresDesign PrinciplesProgramming Fundamentals
0 likes · 9 min read
Why Good Code Depends on Data Structures, Logic, and Control
Software Engineering 3.0 Era
Software Engineering 3.0 Era
Feb 13, 2025 · Industry Insights

Why the 35‑Year IT ‘Crisis’ Is Over: Age Becomes a New Advantage in the AI Era

The article argues that the long‑standing "35‑year crisis" for IT professionals is disappearing as AI amplifies senior engineers' expertise, turning age into a strategic asset for complex system design, cross‑disciplinary collaboration, and leadership in an increasingly automated software landscape.

AISoftware Architectureautomation
0 likes · 10 min read
Why the 35‑Year IT ‘Crisis’ Is Over: Age Becomes a New Advantage in the AI Era
Java Tech Enthusiast
Java Tech Enthusiast
Feb 13, 2025 · Backend Development

Facade Design Pattern with Spring Boot Example

The article explains the Facade design pattern and demonstrates its use in a Spring Boot travel‑booking application, where a BookingFacade aggregates FlightService, HotelService, and PackageService to provide a single bookTravel method that a REST controller calls, simplifying the API and reducing coupling.

Design PatternsFacade PatternJava
0 likes · 12 min read
Facade Design Pattern with Spring Boot Example
Code Mala Tang
Code Mala Tang
Feb 10, 2025 · R&D Management

How to Build a 24‑Book AI‑Curated Reading List for Architecture & Management

This article explains how the author used the AI model DeepSeek to generate a curated 24‑book reading list—12 essential software architecture classics and 12 must‑read technical management titles—while sharing prompts, insights, and a recommended guide to mastering DeepSeek itself.

AIBook RecommendationsSoftware Architecture
0 likes · 6 min read
How to Build a 24‑Book AI‑Curated Reading List for Architecture & Management
IT Architects Alliance
IT Architects Alliance
Feb 5, 2025 · Backend Development

Understanding Microservice Architecture: Core Advantages, Use Cases, and Challenges

Microservice architecture decomposes large applications into independent services, offering agile development, strong scalability, fault tolerance, diverse technology choices, and efficient team collaboration, while also presenting operational complexity, latency, and interface management challenges that can be mitigated through automation, containerization, and robust design practices.

Software Architecture
0 likes · 13 min read
Understanding Microservice Architecture: Core Advantages, Use Cases, and Challenges
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 15, 2025 · Fundamentals

Unlocking Domain-Driven Design: Core Concepts and Strategic Patterns

This article condenses the key concepts of Domain‑Driven Design, covering building blocks, layered architecture, entities, value objects, services, aggregates, factories, repositories, specifications, supple design principles, strategic design patterns, distillation techniques, and large‑scale structural considerations, illustrated with diagrams for clear understanding.

Core ConceptsDomain-Driven DesignSoftware Architecture
0 likes · 15 min read
Unlocking Domain-Driven Design: Core Concepts and Strategic Patterns
IT Architects Alliance
IT Architects Alliance
Jan 12, 2025 · Cloud Native

Unlocking Cloud‑Native Success: Microservices, Containers & DevOps Explained

The article explores how cloud‑native architecture—driven by microservices, containerization, and DevOps—empowers enterprises to achieve greater agility, scalability, and operational efficiency, detailing core principles, real‑world examples such as Netflix, common challenges, and practical tools for implementation and security.

ContainersDevOpsSoftware Architecture
0 likes · 18 min read
Unlocking Cloud‑Native Success: Microservices, Containers & DevOps Explained
JD Retail Technology
JD Retail Technology
Jan 3, 2025 · Backend Development

Improving Software Architecture Efficiency: Stability, Performance, and Code Quality

Improving software architecture efficiency requires stable, orthogonal module design, performance‑focused refactoring that avoids tactical shortcuts, and disciplined layered code that balances business and domain responsibilities, while fostering modularization, decoupling, strict quality standards, and a collaborative culture of continuous improvement.

Software Architecturebackend designsystem stability
0 likes · 12 min read
Improving Software Architecture Efficiency: Stability, Performance, and Code Quality
21CTO
21CTO
Jan 1, 2025 · Backend Development

Monolith vs Microservices: Which Architecture Fits Your Project?

This article compares monolithic and microservice architectures, outlining their advantages, disadvantages, and ideal use‑cases, helping developers decide which approach aligns best with project size, team structure, scalability needs, and long‑term maintenance goals.

Software Architecturebackendmicroservices
0 likes · 6 min read
Monolith vs Microservices: Which Architecture Fits Your Project?
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

Comprehensive Introduction to Domain-Driven Design (DDD)

This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.

DDDDesign PatternsDomain-Driven Design
0 likes · 6 min read
Comprehensive Introduction to Domain-Driven Design (DDD)
MoonWebTeam
MoonWebTeam
Dec 26, 2024 · Frontend Development

From Von Neumann to Flutter: Tracing the Evolution of Cross‑Platform Development

This article surveys the history of cross‑platform development—from early computer architectures and the birth of high‑level languages, through web standards, hybrid mobile frameworks, mini‑program ecosystems, and modern native‑rendering solutions—highlighting how abstraction layers enable code reuse across diverse devices and operating systems.

FrameworksSoftware Architecturecross-platform
0 likes · 28 min read
From Von Neumann to Flutter: Tracing the Evolution of Cross‑Platform Development
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 23, 2024 · Fundamentals

Mastering Domain-Driven Design: A Complete Guide to DDD Principles

This article provides a comprehensive introduction to Domain‑Driven Design (DDD), covering its origins, core principles, layered architecture, key concepts such as entities, value objects, aggregates, bounded contexts, and how DDD improves communication and maintainability in complex software systems.

Domain-Driven DesignSoftware ArchitectureValue Object
0 likes · 6 min read
Mastering Domain-Driven Design: A Complete Guide to DDD Principles
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 20, 2024 · Backend Development

State Machine Selection and Refactoring Strategies for Complex Business Scenarios

This article analyzes the problem of exploding state‑branch logic in merchant onboarding and exit flows, presents decoupling, design‑pattern, and state‑machine solutions, compares three Java state‑machine implementations (Zhuozhou, Cola, Spring Statemachine), and offers practical selection guidance for simple to highly complex B2B use cases.

RefactoringSoftware Architecturestate machine
0 likes · 21 min read
State Machine Selection and Refactoring Strategies for Complex Business Scenarios
Architect
Architect
Nov 26, 2024 · Fundamentals

Mastering Software Design Docs: From UML Modeling to Architecture Blueprints

This article explains the fundamentals of software design documentation, covering why modeling is essential, how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases, and how architects tailor documents for different stakeholders.

Software ArchitectureSystem DesignUML
0 likes · 15 min read
Mastering Software Design Docs: From UML Modeling to Architecture Blueprints
Top Architect
Top Architect
Nov 20, 2024 · Fundamentals

Designing Effective Software Architecture Diagrams: Concepts, Types, and the C4 Model

This article explains the fundamental concepts of software architecture and architecture diagrams, outlines what makes a good diagram, describes common pitfalls, and introduces the C4 modeling approach with concrete examples such as system context, container, component, and class diagrams, providing practical guidance for clear communication of system designs.

C4 modelSoftware ArchitectureSystem Design
0 likes · 13 min read
Designing Effective Software Architecture Diagrams: Concepts, Types, and the C4 Model
phodal
phodal
Nov 17, 2024 · Industry Insights

How ArchGuard’s Architecture Analyzer Turns Code into AI‑Generated Knowledge

This article explains how ArchGuard’s Architecture Analyzer extracts domain and business knowledge from microservice codebases, integrates generative AI to produce structured documentation, and provides practical CLI usage, architecture models, and code‑review strategies for modern software engineering teams.

AIArchGuardCLI
0 likes · 9 min read
How ArchGuard’s Architecture Analyzer Turns Code into AI‑Generated Knowledge
Architecture Digest
Architecture Digest
Nov 15, 2024 · Fundamentals

Partial vs. Full Architectural Boundaries: Strategies and Trade‑offs

The article discusses the high cost of building complete architectural boundaries, explores why architects may deliberately leave room for future boundaries, and presents three practical approaches—incomplete boundaries, one‑way boundaries, and façade patterns—illustrating their benefits, drawbacks, and implementation considerations.

FitNesseSoftware Architectureboundary design
0 likes · 7 min read
Partial vs. Full Architectural Boundaries: Strategies and Trade‑offs
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 15, 2024 · Frontend Development

Front‑End Design Patterns in JavaScript: Creational, Structural, and Behavioral

This article introduces front‑end design patterns, explains the three main categories—creational, structural, and behavioral—lists ten common JavaScript patterns, and provides clear explanations and runnable code examples for each pattern to improve code readability, maintainability, and scalability.

BehavioralCreationalSoftware Architecture
0 likes · 16 min read
Front‑End Design Patterns in JavaScript: Creational, Structural, and Behavioral
Python Programming Learning Circle
Python Programming Learning Circle
Nov 13, 2024 · Backend Development

Using Pluggy and Stevedore for Python Plugin Development

This article explains Python plugin architecture, introducing pluggy and stevedore frameworks, showing how to define hook specifications, implement plugins, register them via entry points, and use driver or extension managers to load and invoke plugins in backend applications.

PluggyPluginSoftware Architecture
0 likes · 13 min read
Using Pluggy and Stevedore for Python Plugin Development
Practical DevOps Architecture
Practical DevOps Architecture
Nov 5, 2024 · Backend Development

Comprehensive Video Series on Software Architecture for Aspiring Architects

This extensive series of 50 video lessons covers fundamental and advanced topics such as technology selection, capacity planning, micro‑service design, database scaling, caching strategies, load balancing, decoupling, layering, and service mesh, providing engineers with the knowledge needed to become proficient architects.

Database ScalingSoftware Architecturebackend development
0 likes · 6 min read
Comprehensive Video Series on Software Architecture for Aspiring Architects
Tencent Cloud Developer
Tencent Cloud Developer
Oct 31, 2024 · Backend Development

Monolith vs Microservices: Evolution of Architecture and How to Choose

The article traces software architecture from early distributed systems through monoliths, SOA, microservices and serverless, explaining why each paradigm arose, the trade‑offs they entail, and how to decide between monolith and microservices based on team size, expertise, organizational structure, and business needs.

Software ArchitectureSystem Designdistributed systems
0 likes · 25 min read
Monolith vs Microservices: Evolution of Architecture and How to Choose
Architecture and Beyond
Architecture and Beyond
Oct 26, 2024 · R&D Management

Managing Scale in Software Development: Strategies for Production and Development

The article explains how software teams can handle growing production and development scale by applying systematic architectural designs, cloud‑native infrastructure, automation, CI/CD pipelines, and disciplined team and technical‑debt management to maintain efficiency, stability, and quality as the organization expands.

CI/CDCloud ComputingSoftware Architecture
0 likes · 18 min read
Managing Scale in Software Development: Strategies for Production and Development
Java Tech Enthusiast
Java Tech Enthusiast
Oct 24, 2024 · Fundamentals

Technology Development Trends from the 1970s to the 2020s

From the 1970s structured programming and ARPANET to today’s AI‑driven development, each decade introduced pivotal shifts—object‑orientation, client‑server and web architectures, service‑oriented and cloud‑native micro‑services, containers, DevOps, big‑data tools, and mobile protocols—creating a continual learning challenge known as the 35‑year programmer crisis.

Programming ParadigmsSoftware ArchitectureTechnology Trends
0 likes · 9 min read
Technology Development Trends from the 1970s to the 2020s
JD Retail Technology
JD Retail Technology
Oct 24, 2024 · Interview Experience

From Hello World to AI‑Powered Unit Tests: JD Retail Engineers Share Their Journeys

Eight JD Retail engineers recount their career paths, technical challenges, and personal philosophies, covering topics such as data‑flow tooling, large‑scale architecture refactoring, product‑centric design, AI‑driven unit‑test generation, and the enduring passion that drives their work in software development.

AI testingJD RetailSoftware Architecture
0 likes · 13 min read
From Hello World to AI‑Powered Unit Tests: JD Retail Engineers Share Their Journeys
DaTaobao Tech
DaTaobao Tech
Oct 21, 2024 · Fundamentals

The True Purpose of Classes and Functions: Beyond Reuse

The article argues that classes and functions serve as fundamental structural elements rather than mere tools for reuse, contending that excessive reuse can increase complexity while intentional redundancy simplifies maintenance, and advocating deep modules over shallow ones, illustrated by examples from Supercell, DingTalk, and a trivial shallow‑module code snippet.

DDDDRY principleSoftware Architecture
0 likes · 8 min read
The True Purpose of Classes and Functions: Beyond Reuse
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.

Design PrinciplesR&D managementSoftware Architecture
0 likes · 18 min read
How Consistent Architecture Prevents System Decay: Style, Solution, and Form
Java Architect Essentials
Java Architect Essentials
Oct 13, 2024 · Backend Development

Patent on a SpringBoot-Based Web System Backend Implementation Method and Device

The Chinese Patent Office announced that Industrial and Commercial Bank of China obtained patent CN112905176B for a SpringBoot-based web system backend implementation method and device, which details a process of receiving operation data, extracting business and object IDs, retrieving configuration, forming conditional expressions, and processing data to reduce development changes and improve system stability.

Software ArchitectureWebbackend
0 likes · 3 min read
Patent on a SpringBoot-Based Web System Backend Implementation Method and Device
DaTaobao Tech
DaTaobao Tech
Oct 11, 2024 · Fundamentals

Rethinking Code Reuse: Balancing DRY, YAGNI, and Maintenance Costs

The article argues that while code reuse and DRY can boost productivity, over‑abstracted, duplicated logic often inflates maintenance costs, so developers should apply DRY cautiously, favor YAGNI and heuristics like the Rule of Three, and prefer clean‑architecture boundaries to keep complexity manageable.

DRY principleSoftware ArchitectureYAGNI
0 likes · 12 min read
Rethinking Code Reuse: Balancing DRY, YAGNI, and Maintenance Costs
JD Tech Talk
JD Tech Talk
Oct 9, 2024 · Operations

What Is RPA? Advantages, Applications, Architecture, and Future Outlook

This article explains Robotic Process Automation (RPA), its cost‑saving and efficiency benefits, common use cases such as private‑domain operations, HR and e‑commerce, the business and technical architecture of a large‑scale RPA system, Android accessibility service fundamentals, sample code, and future AI‑driven enhancements.

AI integrationAndroid accessibilityRPA
0 likes · 12 min read
What Is RPA? Advantages, Applications, Architecture, and Future Outlook
macrozheng
macrozheng
Sep 26, 2024 · Cloud Native

Why 2023 Marks the Decline of Microservices: Lessons from Google, Amazon, and Others

In 2023, leading tech firms like Google and Amazon publicly questioned the microservice paradigm, revealing performance, cost, and complexity drawbacks, and showcasing a shift toward monolithic or runtime‑driven architectures that promise lower latency, reduced expenses, and simpler scaling.

Software Architecturecloud-nativemonolith
0 likes · 11 min read
Why 2023 Marks the Decline of Microservices: Lessons from Google, Amazon, and Others
JD Retail Technology
JD Retail Technology
Sep 25, 2024 · Big Data

From a Personal Journey to Data Platform Architecture: Insights on Big Data, Cloud Computing, and System Design

The article narrates the author’s 30‑year programming career and shares technical reflections on building business‑agnostic, configurable data platforms, covering batch, streaming, interactive computing, big‑data sharding, Spark, Flink, cloud migration, and the philosophy of software architecture.

Batch ProcessingCloud ComputingSoftware Architecture
0 likes · 23 min read
From a Personal Journey to Data Platform Architecture: Insights on Big Data, Cloud Computing, and System Design
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 23, 2024 · Fundamentals

Understanding UML Deployment Diagrams

This article explains the purpose, components, and relationships of UML deployment diagrams, illustrates a basic deployment example with client, web, application, and database nodes, and provides visual references while also promoting additional architecture resources from the author.

Software ArchitectureSystem DesignUML
0 likes · 5 min read
Understanding UML Deployment Diagrams
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.

Design PrinciplesModular ArchitectureSoftware 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 DevelopmentDesign PrinciplesModularization
0 likes · 10 min read
Understanding Software Architecture: Concepts, Layers, and Design Principles
Architecture and Beyond
Architecture and Beyond
Sep 14, 2024 · R&D Management

How Does Technical Debt Affect Development Costs and What Strategies Can Tame It?

This article explains the concept of technical debt, its various classifications, the distinct impacts on front‑end and back‑end development, the multi‑dimensional cost consequences, and practical governance methods—including identification, prioritisation, repayment planning and preventive measures—to help teams manage and reduce debt effectively.

R&D managementSoftware Architecturebackend
0 likes · 30 min read
How Does Technical Debt Affect Development Costs and What Strategies Can Tame It?
FunTester
FunTester
Sep 14, 2024 · R&D Management

Why Does Software Architecture Turn Into a Nightmare and How to Fix It

The article examines why software architectures become tangled—citing resource constraints, poor organization, unmanaged technical debt, outdated tech, and missing documentation—and offers practical strategies such as background analysis, continuous refactoring, training, communication, design‑pattern adoption, engineering culture, and comprehensive testing to restore health.

RefactoringSoftware Architectureengineering culture
0 likes · 25 min read
Why Does Software Architecture Turn Into a Nightmare and How to Fix It
Top Architect
Top Architect
Sep 12, 2024 · Fundamentals

Understanding SPI vs API: Interface Placement and Design Principles

The article explains the distinction between Service Provider Interfaces (SPI) and Application Programming Interfaces (API), discusses three possible package placements for interfaces, outlines rules and advantages of each, and provides guidance on choosing between SPI and API based on extensibility, interaction, and stability.

APISPISoftware Architecture
0 likes · 9 min read
Understanding SPI vs API: Interface Placement and Design Principles
Architect
Architect
Sep 5, 2024 · R&D Management

Mastering UML Architecture Diagrams: When and How to Use Each Type

This article explains why architecture diagrams are essential for software engineers, introduces the seven most common UML diagram types, and provides practical guidance on selecting and applying each diagram during requirements analysis, high‑level design, and detailed design phases.

Design DiagramsR&D managementSoftware Architecture
0 likes · 12 min read
Mastering UML Architecture Diagrams: When and How to Use Each Type
JD Tech
JD Tech
Sep 5, 2024 · Fundamentals

Overview of System Complexity and Strategies for Reducing Business Complexity

The article explains what software complexity is, classifies its types, describes the negative impacts of high business complexity, identifies common causes, and presents practical methods such as domain decomposition, layered architecture, structured decomposition, annotation, configurability, and coding standards to effectively reduce complexity.

Code RefactoringComplexityConfiguration
0 likes · 13 min read
Overview of System Complexity and Strategies for Reducing Business Complexity
Zhuanzhuan Tech
Zhuanzhuan Tech
Sep 5, 2024 · Backend Development

Challenges of Abstraction and Reuse in Business Middle‑Platform Development

The article reflects on the difficulties of turning abstract design concepts such as GOF patterns and DDD into practical, reusable middle‑platform services for an e‑commerce business, discussing when to abstract, the trade‑offs between thin and thick services, and how to balance efficiency with evolving business needs.

Software Architectureabstractionbackend development
0 likes · 16 min read
Challenges of Abstraction and Reuse in Business Middle‑Platform Development
21CTO
21CTO
Aug 26, 2024 · Backend Development

Monolith vs Microservices: Which Architecture Wins in Real‑World Scenarios?

This article compares monolithic and microservice architectures across latency, complexity, reliability, resource usage, scalability, throughput, deployment speed, and communication cost, revealing where each approach excels and offering guidance on choosing the right style for different team sizes and workloads.

Software Architecturemicroservicesmonolithic architecture
0 likes · 16 min read
Monolith vs Microservices: Which Architecture Wins in Real‑World Scenarios?
JavaEdge
JavaEdge
Aug 24, 2024 · Backend Development

When to Use Simple vs Detailed Events in Event‑Driven Architecture

This article examines the trade‑offs between simple and detailed events in event‑driven architectures, illustrating their impact on scalability, coupling, and system design through concrete examples, design guidelines, and considerations from domain‑driven design to practical implementation.

Software Architecturebackend designdetailed events
0 likes · 12 min read
When to Use Simple vs Detailed Events in Event‑Driven Architecture
Architect
Architect
Aug 24, 2024 · Fundamentals

From Business Modeling to Use Case Diagrams: Vision, Business Cases, and System Design

This article guides developers through business modeling, defining a clear vision, creating business and system use‑case diagrams, drawing business sequence diagrams, and refining requirements with use‑case specifications, emphasizing how proper modeling adds real value to software projects.

Software ArchitectureUse Case Diagrambusiness modeling
0 likes · 18 min read
From Business Modeling to Use Case Diagrams: Vision, Business Cases, and System Design
Architecture and Beyond
Architecture and Beyond
Aug 23, 2024 · R&D Management

Core Competencies of a Software Architect: System Design, Technical Skills, Global Perspective, Communication, Project Management, Quality Assurance, and Innovation

This comprehensive guide outlines the seven essential abilities—system design and modeling, broad and deep technical expertise, global and systemic thinking, effective communication and collaboration, project management, quality assurance with technical debt control, and innovative foresight—that together define a successful software architect.

InnovationProject ManagementSoftware Architecture
0 likes · 39 min read
Core Competencies of a Software Architect: System Design, Technical Skills, Global Perspective, Communication, Project Management, Quality Assurance, and Innovation
Senior Tony
Senior Tony
Aug 13, 2024 · Fundamentals

How to Refactor Course Display Logic with the Decorator Pattern in Java

This article demonstrates how to identify long‑method and duplicated code smells in a Java curriculum‑display service and refactor the implementation using the Decorator pattern, providing clear component diagrams, full code examples, and a runnable demo that showcases flexible extensions for different course types.

Bad SmellDecorator PatternDesign Patterns
0 likes · 11 min read
How to Refactor Course Display Logic with the Decorator Pattern in Java
DevOps
DevOps
Aug 12, 2024 · Fundamentals

The Importance of Design and Modeling in Software Development

This article explains why software engineers should perform design and modeling—such as business modeling, process analysis, and system modeling—before writing code, highlighting how these practices align development with business goals, improve collaboration, and reduce costly rework caused by changing requirements.

ModelingObject-OrientedSoftware Architecture
0 likes · 9 min read
The Importance of Design and Modeling in Software Development
Go Programming World
Go Programming World
Aug 4, 2024 · Fundamentals

Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms

This article explains the Adapter design pattern, illustrates its real‑world analogy, demonstrates a complete Go implementation for payment processing, and shows how the pattern can be used in production scenarios such as a multi‑cloud management platform and a model‑training service, highlighting its role in unifying incompatible interfaces.

Design PatternsGoKubernetes
0 likes · 13 min read
Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms
Architecture Digest
Architecture Digest
Jul 30, 2024 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article explains the Chain of Responsibility design pattern, its typical use cases, demonstrates a flawed nested‑if implementation for a multi‑level game, and then shows step‑by‑step refactorings—including an abstract handler, concrete handlers, and a factory‑based dynamic chain—using Java code examples.

Chain of ResponsibilityDesign PatternJava
0 likes · 10 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
Java Tech Enthusiast
Java Tech Enthusiast
Jul 29, 2024 · Industry Insights

10 Warning Signs That a Technical Architect Is Not Up to the Role

The article outlines eleven common shortcomings—ranging from weak technical fundamentals and lack of business understanding to poor project management, over‑design, communication failures, low execution, insufficient hands‑on experience, ignorance of framework internals, health issues, and missing global perspective—that indicate a software architect may be unqualified for the position.

Project ManagementSoftware Architecturecareer advice
0 likes · 9 min read
10 Warning Signs That a Technical Architect Is Not Up to the Role
Architect
Architect
Jul 24, 2024 · Fundamentals

Master Design Patterns: Real‑World Examples and Complete Java Implementations

This article introduces design patterns, lists the most common patterns such as Strategy, Factory, Singleton, Proxy, Factory Method, Observer, Template Method, and Adapter, and walks through concrete Java code examples, step‑by‑step explanations, and practical scenarios that demonstrate how each pattern solves specific design problems.

Design PatternsFactory PatternSoftware Architecture
0 likes · 23 min read
Master Design Patterns: Real‑World Examples and Complete Java Implementations
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 24, 2024 · Backend Development

Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples

Domain-Driven Design (DDD) is a software development methodology that bridges business and technology by defining clear domain models, improving communication, code quality, and handling complexity through layered architecture, with concrete C# examples of entities, value objects, aggregates, and domain services.

C++DDDDesign Patterns
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 22, 2024 · Backend Development

Understanding Domain-Driven Design (DDD) Architecture

This article introduces Domain-Driven Design (DDD), explains its core concepts, benefits, and the four-layered DDD architecture—including UI, Application, Domain, and Infrastructure layers—while also offering resources for deeper study and interview preparation.

DDDDesign PatternsDomain-Driven Design
0 likes · 6 min read
Understanding Domain-Driven Design (DDD) 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.

Design PrinciplesSoftware Architectureabstraction
0 likes · 10 min read
Architectural Thinking: Five Core Principles for Managing Complexity
Architect
Architect
Jul 14, 2024 · Fundamentals

How to Build Technical Depth as a Software Architect

The article explains how developers can transform ordinary requirement work into a platform for gaining technical depth by adopting a product‑owner mindset, focusing on quality, continuous improvement, and aligning deep technical challenges with business goals to earn leadership support and career growth.

Software Architecturecareer-developmentprofessional growth
0 likes · 9 min read
How to Build Technical Depth as a Software Architect
Python Crawling & Data Mining
Python Crawling & Data Mining
Jul 14, 2024 · Fundamentals

Why Design Patterns Matter: Master Reusable Solutions in OOP

This article explains what design patterns are, why they are essential for creating reusable and maintainable object‑oriented code, outlines their main categories, learning steps, and provides a Python command‑pattern example along with a guide to a comprehensive Python design‑patterns book.

Behavioral PatternsCreational PatternsDesign Patterns
0 likes · 7 min read
Why Design Patterns Matter: Master Reusable Solutions in OOP
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.

Design PrinciplesJavaObject-Oriented
0 likes · 7 min read
Understanding SOLID Principles with Java Examples
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 5, 2024 · Fundamentals

Why Every Developer Should Think Like an Architect: A Practical Guide

This article explores what software architecture means, distinguishes vertical and horizontal architects, outlines the essential skills and methodology for architects, and provides a step‑by‑step framework—from understanding requirements and quality attributes to modeling business and system domains—so anyone can develop an architect’s mindset.

Domain-Driven DesignSoftware Architecturearchitectural thinking
0 likes · 30 min read
Why Every Developer Should Think Like an Architect: A Practical Guide
Architect
Architect
Jul 4, 2024 · Industry Insights

How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights

This article explains how Meituan applied Domain‑Driven Design to build a scalable B‑side marketing platform, covering background challenges, core DDD concepts, strategic use‑case modeling, tactical code mapping, aggregation design, and practical architectural patterns for large‑scale systems.

Code ArchitectureDDDDomain-Driven Design
0 likes · 20 min read
How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 4, 2024 · Databases

Designing Bugzilla for Multi‑Database Support: A Case Study

The article recounts how the Bugzilla project, originally tied to a single proprietary database (OldDB), was refactored to support multiple databases—including NewDB—through a comprehensive redesign that involved breaking the work into smaller, well‑tested tasks, improving maintainability and expanding support to four database systems.

Code RefactoringDatabase MigrationMulti-Database Support
0 likes · 6 min read
Designing Bugzilla for Multi‑Database Support: A Case Study
Model Perspective
Model Perspective
Jul 2, 2024 · Fundamentals

How to Quantify Tight vs Loose Coupling with Graph Theory

Understanding tight and loose coupling in system design, this article explains their trade‑offs, introduces a coupling degree metric based on graph theory, demonstrates calculations with example module dependencies, and discusses when each approach is preferable for performance, maintainability, and scalability.

CouplingLoose CouplingSoftware Architecture
0 likes · 6 min read
How to Quantify Tight vs Loose Coupling with Graph Theory
Selected Java Interview Questions
Selected Java Interview Questions
Jul 1, 2024 · Fundamentals

Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More

This article provides a comprehensive introduction to common Java design patterns—including Strategy, Factory, Singleton, Proxy, Observer, Template Method, and Adapter—explaining their concepts, typical use‑cases, and complete code implementations with Spring Boot integration for practical application development.

Design PatternsFactory PatternJava
0 likes · 20 min read
Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More
DevOps
DevOps
Jun 30, 2024 · Fundamentals

Understanding Systems, Architecture, and Complexity: A Comprehensive Overview

This article explores system theory, architectural design, and complexity, presenting a structured view of systems, their characteristics, modeling approaches like 4+1 and C4, microservice concepts, and the Cynefin framework, offering developers practical insights to manage and evolve software systems effectively.

C4 modelComplexityCynefin framework
0 likes · 19 min read
Understanding Systems, Architecture, and Complexity: A Comprehensive Overview
FunTester
FunTester
Jun 28, 2024 · Industry Insights

Why System Thinking Matters: From Architecture Basics to Managing Complexity

An in‑depth exploration shows how viewing software as a system, mastering architectural models like 4+1, C4 and TOGAF, and applying the Cynefin framework for complexity can guide developers from basic system concepts to effective microservice design and complexity management.

C4 modelCynefinSoftware Architecture
0 likes · 20 min read
Why System Thinking Matters: From Architecture Basics to Managing Complexity
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 frameworkDesign Principles
0 likes · 21 min read
Why System Thinking and Architecture Matter: A Deep Dive into Complexity and Design
DevOps
DevOps
Jun 17, 2024 · Product Management

Understanding Software Requirement Changes and the Software Value Model

The article examines why software requirements frequently change, introduces a four‑layer software value model—from business value to UI aesthetics—and explains how this model guides product managers and engineers in handling requirement volatility, balancing flexibility, and maintaining architectural integrity.

Business ValueSoftware Architectureproduct management
0 likes · 8 min read
Understanding Software Requirement Changes and the Software Value Model
DaTaobao Tech
DaTaobao Tech
Jun 12, 2024 · Backend Development

Refactoring Large-Scale Video Streaming Engineering: Theory and Practice

The article presents a comprehensive guide to large‑scale video‑streaming system refactoring, combining theory on continuous improvement, architectural evolution, code‑quality criteria, and challenges with a practical roadmap that leverages automation, systematic analysis, engineering safeguards, static‑analysis tools, and design patterns to safely transform legacy monoliths into modular, containerized platforms.

Component ArchitectureEngineering PracticesRefactoring
0 likes · 16 min read
Refactoring Large-Scale Video Streaming Engineering: Theory and Practice
JD Tech Talk
JD Tech Talk
Jun 12, 2024 · Backend Development

Applying Domain-Driven Design: A Restaurant Case Study for Architecture and Domain Modeling

This article presents a comprehensive, restaurant‑based case study that demonstrates how to apply Domain‑Driven Design principles—including domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, and microservice decomposition—to create a clear, maintainable software architecture aligned with business requirements.

DDDDomain modelingDomain-Driven Design
0 likes · 22 min read
Applying Domain-Driven Design: A Restaurant Case Study for Architecture and Domain Modeling
JD Cloud Developers
JD Cloud Developers
Jun 12, 2024 · Backend Development

How to Turn a Restaurant Scenario into Concrete DDD Architecture

This article walks through a complete Domain‑Driven Design case study using a restaurant example, covering domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, microservice boundaries, and functional implementation to illustrate how business concepts map to software structures.

DDDDomain modelingDomain-Driven Design
0 likes · 23 min read
How to Turn a Restaurant Scenario into Concrete DDD Architecture
Continuous Delivery 2.0
Continuous Delivery 2.0
Jun 12, 2024 · Fundamentals

Major Changes in Software Engineering Over the Past 20 Years and Enduring Core Principles

Over the past two decades, software engineering has shifted from waterfall to agile, embraced DevOps, cloud and micro‑services, containerization, CI/CD, open‑source, AI, heightened security, diverse languages, remote collaboration, user‑centered design, dependency management, and continuous learning, while core concepts such as requirements analysis, design principles, testing, version control, and architecture remain unchanged.

AgileCloud ComputingDevOps
0 likes · 8 min read
Major Changes in Software Engineering Over the Past 20 Years and Enduring Core Principles
Architect's Guide
Architect's Guide
Jun 6, 2024 · Backend Development

Backend Implementation Method and Device Based on SpringBoot

The Chinese Patent CN112905176B granted to Industrial and Commercial Bank of China describes a SpringBoot‑based backend implementation method that extracts operation data, maps business IDs to configuration, builds conditional expressions, and processes data, aiming to reduce development changes, lower costs, and improve system stability.

JavaSoftware ArchitectureSpringBoot
0 likes · 3 min read
Backend Implementation Method and Device Based on SpringBoot
Architecture and Beyond
Architecture and Beyond
May 25, 2024 · R&D Management

Applying Conway's Law and Inverse Conway's Law to Improve Software Development Efficiency and Manage Team Cognitive Load

The article explores how organizational structure, Conway's Law and its inverse, and the management of team cognitive load influence software architecture stability and development efficiency, offering practical measures for team design, governance, and architectural practices to align teams with desired system outcomes.

Cognitive LoadConway's LawR&D management
0 likes · 18 min read
Applying Conway's Law and Inverse Conway's Law to Improve Software Development Efficiency and Manage Team Cognitive Load
macrozheng
macrozheng
May 24, 2024 · Backend Development

Master Java Design Patterns: Strategy, Chain, Template, Observer, Factory & Singleton

This article explains the core concepts, typical business scenarios, definitions, and concrete Java implementations of six fundamental design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—showing how they improve code maintainability, extensibility, and adherence to SOLID principles.

Software ArchitectureStrategy Patternsingleton
0 likes · 24 min read
Master Java Design Patterns: Strategy, Chain, Template, Observer, Factory & Singleton
Architect
Architect
May 23, 2024 · Fundamentals

Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers

This article explains Domain‑Driven Design (DDD) from its origins to practical modeling, compares it with MVC, outlines business and personal benefits, discusses drawbacks, details strategic and tactical concepts, and walks through a real‑world VOC product example using event‑storming and four‑color modeling.

DDDDomain-Driven DesignModeling
0 likes · 34 min read
Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers
dbaplus Community
dbaplus Community
May 20, 2024 · Backend Development

When Architects Overdesign: Tales of Microservices, MQ, Caches, and Database Chaos

The article humorously chronicles a series of real‑world over‑design incidents—excessive microservice splitting, needless multi‑database sharding, ubiquitous message‑queue usage, over‑engineered caching, design‑pattern abuse, and bloated database schemas—highlighting why simplicity (KISS) remains the best practice for backend systems.

KISSSoftware Architecturecaching
0 likes · 11 min read
When Architects Overdesign: Tales of Microservices, MQ, Caches, and Database Chaos
Top Architect
Top Architect
May 20, 2024 · Fundamentals

Designing Clear Software Architecture Diagrams: Concepts, Types, and the C4 Model

This article explains the fundamental concepts of software architecture, defines what architecture diagrams are and their purposes, evaluates what makes a good diagram, introduces the C4 modeling approach with system context, container, component, and class diagrams, and provides practical case examples and reference resources.

C4 modelSoftware ArchitectureSystem Design
0 likes · 12 min read
Designing Clear Software Architecture Diagrams: Concepts, Types, and the C4 Model
DeWu Technology
DeWu Technology
May 20, 2024 · Fundamentals

Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques

Domain‑Driven Design aligns software architecture with business needs by establishing a shared language, clear bounded contexts, and strategic‑tactical patterns—entities, value objects, aggregates, services, and events—while using techniques such as Event Storming and Four‑Color Modeling to visualize domains, guide micro‑service boundaries, and produce maintainable, adaptable systems.

Domain-Driven DesignModelingSoftware Architecture
0 likes · 28 min read
Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques
Open Source Linux
Open Source Linux
May 20, 2024 · Backend Development

What Is Middleware and Why It’s Crucial for Modern Software Architecture

Middleware is software that connects system software and application software, enabling communication between components and centralizing application logic toward the system layer; it is widely employed in modern IT frameworks such as web services and service‑oriented architectures to streamline integration and functionality.

MiddlewareSoftware Architecturebackend development
0 likes · 3 min read
What Is Middleware and Why It’s Crucial for Modern Software Architecture
ByteDance Data Platform
ByteDance Data Platform
May 8, 2024 · Backend Development

How DataTester’s Architecture Upgrade Uses DDD to Tame Code Complexity

DataTester’s A/B testing platform underwent a comprehensive architectural overhaul, applying domain‑driven design, modular refactoring, automated validation, and dependency inversion to reduce change amplification, cognitive load, and unknown unknowns, ultimately improving code readability, maintainability, scalability, and development efficiency across its lifecycle.

A/B testingCode RefactoringDDD
0 likes · 29 min read
How DataTester’s Architecture Upgrade Uses DDD to Tame Code Complexity
21CTO
21CTO
Apr 20, 2024 · Backend Development

Why Backend Development Is Harder Today Than 20 Years Ago

Over the past two decades, backend development has shifted from simple server‑side coding to a complex, multidisciplinary field, driven by soaring user expectations, massive system scale, an overwhelming array of technologies, and the need for cloud, container, and cross‑team collaboration skills.

Software Architecturebackenddevelopment trends
0 likes · 9 min read
Why Backend Development Is Harder Today Than 20 Years Ago
MoonWebTeam
MoonWebTeam
Apr 16, 2024 · Frontend Development

Mastering Dependency Injection in Frontend: Boost Maintainability and Testability

This article explains the concept of Dependency Injection for frontend projects, compares it with Inversion of Control, showcases practical code examples, discusses popular DI libraries and frameworks, and details implementation techniques such as decorators, reflection, singleton handling, and circular dependency resolution to improve maintainability and testability.

Design PatternsIoCSoftware Architecture
0 likes · 26 min read
Mastering Dependency Injection in Frontend: Boost Maintainability and Testability
21CTO
21CTO
Apr 14, 2024 · Fundamentals

8 Hard‑Won Lessons on Software Architecture Every Engineer Should Know

This reflective essay shares eight practical insights on software architecture—from the challenge of asking the right questions and deciding what not to build, to the pivotal role of non‑functional requirements, risk‑first design, and the paradox of simplicity—offering engineers actionable guidance for better architectural decisions.

Risk ManagementSoftware Architecturecontinuous coding
0 likes · 13 min read
8 Hard‑Won Lessons on Software Architecture Every Engineer Should Know
php Courses
php Courses
Apr 10, 2024 · Fundamentals

What Is the State Pattern? Explanation and PHP Implementation Example

The article introduces the State design pattern as a behavioral pattern that lets objects change their behavior when their internal state changes, compares it with the Strategy pattern, and provides a detailed PHP example illustrating its components and usage.

Design PatternSoftware ArchitectureState Pattern
0 likes · 5 min read
What Is the State Pattern? Explanation and PHP Implementation Example
Ops Development & AI Practice
Ops Development & AI Practice
Apr 4, 2024 · Fundamentals

Mastering the Facade Pattern in Go: Simplify Complex Systems

This article explains the Facade design pattern, outlines its core roles, provides step‑by‑step guidance for implementing it in Go, showcases a complete code example, and discusses its advantages and typical use cases such as API gateways in microservice architectures.

Code ExampleDesign PatternsFacade Pattern
0 likes · 5 min read
Mastering the Facade Pattern in Go: Simplify Complex Systems
Liangxu Linux
Liangxu Linux
Mar 28, 2024 · Fundamentals

Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs

Ports act as an essential indirection layer that maps network requests to specific processes, enabling protocols like HTTP and HTTPS to function, while default ports simplify user interaction; this article explains common ports, default values, the role of IPC, naming services, and how ports embody inversion of control principles.

IPCNetworkingSoftware Architecture
0 likes · 18 min read
Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs
Java Tech Enthusiast
Java Tech Enthusiast
Mar 23, 2024 · Cloud Native

Why Over‑Engineering with Microservices Is a Trap

Over‑engineering with micro‑services creates needless complexity, high costs, and fragile systems, as many startups and developers adopt them for hype rather than scale, while successful companies like Dropbox and Netflix began as monoliths and thrive, proving that simple, well‑designed architectures usually outweigh distributed solutions.

Software Architecturemonolith
0 likes · 9 min read
Why Over‑Engineering with Microservices Is a Trap