BestHub
Sign in
Tagged articles

Software Architecture

1241 articles · Page 8 of 13
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 29, 2021 · Fundamentals

Mastering Software Architecture: Strategic & Tactical Design Principles

This article explores how to transform product requirements into robust technical architectures by addressing uncertainty, outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical design recommendations.

High concurrencySoftware Architecturedesign principles
0 likes · 14 min read
Mastering Software Architecture: Strategic & Tactical Design Principles
Java Architect Essentials
Java Architect Essentials
Sep 28, 2021 · R&D Management

How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work

This article explains the common misconceptions about software architects, outlines the essential technical and soft‑skill requirements for senior developers to become architects, describes practical upgrade paths, and details the typical responsibilities and daily activities of an architect.

Design PatternsSoftware Architecturecareer development
0 likes · 13 min read
How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work
Top Architect
Top Architect
Sep 28, 2021 · Fundamentals

How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices

This article explains the purpose of software architecture diagrams, defines key concepts, outlines common diagram types such as the 4+1 view and C4 model, discusses criteria for good diagrams, addresses typical pitfalls, and provides practical guidance and tool recommendations for producing clear, audience‑focused architecture visuals.

C4 modelSoftware ArchitectureSystem Design
0 likes · 10 min read
How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 23, 2021 · Fundamentals

Builder Pattern in Java: Implementation, Usage, and Comparison with Simple Factory

This article explains the Builder design pattern in Java with complete code examples—including Product, abstract Builder, ConcreteBuilder, Director, and client code—demonstrates the output, compares it to the simple factory pattern, and briefly shows how ASM bytecode manipulation can generate similar constructs.

Design PatternsJavaSoftware Architecture
0 likes · 6 min read
Builder Pattern in Java: Implementation, Usage, and Comparison with Simple Factory
IT Architects Alliance
IT Architects Alliance
Sep 19, 2021 · R&D Management

30 Proven Architecture Principles Every Software Engineer Should Follow

This article presents 30 widely‑accepted software architecture principles—grouped into basics, feature selection, server design, distributed systems, user experience, and challenges—to help architects act as gardeners who shape, refine, and sustain robust, maintainable systems.

Best PracticesR&D ManagementSoftware Architecture
0 likes · 12 min read
30 Proven Architecture Principles Every Software Engineer Should Follow
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 15, 2021 · R&D Management

What Makes a Successful CTO? Lessons from Alibaba’s Tech Evolution

This article shares a senior CTO’s journey through Alibaba and Ant Group, detailing how commercial goals and technology co‑evolve, the pivotal architectural decisions, risk‑management practices, organizational design, and leadership principles that shape effective technology leadership.

AlibabaCTOCloud Computing
0 likes · 30 min read
What Makes a Successful CTO? Lessons from Alibaba’s Tech Evolution
Alimama Tech
Alimama Tech
Sep 15, 2021 · R&D Management

CTO: Not a Thinker but an Action Taker – Insights on Technology Leadership and Evolution

The article recounts a senior technology leader’s journey from early PHP/MySQL work to senior CTO roles at Ant Group and Alibaba, arguing that a CTO must be an executor who aligns business goals with evolving distributed, cloud‑native architectures, outlines three leadership stages, key responsibilities, and offers a Z‑shaped career roadmap for future CTOs.

CTOCloud ComputingSoftware Architecture
0 likes · 28 min read
CTO: Not a Thinker but an Action Taker – Insights on Technology Leadership and Evolution
IT Architects Alliance
IT Architects Alliance
Sep 12, 2021 · Fundamentals

Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns

This article introduces the essential principles of Domain‑Driven Design, explaining its two‑stage approach, key building blocks such as entities, value objects, aggregates, factories, repositories, services, and domain events, and shows how DDD fits into layered architecture and common anti‑patterns.

AggregatesDDDDomain-Driven Design
0 likes · 26 min read
Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns
IT Architects Alliance
IT Architects Alliance
Sep 8, 2021 · Backend Development

Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Microservices

The article explains the concept of software scaffolding, why it is needed for microservice development, outlines key design principles, shares a real‑world case of replacing a custom persistence layer with Spring Data, and reviews popular scaffolding tools such as Vue CLI, Maven, Netty, Java EE, Dropwizard and Spring Boot.

Backend DevelopmentMicroservicesScaffolding
0 likes · 11 min read
Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Microservices
Java Architect Essentials
Java Architect Essentials
Sep 6, 2021 · Fundamentals

Strategic and Tactical Design Principles for Technical Architecture

This article explains how to design a stable and high‑performing software architecture by addressing strategic principles—suitability, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business‑oriented design, while illustrating logical and physical architecture diagrams.

High concurrencySoftware ArchitectureStrategic Design
0 likes · 15 min read
Strategic and Tactical Design Principles for Technical Architecture
Java Interview Crash Guide
Java Interview Crash Guide
Sep 4, 2021 · Backend Development

Why Is Domain‑Driven Design Booming? Uncover Its Role in Modern Microservices

This article explains how Domain‑Driven Design (DDD) gained popularity alongside microservices, outlines the evolution of software architectures, highlights the boundary‑defining problems of microservices, and shows how DDD’s strategic and tactical design methods help create clear, high‑cohesion, low‑coupling systems.

Backend DevelopmentDomain-Driven DesignSoftware Architecture
0 likes · 10 min read
Why Is Domain‑Driven Design Booming? Uncover Its Role in Modern Microservices
KooFE Frontend Team
KooFE Frontend Team
Sep 2, 2021 · R&D Management

How Conway’s Law and Entropy Shape Modern Tech Team Structures

The article explores how Conway’s Law and the entropy increase principle explain the dynamic nature of organizational structures in tech companies, highlighting the impact of communication patterns on system design, resource allocation, and team efficiency.

Conway's LawSoftware Architectureentropy
0 likes · 6 min read
How Conway’s Law and Entropy Shape Modern Tech Team Structures
Baidu Geek Talk
Baidu Geek Talk
Aug 23, 2021 · Frontend Development

Exploring Lowcode and Micro‑Frontend: Towards the Next Generation Front‑End Framework

The article surveys the evolution of front‑end development, explains the surge of low‑code platforms and micro‑frontend architectures, and proposes a next‑generation, JSON‑driven framework that separates component creation from page configuration to combine rapid low‑code productivity with the flexibility of traditional code.

LowCodeSoftware Architectureframework
0 likes · 10 min read
Exploring Lowcode and Micro‑Frontend: Towards the Next Generation Front‑End Framework
Programmer DD
Programmer DD
Aug 18, 2021 · Fundamentals

Why Domain-Driven Design Remains Essential for Complex Software Projects

Domain-Driven Design (DDD) focuses software development on deep domain understanding, offering a proven, timeless approach to tackling core complexity, especially in large or evolving systems, while emphasizing the crucial role of a well‑crafted domain model and DSL.

DDDDomain ModelingDomain-Driven Design
0 likes · 9 min read
Why Domain-Driven Design Remains Essential for Complex Software Projects
Baidu Intelligent Testing
Baidu Intelligent Testing
Aug 17, 2021 · Fundamentals

Applying Domain‑Driven Design in Baidu’s AiFanFan Product Development: A Practical Guide

This article explains how Baidu’s AiFanFan team introduced Domain‑Driven Design to tackle complex enterprise‑level requirements, detailing the strategic and tactical steps, core DDD concepts, layered implementation, and the concrete benefits gained from adopting a domain‑centric architecture.

Domain-Driven DesignMicroservicesSoftware Architecture
0 likes · 24 min read
Applying Domain‑Driven Design in Baidu’s AiFanFan Product Development: A Practical Guide
IT Architects Alliance
IT Architects Alliance
Aug 15, 2021 · Fundamentals

Comprehensive Guide to Design Patterns with Java Examples

This article provides a thorough introduction to classic software design patterns—including creational, structural, and behavioral patterns—explaining their principles, illustrating each with clear Java code examples, and offering practical insights on when and how to apply them effectively in development.

BehavioralCreationalJava
0 likes · 41 min read
Comprehensive Guide to Design Patterns with Java Examples
dbaplus Community
dbaplus Community
Aug 9, 2021 · Backend Development

Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons

This article explains the fundamentals of Domain‑Driven Design (DDD), outlines its strategic and tactical design processes, and demonstrates how Haro’s transaction platform applies DDD across taxi, e‑commerce, and core trading scenarios, highlighting benefits, challenges, and practical recommendations.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 29 min read
Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons
21CTO
21CTO
Aug 9, 2021 · Fundamentals

Mastering System Design: Core Elements, Steps, and Performance Strategies

This article explains system design fundamentals—including architecture, modules, components, interfaces, and data—outlines the main tasks and step‑by‑step process, covers performance challenges, RAIL performance model, key web metrics, and Facebook's design values, providing a comprehensive guide for building robust applications.

Performance OptimizationRAIL modelSoftware Architecture
0 likes · 14 min read
Mastering System Design: Core Elements, Steps, and Performance Strategies
Tongcheng Travel Technology Center
Tongcheng Travel Technology Center
Aug 4, 2021 · Backend Development

Designing Complex System Architecture: From Entropy to Microservices and the Middle Platform

The article explains how the thermodynamic entropy principle inspires software architecture design, emphasizes abstract thinking and domain‑driven design, compares monolithic and microservice approaches, outlines microservice benefits and distributed‑system design principles, and discusses the complementary role of middle‑platform architecture in modern backend development.

Domain-Driven DesignMicroservicesSoftware Architecture
0 likes · 9 min read
Designing Complex System Architecture: From Entropy to Microservices and the Middle Platform
IT Architects Alliance
IT Architects Alliance
Aug 2, 2021 · R&D Management

What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework

This article explains the meaning of architecture, why it is essential for any system, the responsibilities of architects, various software architecture classifications, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered, extension, and standard design principles.

COLA frameworkCQRSSoftware Architecture
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework
21CTO
21CTO
Aug 2, 2021 · Fundamentals

Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes

The article examines why many software projects become “rotten” by analyzing four common code‑quality problems—over‑large components, low cohesion, tangled high‑level/low‑level logic, and rampant if‑else—then offers concrete refactoring patterns, design‑pattern applications, and practical tooling to restore maintainability and project success.

Design PatternsSoftware Architecturecode quality
0 likes · 38 min read
Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes
21CTO
21CTO
Aug 1, 2021 · Backend Development

What Does It Take to Become a Great Software Architect? Key Skills and Practices

This article outlines the career path toward software architecture, detailing the market expectations, essential competencies such as project management, technical depth, business insight, communication, decision‑making, and optimization techniques for systems, backend services, and databases, while emphasizing continuous learning and community involvement.

Backend DevelopmentPerformance OptimizationSoftware Architecture
0 likes · 17 min read
What Does It Take to Become a Great Software Architect? Key Skills and Practices
IT Architects Alliance
IT Architects Alliance
Jul 28, 2021 · Fundamentals

Software Modeling and Design: Key UML Diagrams and Their Application Across Development Stages

This article explains how software architects can use UML modeling—covering class, sequence, component, deployment, use‑case, state, and activity diagrams—to analyze domain problems, design abstract models, and produce clear documentation that guides development from requirements through detailed design.

Software ArchitectureSystem DesignUML
0 likes · 15 min read
Software Modeling and Design: Key UML Diagrams and Their Application Across Development Stages
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 28, 2021 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

This article explains software architecture patterns as reusable solutions to common design problems, introduces the seven major patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their context, challenges, solutions, drawbacks, and typical use cases.

Design PatternsMVCMicroservices
0 likes · 11 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
ELab Team
ELab Team
Jul 26, 2021 · Fundamentals

Why Rule Engines Matter: From Rete Algorithm to Node.js Nools

This article explains the origins and concepts of rule engines, demonstrates practical JavaScript implementations, dives into the Rete pattern‑matching algorithm, and explores design considerations for visual rule editors and lightweight Node.js components.

Node.jsRete algorithmSoftware Architecture
0 likes · 15 min read
Why Rule Engines Matter: From Rete Algorithm to Node.js Nools
DevOps
DevOps
Jul 26, 2021 · Fundamentals

Preventing Software Degradation with Domain‑Driven Design and the Two‑Hat Refactoring Approach

The article explains how software degradation occurs as systems evolve, why domain‑driven design combined with a two‑step refactoring approach can maintain high‑quality design, and demonstrates these concepts through an e‑commerce payment case study, covering principles like OCP, SRP, and micro‑services.

Domain-Driven DesignSoftware Architecturecode quality
0 likes · 21 min read
Preventing Software Degradation with Domain‑Driven Design and the Two‑Hat Refactoring Approach
MaGe Linux Operations
MaGe Linux Operations
Jul 25, 2021 · Backend Development

From Monolith to Microservices: A Comprehensive Journey and Essential Tech Stack

This article traces the evolution of software architecture from monolithic applications through vertical splitting and distributed services to modern microservice architectures, examines their advantages and drawbacks, and outlines a comprehensive technology stack—including service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD tools—essential for building scalable, resilient systems.

CI/CDMicroservicesService Mesh
0 likes · 18 min read
From Monolith to Microservices: A Comprehensive Journey and Essential Tech Stack
IT Architects Alliance
IT Architects Alliance
Jul 24, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Framework

This article explains what software architecture is, why it is needed, the responsibilities of architects, various classification types such as business, application, distributed, data, physical and operations, and introduces typical architectural styles like layered, CQRS, hexagonal, onion, and the open‑source COLA framework.

COLACQRSDesign Patterns
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 23, 2021 · Fundamentals

Why Architecture Matters: From Basics to the COLA Framework

This article explains what software architecture is, why it is essential, the responsibilities of architects, various architecture classifications, common patterns such as layered, CQRS, hexagonal and onion designs, and introduces the open‑source COLA framework with its layered structure, extension mechanisms, and normative guidelines.

COLA frameworkDesign PatternsSoftware Architecture
0 likes · 13 min read
Why Architecture Matters: From Basics to the COLA Framework
JD Tech
JD Tech
Jul 23, 2021 · Fundamentals

Understanding the Essence, Principles, and Methodology of Software Architecture Design

This article explains software architecture design by defining its essence, contrasting it with ordinary software development, outlining three core principles—appropriateness, simplicity, and evolution—and detailing the TOGAF/ADM methodology and its business, data, application, and technology domains for building robust, adaptable systems.

ADMSoftware ArchitectureTOGAF
0 likes · 10 min read
Understanding the Essence, Principles, and Methodology of Software Architecture Design
IT Architects Alliance
IT Architects Alliance
Jul 22, 2021 · Fundamentals

Key Responsibilities and Skills for Software Architects

The article outlines the essential duties, required competencies, decision‑making principles, and optimization techniques for software architects, covering system decomposition, technology selection, communication, technical depth, performance tuning, database scaling, and the broader mindset needed to lead complex development projects.

Performance OptimizationSoftware ArchitectureSystem Design
0 likes · 16 min read
Key Responsibilities and Skills for Software Architects
IT Architects Alliance
IT Architects Alliance
Jul 20, 2021 · R&D Management

Finding Value in Software Development: From Programmer's Confusion to Value‑Driven Architecture

The article explores why many programmers feel lost, explains the business‑technology‑software value chain, and argues that adopting a value‑driven architectural mindset helps align learning and work with real business impact, improving both personal fulfillment and organizational outcomes.

R&D ManagementSoftware Architecturebusiness alignment
0 likes · 17 min read
Finding Value in Software Development: From Programmer's Confusion to Value‑Driven Architecture
IT Architects Alliance
IT Architects Alliance
Jul 17, 2021 · Fundamentals

Business Analysis Methods and Modeling Techniques

The article outlines practical business analysis approaches—including flowcharts, sequence diagrams, prototype sketches, business and data model diagrams—and recommends modeling tools, emphasizing the importance of selecting appropriate visualizations to clarify complex requirements and improve communication between stakeholders and technical teams.

Software Architecturebusiness analysismodeling
0 likes · 9 min read
Business Analysis Methods and Modeling Techniques
Amap Tech
Amap Tech
Jul 16, 2021 · Fundamentals

Code Refactoring: Concepts, Practices, and Techniques

The article shares practical lessons from refactoring a ride‑hailing order system, explaining Martin Fowler’s definition of refactoring, distinguishing small (renaming, deduplication) and large (architectural redesign) efforts, outlining typical code smells, and detailing a structured pre‑, during‑, and post‑refactoring process to improve maintainability, reduce bugs, and accelerate development.

Best PracticesCode RefactoringSoftware Architecture
0 likes · 19 min read
Code Refactoring: Concepts, Practices, and Techniques
Java High-Performance Architecture
Java High-Performance Architecture
Jul 11, 2021 · Fundamentals

Why Domain‑Driven Design Is the Secret Weapon for Tackling Complex Business Systems

This article explains how Domain‑Driven Design (DDD) helps teams manage rising business and technical complexity by promoting a ubiquitous language, strategic and tactical design, layered and hexagonal architectures, and seamless integration with microservices, enabling rapid adaptation and robust, maintainable systems.

CQRSDomain-Driven DesignMicroservices
0 likes · 42 min read
Why Domain‑Driven Design Is the Secret Weapon for Tackling Complex Business Systems
IT Architects Alliance
IT Architects Alliance
Jul 11, 2021 · Fundamentals

Understanding Software Architecture: Types, Design Principles, and the Role of Architects

This article explains the five architectural views—logical, development, runtime, physical, and data—clarifies the distinction between software and system architecture, discusses tier versus layer concepts, outlines the benefits of logical and physical layering, and describes the various kinds of architects and their responsibilities.

@layerArchitect RolesSoftware Architecture
0 likes · 10 min read
Understanding Software Architecture: Types, Design Principles, and the Role of Architects
macrozheng
macrozheng
Jul 8, 2021 · Backend Development

Why Legacy Code Is Killing Your Productivity—and How to Fix It

The article shares painful real‑world cases of poorly written SQL and Java code, explains how tangled microservice dependencies and missing transactions cripple maintainability, and offers concrete guidelines for clean architecture, modular design, and effective code governance to boost team efficiency.

Software Architecturecode qualitysql-optimization
0 likes · 8 min read
Why Legacy Code Is Killing Your Productivity—and How to Fix It
IT Architects Alliance
IT Architects Alliance
Jul 4, 2021 · R&D Management

Understanding Software: History, Cost Drivers, and the Evolution of Architecture

This article explores the origins of software as a human‑simulation tool, examines how cost reductions and technological advances have driven its widespread adoption, and explains how increasing complexity led to the emergence of specialized roles and architectural practices in modern software development.

Software ArchitectureSystem Designcost efficiency
0 likes · 10 min read
Understanding Software: History, Cost Drivers, and the Evolution of Architecture
Architecture Digest
Architecture Digest
Jul 4, 2021 · Fundamentals

Understanding Domain-Driven Design: Value, Process, and Architectural Practices

This article explains the principles and benefits of Domain-Driven Design (DDD), describing how strategic and tactical design, layered and hexagonal architectures, CQRS, and bounded contexts help manage complex business logic, improve scalability, and align software development with evolving business requirements.

CQRSDomain-Driven DesignMicroservices
0 likes · 40 min read
Understanding Domain-Driven Design: Value, Process, and Architectural Practices
IT Architects Alliance
IT Architects Alliance
Jul 4, 2021 · Industry Insights

Why Do Software Architectures Decay Over Time and How to Prevent It?

The article examines why software architectures inevitably degrade as projects grow, outlines the stages of decay, critiques common quick fixes, and proposes strategic solutions such as adopting new technologies, refactoring into isolated components, using separate processes, and building loosely coupled platforms to sustain long‑term maintainability.

Build OptimizationPlatform designSoftware Architecture
0 likes · 25 min read
Why Do Software Architectures Decay Over Time and How to Prevent It?
IT Architects Alliance
IT Architects Alliance
Jul 1, 2021 · R&D Management

How to Break Down a Business Domain: From Core to Supporting Subdomains

This article explains DDD terminology by using a peach‑tree analogy to illustrate how a business can be divided into domains, subdomains, core, generic, and supporting domains, and provides step‑by‑step guidance for identifying and structuring these layers to focus development effort effectively.

Core DomainDomain-Driven DesignMicroservices
0 likes · 8 min read
How to Break Down a Business Domain: From Core to Supporting Subdomains
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 1, 2021 · Fundamentals

What a Peach Tree Can Teach You About Domain‑Driven Design

This article uses a peach‑tree analogy to explain how to break down complex business logic into domains, subdomains, core, generic, and supporting domains, illustrating the practical steps and benefits of applying Domain‑Driven Design in software projects.

DDDDomain ModelingMicroservices
0 likes · 8 min read
What a Peach Tree Can Teach You About Domain‑Driven Design
IT Architects Alliance
IT Architects Alliance
Jun 30, 2021 · Fundamentals

Understanding Software Architecture: Systems, Subsystems, Modules, Components, Frameworks, and Architecture

This article explains the fundamental concepts of software architecture—including systems, subsystems, modules, components, frameworks, and architecture itself—by defining each term, illustrating their relationships with real‑world examples, and clarifying common misconceptions for technical professionals.

ComponentSoftware ArchitectureSystem Design
0 likes · 10 min read
Understanding Software Architecture: Systems, Subsystems, Modules, Components, Frameworks, and Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 30, 2021 · Fundamentals

Who Is Software Architecture Designed For? Exploring 4+1 Views and Documentation

This article examines the purpose of software architecture by identifying its diverse stakeholders, detailing the refinement process, illustrating the 4+1 view model with diagrams, outlining documentation practices, summarizing key takeaways, and previewing the next installment on deployment architecture.

4+1 viewSoftware ArchitectureSystem Design
0 likes · 4 min read
Who Is Software Architecture Designed For? Exploring 4+1 Views and Documentation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 28, 2021 · Fundamentals

Why Architecture Diagrams Matter: Principles, Methods, and Tools for Effective Software Design

This article explains the essence of software architecture, its core elements, why clear diagrams are crucial for communication and quality, and presents practical principles, patterns like UML, 4+1, C4, arc42, and tools such as draw.io and PlantUML to help engineers create accurate, consistent, and maintainable architectural documentation.

C4 modelPlantUMLSoftware Architecture
0 likes · 34 min read
Why Architecture Diagrams Matter: Principles, Methods, and Tools for Effective Software Design
Architecture Digest
Architecture Digest
Jun 28, 2021 · Backend Development

Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges

The article explains the rise of Domain-Driven Design by tracing architectural evolution from monolithic to microservices, highlighting DDD’s role in defining business boundaries, its strategic and tactical components, and practical steps for modeling domains to guide microservice design.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 11 min read
Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges
IT Architects Alliance
IT Architects Alliance
Jun 27, 2021 · Cloud Native

From Monolith to Microservices: A Complete Evolution Guide

This article traces the evolution of software architecture from monolithic applications through vertical splitting, distributed services, and SOA to modern microservices, and then details the essential technology stack—including service communication, API gateways, authentication, fault tolerance, logging, configuration, containers, orchestration, and CI/CD—required to build scalable, resilient cloud‑native systems.

CI/CDContainersKubernetes
0 likes · 19 min read
From Monolith to Microservices: A Complete Evolution Guide
IT Architects Alliance
IT Architects Alliance
Jun 27, 2021 · Fundamentals

Software Architecture Design and the 4+1 View Model Overview

This article explains software architecture concepts, the 4+1 view model, various architectural styles, the evolution of layered client‑server architectures, and the MVC/MVP patterns, providing a comprehensive overview of design principles and their practical implications.

4+1 viewMVCSoftware Architecture
0 likes · 16 min read
Software Architecture Design and the 4+1 View Model Overview
IT Architects Alliance
IT Architects Alliance
Jun 24, 2021 · Industry Insights

Why Is Domain-Driven Design Suddenly Trending? A Deep Dive into Its Rise

Domain-Driven Design (DDD) has surged in popularity as microservices dominate, and this article traces its historical background, explains the architectural shifts that created its need, outlines strategic and tactical design concepts, and provides a three‑step method for defining domain models and service boundaries.

Domain-Driven DesignMicroservicesSoftware Architecture
0 likes · 10 min read
Why Is Domain-Driven Design Suddenly Trending? A Deep Dive into Its Rise
IT Architects Alliance
IT Architects Alliance
Jun 23, 2021 · Fundamentals

10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know

This article introduces ten fundamental software architecture patterns—layered, client‑server, master‑slave, pipe‑and‑filter, broker, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical applications, advantages, and drawbacks to help engineers choose the right architecture for large‑scale enterprise systems.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 10 min read
10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 7, 2021 · Fundamentals

Why Domain Models Are the Secret Weapon for Stable, Scalable Software

This article explains the concept of domain models, why they are crucial business assets, how to create and use them with UML diagrams and simple examples, highlights common misconceptions, and shows how explicit modeling improves communication, code readability, and software adaptability.

DDDDomain ModelingSoftware Architecture
0 likes · 16 min read
Why Domain Models Are the Secret Weapon for Stable, Scalable Software
Java High-Performance Architecture
Java High-Performance Architecture
Jun 7, 2021 · Fundamentals

23 Essential Design Patterns Explained with Fun Real‑World Analogies

This article humorously illustrates 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by mapping each to everyday relationship scenarios.

AdapterBuilderDesign Patterns
0 likes · 18 min read
23 Essential Design Patterns Explained with Fun Real‑World Analogies
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 6, 2021 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Real‑World Stories and Java Implementations

This article explains the Chain of Responsibility design pattern by linking a historical story of Guan Yu’s five passes with an OA leave‑approval workflow, provides a clear definition, discusses its pros and cons, and presents comprehensive Java code examples illustrating abstract handlers, concrete handlers, and client usage.

Chain of ResponsibilityJavaOO Design
0 likes · 12 min read
Understanding the Chain of Responsibility Design Pattern with Real‑World Stories and Java Implementations
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2021 · Fundamentals

What Does a Complete Enterprise Technology Middle‑Platform Architecture Look Like?

An extensive diagram presents a panoramic view of an enterprise technology middle‑platform architecture, illustrating its layered components, data flow, service governance, capability services, and integration points, offering a comprehensive visual guide for architects and engineers designing scalable internal platforms.

Software ArchitectureSystem Designtechnology platform
0 likes · 1 min read
What Does a Complete Enterprise Technology Middle‑Platform Architecture Look Like?
IT Architects Alliance
IT Architects Alliance
May 29, 2021 · Industry Insights

Mastering System Scalability: How to Predict and Handle Change in Architecture

The article explains why scalability is crucial for software systems, outlines the difficulty of accurately predicting future changes, and presents two architectural approaches—layer separation and abstraction/implementation layers—illustrated with diagrams and design‑pattern examples to help architects manage complexity.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 9 min read
Mastering System Scalability: How to Predict and Handle Change in Architecture
IT Architects Alliance
IT Architects Alliance
May 24, 2021 · R&D Management

What Is Software Architecture? Core Concepts, Types, and Best Practices

This article explains the essence of software architecture, outlines its main components, classifies various architecture layers such as business, application, code, and technical architecture, discusses evolution stages, measurement criteria, common pitfalls, and provides a comprehensive knowledge framework for architects.

R&D ManagementSoftware ArchitectureSystem Design
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Types, and Best Practices
IT Architects Alliance
IT Architects Alliance
May 23, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.

ComponentSoftware ArchitectureSystem Design
0 likes · 11 min read
Understanding Software Architecture: History, Concepts, and Definitions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 21, 2021 · Backend Development

When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems

This article examines how evolving software requirements can lock systems into rigid data models, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when CQRS is beneficial or detrimental, helping architects decide if separating read and write models will improve scalability and maintainability.

CQRSSoftware Architecturebackend design
0 likes · 8 min read
When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems
JD Retail Technology
JD Retail Technology
May 17, 2021 · Interview Experience

How a JD Architect Turns PaaS Challenges into Career Growth

In this interview, senior architect Li Zunjing shares his two‑stage journey at JD.com—from stabilizing e‑commerce systems to pioneering B‑PaaS—highlighting the importance of technical fundamentals, a "empty‑cup" mindset, collaborative execution, and self‑driven learning for engineering success.

JD.comPaaSSoftware Architecture
0 likes · 9 min read
How a JD Architect Turns PaaS Challenges into Career Growth
IT Architects Alliance
IT Architects Alliance
May 16, 2021 · Fundamentals

Why Domain-Driven Design Is the Key to Taming Complex Business Logic

Domain-Driven Design (DDD) offers a systematic approach to separate business complexity from technical concerns, using ubiquitous language, bounded contexts, layered and hexagonal architectures, CQRS, and strategic and tactical patterns, enabling teams to build flexible, scalable systems that quickly adapt to evolving requirements.

CQRSDomain-Driven DesignMicroservices
0 likes · 41 min read
Why Domain-Driven Design Is the Key to Taming Complex Business Logic
Top Architect
Top Architect
May 15, 2021 · Fundamentals

Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless

This article introduces the concept of software architecture and compares four major styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, disadvantages, and typical use cases, helping developers understand how architectural choices affect scalability, maintainability, and operational complexity.

DistributedServerlessSoftware Architecture
0 likes · 12 min read
Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless
Programmer DD
Programmer DD
May 15, 2021 · Backend Development

How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips

This article walks through a real‑world scenario of extending trial‑user eligibility rules, explains the logical flow using AND/OR short‑circuiting, and presents a modular Java rule engine design with abstract templates, concrete rules, a service builder, and a test case, highlighting its advantages and drawbacks.

Backend DevelopmentDesign PatternsJava
0 likes · 8 min read
How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips
Python Programming Learning Circle
Python Programming Learning Circle
May 10, 2021 · Backend Development

Functional Dependency Injection in Python: From Simple Thresholds to Contextual Composition

This article explores how to combine typed functional concepts with traditional object‑oriented dependency injection in Python, using a Django‑based word‑guessing game to illustrate naive parameter passing, its drawbacks, and a functional approach based on factories, transparent dependencies, and static typing.

Dependency InjectionFunctional ProgrammingSoftware Architecture
0 likes · 11 min read
Functional Dependency Injection in Python: From Simple Thresholds to Contextual Composition
Top Architect
Top Architect
May 10, 2021 · Fundamentals

Why UML Really Died: Historical Causes and What Replaced It

The article analyses the rise and fall of UML, tracing its origins in the 1990s, the impact of CASE tools, the shift toward agile development, and the technical and cultural reasons for its decline, while also exploring emerging lightweight modeling alternatives such as C4 and masala diagrams.

CASE toolsSoftware ArchitectureUML
0 likes · 13 min read
Why UML Really Died: Historical Causes and What Replaced It
Top Architect
Top Architect
May 9, 2021 · Backend Development

Principles and Practices for Effective Code Review and Software Architecture

This article shares a senior backend engineer's insights on why code review is essential, common pitfalls that degrade code quality, and a set of concrete principles—ranging from simplicity and composition to transparency and error handling—to guide developers in writing maintainable, scalable Go code and robust system designs.

GolangSoftware Architecturecode review
0 likes · 39 min read
Principles and Practices for Effective Code Review and Software Architecture
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 8, 2021 · Fundamentals

Mastering Behavioral Design Patterns: When and How to Use Them

This article provides a comprehensive overview of behavioral design patterns—including Chain of Responsibility, Command, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—explaining their motivations, class diagrams, advantages, disadvantages, and typical scenarios for applying each pattern in software development.

Behavioral PatternsDesign PatternsSoftware Architecture
0 likes · 20 min read
Mastering Behavioral Design Patterns: When and How to Use Them
Open Source Linux
Open Source Linux
May 8, 2021 · Fundamentals

Why Understanding Software Architecture Evolution Matters for Developers

This article outlines the evolution of software architecture—from monolithic to distributed, microservice, and serverless models—detailing each pattern’s structure, advantages, and drawbacks, helping developers understand how architectural choices impact scalability, maintenance, and innovation in modern software projects.

MicroservicesServerlessSoftware Architecture
0 likes · 12 min read
Why Understanding Software Architecture Evolution Matters for Developers
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 7, 2021 · Fundamentals

Unlocking Behavioral Design Patterns: When and How to Use Them

This article explains behavioral design patterns—how they manage complex runtime interactions among classes or objects, outlines the eleven classic patterns with their motivations, class diagrams, advantages, disadvantages, and typical scenarios, and shows why object‑based patterns offer greater flexibility than class‑based ones.

Behavioral PatternsDesign PatternsObject-Oriented Design
0 likes · 22 min read
Unlocking Behavioral Design Patterns: When and How to Use Them
Python Programming Learning Circle
Python Programming Learning Circle
May 6, 2021 · Fundamentals

Understanding 23 Classic Design Patterns Through Everyday Analogies

This article explains twenty‑three classic software design patterns—including Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using humorous real‑world scenarios to illustrate their intent and structure.

Design PatternsSoftware Architectureobject-oriented
0 likes · 17 min read
Understanding 23 Classic Design Patterns Through Everyday Analogies
Top Architect
Top Architect
Apr 30, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Framework

This article explains the fundamental notion of software architecture, why it is needed, the responsibilities of architects, various architecture classifications, typical application architectures such as layered, CQRS, hexagonal and onion models, and introduces Alibaba's open‑source COLA framework with its layered design, extension mechanisms and standards.

COLACQRSSoftware Architecture
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 29, 2021 · Fundamentals

Understanding the Singleton Pattern: Definition, Nine Implementations, Pros & Cons, and Android Applications

This article explains the Singleton design pattern, its core concept of ensuring a single instance, presents nine Java implementations with code examples, compares their advantages and disadvantages, discusses real‑world usage in Android and general development, and offers guidelines for when to apply the pattern.

AndroidDesign PatternsJava
0 likes · 15 min read
Understanding the Singleton Pattern: Definition, Nine Implementations, Pros & Cons, and Android Applications
Top Architect
Top Architect
Apr 29, 2021 · Fundamentals

Five Ways to Replace If‑Else Statements: From Basic Refactoring to Advanced Patterns

This article explores why traditional if‑else constructs often lead to tangled, hard‑to‑maintain code and presents five progressively sophisticated techniques—including removing unnecessary else blocks, using guard clauses, value‑assignment shortcuts, dictionary‑based dispatch, and strategy‑pattern refactoring—to write cleaner, more readable software.

Code RefactoringProgramming FundamentalsSoftware Architecture
0 likes · 6 min read
Five Ways to Replace If‑Else Statements: From Basic Refactoring to Advanced Patterns
IT Architects Alliance
IT Architects Alliance
Apr 28, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture

This article explains what software architecture is, why it is needed, the responsibilities of architects, various architecture classifications, common architectural styles such as layered, CQRS, hexagonal and onion, and introduces the COLA application architecture with its layered design, extension mechanisms and normative guidelines.

COLACQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
DevOps
DevOps
Apr 28, 2021 · Operations

Key Capabilities for Continuous Delivery, Architecture, Product, Lean Management, and Culture (Accelerate Insights)

The article outlines twenty‑four essential capabilities across continuous delivery, architecture, product and process, lean management, and culture, derived from the Accelerate research, providing practical guidance for organizations seeking high‑performance software delivery.

Lean ManagementSoftware Architecturecontinuous delivery
0 likes · 8 min read
Key Capabilities for Continuous Delivery, Architecture, Product, Lean Management, and Culture (Accelerate Insights)
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Apr 20, 2021 · Fundamentals

Master Design Patterns: Boost Code Reusability, Readability, and Maintainability

This comprehensive guide explains what design patterns are, why they matter, the fundamentals of object‑oriented programming, ten core SOLID principles, a mnemonic for 23 patterns, and detailed examples of creational, structural, and behavioral patterns with real‑world code snippets to help developers write cleaner, more maintainable software.

Design PatternsObject-Oriented ProgrammingSOLID principles
0 likes · 28 min read
Master Design Patterns: Boost Code Reusability, Readability, and Maintainability
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 19, 2021 · Backend Development

How to Build Scalable Business Architecture: Standards, Reuse, and Continuous Refactoring

This article examines common pain points in building and maintaining business applications, proposes a design specification that standardizes technical details, encourages component reuse, promotes continuous refactoring, and introduces a service orchestration engine to streamline complex workflow integration.

Backend DevelopmentService OrchestrationSoftware Architecture
0 likes · 15 min read
How to Build Scalable Business Architecture: Standards, Reuse, and Continuous Refactoring
Top Architect
Top Architect
Apr 18, 2021 · Fundamentals

How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices

This article explains the fundamentals of software architecture diagrams, introduces the 4+1 view taxonomy and the C4 model, describes how to choose the right diagram for different audiences, and shares practical tips, common pitfalls, and tool recommendations for clear, self‑describing architecture visuals.

C4 modelSoftware ArchitectureSystem Design
0 likes · 11 min read
How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices