BestHub
Sign in
Tagged articles
1187 articles
Page 7 of 12
Top Architect
Top Architect
Jan 15, 2022 · Backend Development

Technical Architecture Design Principles: Strategy and Tactics for Backend Systems

This article explains how to design robust backend technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and practical implementation tips.

Software ArchitectureSystem DesignTechnical architecture
0 likes · 14 min read
Technical Architecture Design Principles: Strategy and Tactics for Backend Systems
Top Architect
Top Architect
Dec 31, 2021 · Fundamentals

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

This article explains the fundamentals of software architecture, why it is needed, the responsibilities of architects, various architectural classifications, and introduces classic and modern application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.

COLACQRSDesign Patterns
0 likes · 14 min read
Understanding Software Architecture: Concepts, Layers, and the COLA Framework
IT Architects Alliance
IT Architects Alliance
Dec 31, 2021 · Industry Insights

A Complete 19‑Part Knowledge Map for Software Architects

The article presents a detailed 19‑section knowledge map for software architects, covering everything from core responsibilities and fundamentals to distributed caching, messaging, load balancing, performance testing, OS, algorithms, networking, databases, JVM, micro‑services, DDD, security, high availability, big data, and blockchain, with visual mind‑maps for each topic.

Big DataBlockchainDistributed Systems
0 likes · 4 min read
A Complete 19‑Part Knowledge Map for Software Architects
Open Source Linux
Open Source Linux
Dec 31, 2021 · Fundamentals

Which Programming Languages Power Today's Operating Systems and Software?

This article surveys the programming languages and technology stacks behind a wide range of operating systems, user interfaces, desktop search tools, office suites, databases, browsers, servers, and other software, highlighting the prevalence of C, C++, Java, and other languages across the industry.

Operating SystemsSoftware ArchitectureTechnology Stack
0 likes · 10 min read
Which Programming Languages Power Today's Operating Systems and Software?
Architect
Architect
Dec 30, 2021 · Backend Development

Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture

The article explains how the misconception of treating distribution as the whole of microservices leads to a distributed‑monolith trap, and shows how mixing command‑driven and event‑driven communication can decouple services, improve reliability, and guide a smooth migration from monolith to microservices.

Command PatternEvent-drivenMicroservices
0 likes · 11 min read
Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture
21CTO
21CTO
Dec 25, 2021 · Cloud Native

When Should You Split a Monolith? Strategies and Principles for Microservice Migration

This article explains why and when to break a monolithic application into microservices, outlines the business and technical signals that trigger splitting, presents guiding principles, functional and non‑functional strategies, and risk‑mitigation practices to ensure a smooth, sustainable migration.

Domain-Driven DesignMicroservicesService Splitting
0 likes · 21 min read
When Should You Split a Monolith? Strategies and Principles for Microservice Migration
IT Architects Alliance
IT Architects Alliance
Dec 22, 2021 · Industry Insights

Mastering Technical Architecture: Strategic & Tactical Design Principles for Scalable Systems

This article explains how to transform product requirements into robust technical architectures by addressing uncertainty through strategic principles—suitability, simplicity, evolution—and tactical guidelines covering high concurrency, high availability, and business design, illustrated with logical and physical diagrams.

ScalabilitySoftware Architecturedesign principles
0 likes · 14 min read
Mastering Technical Architecture: Strategic & Tactical Design Principles for Scalable Systems
21CTO
21CTO
Dec 20, 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.

Software ArchitectureSystem Designdesign principles
0 likes · 14 min read
Mastering Software Architecture: Strategic & Tactical Design Principles
IT Architects Alliance
IT Architects Alliance
Dec 16, 2021 · Fundamentals

What Really Defines Software Architecture? Core Concepts and Layers Explained

This article clarifies the essence of software architecture by defining key concepts such as system, subsystem, module, component, framework versus architecture, and then details the multiple architectural layers—including business, application, data, code, technical, and deployment—while highlighting their purposes, relationships, and design considerations.

Software ArchitectureSystem DesignTechnical architecture
0 likes · 11 min read
What Really Defines Software Architecture? Core Concepts and Layers Explained
Architecture Digest
Architecture Digest
Dec 15, 2021 · Fundamentals

Object‑Oriented Modeling: Concepts, Attributes, Composition, and Code Examples

This article explains the philosophical basis of object‑oriented thinking, distinguishes attributes and operations, compares data‑model and object‑model designs with Java and SQL examples, discusses composition versus aggregation through a digestion model, and illustrates application‑service patterns in account credit scenarios.

Domain-Driven DesignSoftware Architecturejava
0 likes · 13 min read
Object‑Oriented Modeling: Concepts, Attributes, Composition, and Code Examples
Architects Research Society
Architects Research Society
Dec 14, 2021 · Fundamentals

Context Mapping Patterns in Domain-Driven Design

The article explains various context‑mapping techniques from Domain‑Driven Design—such as Partnership, Shared Kernel, Customer/Supplier, Conformist, Anti‑Corruption Layer, Open Host Service, and Published Language—and advises when to apply each based on code, team, and business considerations.

Bounded ContextDomain-Driven DesignIntegration Patterns
0 likes · 7 min read
Context Mapping Patterns in Domain-Driven Design
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 14, 2021 · Fundamentals

What Really Defines Software Architecture? Core Concepts and Layers Explained

This article clarifies the fundamental concept of software architecture, distinguishes related terms such as system, subsystem, module, component, framework, and architecture, and outlines the five major architectural layers—business, application, data, code, technical, and deployment—providing a comprehensive guide for architects and developers.

Software ArchitectureSystem DesignTechnical architecture
0 likes · 12 min read
What Really Defines Software Architecture? Core Concepts and Layers Explained
Java Captain
Java Captain
Dec 12, 2021 · Backend Development

Why a Good Code Structure Matters and How to Design It: Models, Utils, Services, DAO, and Controllers

The article explains why a solid code structure is essential, outlines the principles of single responsibility, reusability and clear definitions, and details the roles of Model, Util, Service, DAO and Controller, while discussing their relevance to Web, Android and iOS development.

Model-View-ControllerSoftware Architecturecode-structure
0 likes · 9 min read
Why a Good Code Structure Matters and How to Design It: Models, Utils, Services, DAO, and Controllers
YunZhu Net Technology Team
YunZhu Net Technology Team
Dec 10, 2021 · Backend Development

Understanding Rule Engines: Concepts, Patterns, and Practical Applications

This article explains what a rule engine is, why it is useful, common products, core concepts such as rule files, LHS/RHS, facts, and various modeling patterns, as well as management, execution modes, real‑world use cases and best‑practice recommendations for building scalable backend rule‑processing systems.

Business RulesDecision TableSoftware Architecture
0 likes · 17 min read
Understanding Rule Engines: Concepts, Patterns, and Practical Applications
Java High-Performance Architecture
Java High-Performance Architecture
Dec 9, 2021 · Fundamentals

Bridging the Language Gap: How a Ubiquitous Domain Model Enhances DDD Collaboration

This article explains how mismatched vocabularies between domain experts and developers hinder project progress, and how establishing a shared, model‑driven language can reduce misunderstandings, streamline communication, and improve the reliability of software built with Domain‑Driven Design.

CollaborationDomain-Driven DesignModeling
0 likes · 8 min read
Bridging the Language Gap: How a Ubiquitous Domain Model Enhances DDD Collaboration
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 7, 2021 · Backend Development

How to Standardize Business Architecture: A Layered Design Blueprint

This article presents a comprehensive, layer‑by‑layer framework for unifying business architecture design, detailing product contracts, business models, services, flows, components, infrastructure, and model adapters, and shows how low‑code and hard‑coded approaches can be combined to accelerate development while maintaining consistency.

Design PatternsSoftware Architecturebackend-development
0 likes · 25 min read
How to Standardize Business Architecture: A Layered Design Blueprint
Architecture Digest
Architecture Digest
Dec 7, 2021 · Fundamentals

Bridging the Language Gap in Domain‑Driven Design

The article explains how mismatched vocabularies between domain experts and developers hinder project progress, and argues that establishing a shared, model‑driven language—central to Domain‑Driven Design—can improve communication, reduce misunderstandings, and create more reliable software.

CollaborationDomain-Driven DesignSoftware Architecture
0 likes · 8 min read
Bridging the Language Gap in Domain‑Driven Design
Qingyun Technology Community
Qingyun Technology Community
Nov 30, 2021 · Fundamentals

How Low‑Code Platforms Design Flexible Workflows: From Train Tracks to Nodes

This article explains workflow fundamentals using a train‑transport analogy, describes key design elements such as forms, task nodes, and routing, compares open‑source engines, and details a low‑code platform architecture that separates business logic, process control, and event handling for flexible, distributed execution.

NodeProcess DesignSoftware Architecture
0 likes · 11 min read
How Low‑Code Platforms Design Flexible Workflows: From Train Tracks to Nodes
HelloTech
HelloTech
Nov 30, 2021 · Backend Development

Applying Domain-Driven Design and Microservice Architecture in E-commerce Business

The talk demonstrates how to apply Domain‑Driven Design and microservice architecture to an e‑commerce voucher platform by defining problem spaces and bounded contexts, prioritizing boundaries over aggregates, using layered‑on‑demand infrastructure, and following SOLID principles to achieve clear, maintainable services.

DDDDomain-Driven DesignMicroservices
0 likes · 12 min read
Applying Domain-Driven Design and Microservice Architecture in E-commerce Business
Architects' Tech Alliance
Architects' Tech Alliance
Nov 29, 2021 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

This article introduces seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their contexts, problems they solve, typical structures, advantages, drawbacks, and suitable application scenarios.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
Top Architect
Top Architect
Nov 27, 2021 · Fundamentals

Understanding Software Architecture: From Basic Concepts to the COLA Framework

This article explains the fundamentals of software architecture, why architecture is needed, the responsibilities of architects, various architecture categories, common styles such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension points and standards.

COLA frameworkCQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: From Basic Concepts to the COLA Framework
Java High-Performance Architecture
Java High-Performance Architecture
Nov 26, 2021 · Fundamentals

Mastering Domain-Driven Design: Key Principles and Practical Insights

This article shares eight months of hands‑on experience with Domain‑Driven Design, explaining why traditional waterfall approaches hinder true business understanding and presenting practical notes, mind‑map visualizations, and step‑by‑step guidance on effective modeling, knowledge digestion, continuous learning, and deep model design.

Domain-Driven DesignModelingSoftware Architecture
0 likes · 12 min read
Mastering Domain-Driven Design: Key Principles and Practical Insights
DevOps Cloud Academy
DevOps Cloud Academy
Nov 26, 2021 · Operations

Key Capabilities for Continuous Delivery and DevOps Performance

The article outlines twenty‑four essential capabilities—including version control, automated deployment, continuous integration, trunk‑based development, test automation, lean management, and cultural practices—that together drive high‑performance software delivery and organizational effectiveness.

CultureDevOpsLean Management
0 likes · 10 min read
Key Capabilities for Continuous Delivery and DevOps Performance
Sohu Tech Products
Sohu Tech Products
Nov 24, 2021 · Frontend Development

Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation

This article explains how Vivo Game Center adopted a modular architecture—combining componentization, configuration, and experiment-driven deployment—to enable rapid, flexible UI layout adjustments, unified backend processes, and data-driven A/B testing, thereby improving development efficiency and user‑targeted operations.

AB testingBackendSoftware Architecture
0 likes · 17 min read
Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 23, 2021 · Fundamentals

Why Object‑Oriented Design Still Matters: From Machine Code to Domain‑Driven Architecture

This article traces the evolution of programming paradigms—from low‑level machine code through procedural and object‑oriented approaches—explains the pitfalls of poor abstraction, introduces domain‑driven design, and reviews key software design principles such as SOLID, OCP, DIP, PLOA and KISS.

Programming ParadigmsSOLIDSoftware Architecture
0 likes · 21 min read
Why Object‑Oriented Design Still Matters: From Machine Code to Domain‑Driven Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Nov 22, 2021 · Fundamentals

Understanding Software Architecture and the COLA Application Architecture

This article explains the concept of software architecture, its necessity, the role of architects, various architectural categories, typical patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA open‑source application architecture with its layered design, extension mechanisms, and specification guidelines.

COLACQRSHexagonal Architecture
0 likes · 14 min read
Understanding Software Architecture and the COLA Application Architecture
IT Architects Alliance
IT Architects Alliance
Nov 21, 2021 · R&D Management

Mastering Software Architecture: From Basics to Evolution

This comprehensive guide explains the essence of software architecture, its layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, and key metrics for evaluating a sound architecture.

Architecture PatternsDistributed SystemsMicroservices
0 likes · 22 min read
Mastering Software Architecture: From Basics to Evolution
Architects' Tech Alliance
Architects' Tech Alliance
Nov 19, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls

This article provides a comprehensive overview of software architecture, covering its definition, essential concepts such as systems, subsystems, modules, and frameworks, various architectural layers and classifications, evolution from monolithic to microservices, design principles, evaluation criteria, and typical misconceptions to avoid.

Architecture PatternsMicroservicesScalability
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls
Architecture Digest
Architecture Digest
Nov 13, 2021 · Fundamentals

Anemic vs. Rich Domain Models: Core Concepts of Domain‑Driven Design

The article explains the differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, drawbacks, and provides guidance on when and how to apply each model in software design.

Domain-Driven DesignObject-Oriented DesignRich Model
0 likes · 9 min read
Anemic vs. Rich Domain Models: Core Concepts of Domain‑Driven Design
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 5, 2021 · Backend Development

Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices

This article explains the fundamentals of Domain-Driven Design, covering its core concepts, step‑by‑step design methodology, domain modeling techniques, and how to apply DDD in microservice architectures with considerations for technical elements such as distributed transactions and scalability.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 7 min read
Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices
macrozheng
macrozheng
Nov 1, 2021 · Backend Development

Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton

This article explores six classic design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—detailing their real‑world business scenarios, core principles, Java implementations with Spring integration, and how they improve code maintainability, extensibility, and adherence to SOLID principles.

SOLIDSoftware Architecturejava
0 likes · 27 min read
Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton
Top Architect
Top Architect
Oct 27, 2021 · Backend Development

Technical Architecture Design Principles: Strategy, Tactics, and Practical Guidelines

This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, and tactical principles covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical implementation advice.

Software ArchitectureSystem Designdesign principles
0 likes · 15 min read
Technical Architecture Design Principles: Strategy, Tactics, and Practical Guidelines
Selected Java Interview Questions
Selected Java Interview Questions
Oct 25, 2021 · Fundamentals

Understanding Factory and Strategy Design Patterns in Java

This article explains the differences and similarities between the Factory and Strategy design patterns in Java, provides concrete code examples for each, and discusses how the Strategy pattern can offer more flexible behavior composition compared to the traditional Factory approach.

Design PatternsFactory PatternSoftware Architecture
0 likes · 7 min read
Understanding Factory and Strategy Design Patterns in Java
IT Architects Alliance
IT Architects Alliance
Oct 17, 2021 · Fundamentals

Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices

The article explains how Domain-Driven Design (DDD) rose to prominence by addressing business‑boundary challenges in microservice architectures, outlines the evolution of software architectures, and details DDD’s strategic and tactical design practices for creating clear, maintainable service boundaries.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 9 min read
Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices
21CTO
21CTO
Oct 12, 2021 · Fundamentals

Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems

This article explains how good software architecture enables easy evolution, fault tolerance, and low maintenance, while bad architecture leads to complexity and brittleness, and it outlines key principles, design styles, and practical techniques such as domain‑centric, microservices, event‑driven, and CQRS to build robust, adaptable systems.

Design PatternsDomain-Driven DesignMicroservices
0 likes · 14 min read
Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems
Architecture Digest
Architecture Digest
Oct 12, 2021 · Fundamentals

Introduction to Domain-Driven Design (DDD)

This article provides a concise overview of Domain-Driven Design, explaining why it matters, defining key concepts such as domain, model, bounded context, and ubiquitous language, and illustrating how DDD helps teams tackle core software complexity through collaborative modeling and shared terminology.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 11 min read
Introduction to Domain-Driven Design (DDD)
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Oct 11, 2021 · Frontend Development

DrawIO Secondary Development: A Comprehensive Technical Guide

This guide walks developers through DrawIO secondary development, explaining why integration is needed, how to set up Java/Ant, clone and build the source, configure dev mode, deploy via various platforms, and use core APIs like getCurrentFile and loadFile, with a starter scaffold on GitHub.

Diagram ToolJavaScriptNext.js
0 likes · 23 min read
DrawIO Secondary Development: A Comprehensive Technical Guide
Architect
Architect
Oct 11, 2021 · Databases

How to Efficiently Read Redis Source Code: A Step-by-Step Guide

This article presents a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, balancing overall structure with detailed logic, handling auxiliary features, and performing targeted gap‑filling to master the codebase.

Software Architecturedatabaseprogramming
0 likes · 14 min read
How to Efficiently Read Redis Source Code: A Step-by-Step Guide
Programmer DD
Programmer DD
Oct 10, 2021 · Backend Development

Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Backend Development

Microservice architecture introduces complexity, but using scaffolding tools such as Spring Boot and Spring Data lets developers focus on business logic by providing reusable components, reducing duplication, and simplifying data access, while avoiding the pitfalls of building custom persistence layers from scratch.

MicroservicesSoftware ArchitectureSpring Boot
0 likes · 12 min read
Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Backend Development
IT Architects Alliance
IT Architects Alliance
Oct 10, 2021 · Industry Insights

10 Essential Software Architecture Patterns Every Engineer Should Know

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

Architecture PatternsDesign PatternsSoftware Architecture
0 likes · 9 min read
10 Essential Software Architecture Patterns Every Engineer Should Know
Architects' Tech Alliance
Architects' Tech Alliance
Oct 9, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines key architectural concepts such as systems, subsystems, modules, components, frameworks, and the role of software architecture in managing complexity.

Software Architecturearchitectural fundamentalshistory of programming
0 likes · 14 min read
Understanding Software Architecture: History, Concepts, and Definitions
Java Architect Essentials
Java Architect Essentials
Oct 7, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Types, and Evolution

This article explains the essence of software architecture, defining systems, subsystems, modules, components, frameworks, and various architectural layers such as business, application, data, code, technical, and deployment, and discusses architectural evolution from monolithic to distributed and microservice designs, including common pitfalls and recommended reading.

Architecture PatternsDistributed SystemsSoftware Architecture
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Types, and Evolution
Architect
Architect
Oct 5, 2021 · Fundamentals

Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities

The article explains the core characteristics of entities—identity and continuity—using DDD concepts, demonstrates why a Message in a messaging scenario qualifies as an entity, and argues that senders and recipients (contacts) should also be modeled as entities rather than value objects.

DDDDomain-Driven DesignEntity
0 likes · 12 min read
Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities
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.

Software Architecturedesign principleshigh concurrency
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.

Career DevelopmentDesign PatternsDistributed Systems
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 PatternsSoftware Architecturejava
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.

Distributed SystemsR&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.

AlibabaCTOSoftware Architecture
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.

CTODigital TransformationSoftware 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.

MicroservicesSoftware ArchitectureSpring Boot
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.

Software ArchitectureStrategic DesignTactical 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.

Domain-Driven DesignSoftware ArchitectureStrategic Design
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.

FrameworkLowCodeSoftware Architecture
0 likes · 10 min read
Exploring Lowcode and Micro‑Frontend: Towards the Next Generation Front‑End Framework
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.

Agile DevelopmentDomain-Driven DesignMicroservices
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.

BehavioralCreationalSoftware Architecture
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.

DDDDomain-Driven DesignSoftware Architecture
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.

RAIL modelSoftware ArchitectureSystem Design
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 frameworkCQRSHexagonal 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.

Software ArchitectureSystem Designbackend-development
0 likes · 17 min read
What Does It Take to Become a Great Software Architect? Key Skills and Practices
Top Architect
Top Architect
Jul 29, 2021 · Mobile Development

Cross‑Platform Architecture for WeChat Pay: Reducing Bugs, Improving Efficiency, and Managing Data Flow

The article describes how a C++‑based cross‑platform framework and a unified routing mechanism were introduced to solve iOS and Android inconsistencies in WeChat Pay, resulting in fewer bugs, 45% less code, faster feature delivery, and a more reliable data‑flow architecture.

Mobile DevelopmentSoftware ArchitectureWeChat Pay
0 likes · 13 min read
Cross‑Platform Architecture for WeChat Pay: Reducing Bugs, Improving Efficiency, and Managing Data Flow
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.

MicroservicesService MeshSoftware Architecture
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 PatternsHexagonal 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.

Software ArchitectureSystem Designdatabase scaling
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.

ModelingSoftware Architecturebusiness analysis
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.

Code RefactoringSoftware ArchitectureTechnical Debt
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.

Architect RolesSoftware ArchitectureSystem Design
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.

SQL OptimizationSoftware Architecturecode quality
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 OptimizationSoftware ArchitectureTechnical Debt
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