BestHub
Sign in
Tagged articles
1194 articles
Page 5 of 12
21CTO
21CTO
Mar 28, 2023 · R&D Management

What Makes a Great Architect? Lessons from Alibaba’s Platform Engineering

The article shares a senior engineer’s reflections on technical architecture at Alibaba, covering top‑level design, physical and application architecture, the evolving role of architects, essential problem‑solving skills, the need for a global perspective, broad technical breadth, continuous learning, and how these insights shape effective R&D management.

R&D ManagementSoftware ArchitectureSystem Design
0 likes · 14 min read
What Makes a Great Architect? Lessons from Alibaba’s Platform Engineering
DevOps Cloud Academy
DevOps Cloud Academy
Mar 26, 2023 · Operations

Essential DevOps Capabilities for Continuous Delivery, Architecture, Product, Lean Management, and Culture

This article outlines 24 key DevOps capabilities—covering continuous delivery, loosely‑coupled architecture, product feedback, value‑stream visibility, small‑batch work, lean management, monitoring, and cultural practices—derived from the Accelerate research to improve software delivery performance.

Continuous DeliveryCultureDevOps
0 likes · 10 min read
Essential DevOps Capabilities for Continuous Delivery, Architecture, Product, Lean Management, and Culture
Bilibili Tech
Bilibili Tech
Mar 24, 2023 · Big Data

Design and Implementation of Bilibili's Event Tracking (埋点) Analysis Platform

Bilibili’s unified event‑tracking platform now manages over 120,000 definitions and ingests billions of daily events, guiding product, operation and marketing decisions through a full‑lifecycle framework—design, collection, testing, storage, and analysis—while leveraging a Spmid naming scheme, protobuf models, ClickHouse for sub‑second queries, and visual dashboards, with future plans for dynamic TTL, automated DWD tables, and deeper AB‑testing integration.

Data AnalyticsSoftware Architectureevent tracking
0 likes · 14 min read
Design and Implementation of Bilibili's Event Tracking (埋点) Analysis Platform
Continuous Delivery 2.0
Continuous Delivery 2.0
Mar 24, 2023 · Operations

Continuous Testing as a Weapon Against Architecture Decay: Practices, Performance Fences, Acceptance Test Nets, and Dependency Checks

Continuous testing, performance testing fences, acceptance test nets, and ArchUnit dependency checks are presented as practical strategies to prevent software and architecture decay, illustrated with real project experiences, CI/CD integration, and code examples for robust quality assurance.

ArchUnitSoftware Architectureacceptance testing
0 likes · 7 min read
Continuous Testing as a Weapon Against Architecture Decay: Practices, Performance Fences, Acceptance Test Nets, and Dependency Checks
Top Architect
Top Architect
Mar 23, 2023 · Fundamentals

How to Create Effective Software Architecture Diagrams: Methods, Views, and Best Practices

This article explains the purpose and classification of software architecture diagrams, introduces the 4+1 and C4 view models, describes business, application, technical, and data architectures, and provides practical guidance on drawing clear, audience‑focused diagrams that accurately reflect system design.

C4 ModelSoftware ArchitectureSystem Design
0 likes · 9 min read
How to Create Effective Software Architecture Diagrams: Methods, Views, and Best Practices
FunTester
FunTester
Mar 23, 2023 · Fundamentals

Factory Method Pattern in Go: Theory, Use Cases, and Implementation

This article explains why design patterns are needed, introduces the Factory Method pattern with its UML roles, provides a step‑by‑step Go implementation—including interfaces, concrete factories, and client code—covers a clothing‑brand example, and discusses the pattern's advantages and drawbacks while also noting its source from a Go design‑patterns book.

Creational PatternDesign PatternsFactory Method
0 likes · 11 min read
Factory Method Pattern in Go: Theory, Use Cases, and Implementation
Top Architect
Top Architect
Mar 15, 2023 · Fundamentals

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

This article explains the definition and essence of software architecture, outlines its layers and classifications, describes architectural levels and the evolution from monolithic to micro‑service designs, and discusses how to evaluate architectural rationality while highlighting typical misconceptions and best‑practice guidelines.

Architecture PatternsScalabilitySoftware Architecture
0 likes · 23 min read
Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls
Continuous Delivery 2.0
Continuous Delivery 2.0
Mar 9, 2023 · Fundamentals

Ten Essential Software Architecture Quality Attributes

The article explains ten key non‑functional quality attributes of software architecture—such as scalability, availability, consistency, resilience, usability, observability, security, persistence, agility, and maintainability—describing their meanings, typical implementation techniques, and why selecting the right attributes is crucial for any system.

AvailabilityNon-functional RequirementsScalability
0 likes · 9 min read
Ten Essential Software Architecture Quality Attributes
ByteFE
ByteFE
Mar 8, 2023 · Fundamentals

Inversion of Control and Dependency Injection in JavaScript: InversifyJS and Theia Case Study

This article revisits the concepts of Inversion of Control and SOLID design principles within the JavaScript ecosystem, explains how InversifyJS implements IoC with TypeScript decorators, demonstrates practical steps to configure containers and bindings, and shows how Theia leverages these techniques for modular front‑end and back‑end architecture, while also discussing the benefits and limitations of IoC in modern web development.

InversifyJSInversion of ControlSoftware Architecture
0 likes · 26 min read
Inversion of Control and Dependency Injection in JavaScript: InversifyJS and Theia Case Study
Continuous Delivery 2.0
Continuous Delivery 2.0
Mar 1, 2023 · Fundamentals

The Importance of Continuous Architecture and Lifelong Learning for Software Engineers

The article emphasizes that in the fast‑changing IT field, software engineers must continuously learn and adopt continuous architecture principles—guided by product thinking, quality attributes, and agile practices—to stay relevant, solve problems effectively, and sustain long‑term value creation.

Continuous ArchitectureEngineering GrowthLifelong Learning
0 likes · 9 min read
The Importance of Continuous Architecture and Lifelong Learning for Software Engineers
IT Architects Alliance
IT Architects Alliance
Mar 1, 2023 · Cloud Native

How to Break Down Monoliths: Business‑Capability vs Subdomain Strategies for Microservices

This article explains why and how to decompose large or legacy applications into microservices using business‑capability and sub‑domain (DDD) approaches, outlines their benefits, discusses common challenges such as latency and data consistency, and introduces the Strangler pattern for gradual migration.

Domain‑Driven DesignSoftware Architecturebusiness capability
0 likes · 7 min read
How to Break Down Monoliths: Business‑Capability vs Subdomain Strategies for Microservices
Open Source Linux
Open Source Linux
Feb 22, 2023 · Fundamentals

Mastering the Software Architect Role: Skills, Decisions, and Daily Practices

This article explores what a software architect does, the different levels of architecture, essential daily activities, key skills such as design, decision‑making, communication, estimation, and marketing, and offers practical advice on continuous learning, documentation, and influencing stakeholders.

Design PatternsDocumentationSoftware Architecture
0 likes · 17 min read
Mastering the Software Architect Role: Skills, Decisions, and Daily Practices
Sohu Tech Products
Sohu Tech Products
Feb 15, 2023 · Backend Development

Practical Domain-Driven Design (DDD) Modeling: Concepts, Strategic & Tactical Design, and Four‑Color Modeling

This article explains the fundamentals of Domain‑Driven Design, distinguishes strategic from tactical design, outlines core DDD elements such as domains, aggregates and bounded contexts, and demonstrates how four‑color modeling can be applied to real‑world e‑commerce microservice architectures.

DDDDomain‑Driven DesignSoftware Architecture
0 likes · 11 min read
Practical Domain-Driven Design (DDD) Modeling: Concepts, Strategic & Tactical Design, and Four‑Color Modeling
Architects Research Society
Architects Research Society
Feb 15, 2023 · Operations

Built‑in Quality: Embedding Quality Practices Across Architecture, Code, System, and Release

The article explains how built‑in quality, a core principle of SAFe and lean‑agile thinking, integrates quality into architecture, design, code, system testing, and release processes to enable fast, reliable delivery of software and hardware solutions while reducing rework and compliance risk.

Quality EngineeringSoftware Architecturebuilt-in quality
0 likes · 20 min read
Built‑in Quality: Embedding Quality Practices Across Architecture, Code, System, and Release
Architect's Journey
Architect's Journey
Feb 15, 2023 · Backend Development

How to Successfully Land DDD: A Practical Engineering Walkthrough

This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.

CQRSClean ArchitectureDDD
0 likes · 22 min read
How to Successfully Land DDD: A Practical Engineering Walkthrough
The Dominant Programmer
The Dominant Programmer
Feb 9, 2023 · Fundamentals

Java Design Pattern Examples: A Comprehensive Collection

This article compiles practical Java code examples for common design patterns—including Simple Factory, Factory Method, Abstract Factory, Singleton (eager, lazy, static inner class, enum, container), Proxy, Decorator, Prototype, Strategy, Observer, and Adapter—each linked to detailed tutorials.

Design PatternsFactoryProxy
0 likes · 3 min read
Java Design Pattern Examples: A Comprehensive Collection
IT Architects Alliance
IT Architects Alliance
Feb 7, 2023 · Fundamentals

Key Skills and Practices for Software Architects

This article provides a comprehensive guide to software architecture, detailing the three architecture levels, daily activities, ten essential skills, decision‑making techniques, communication strategies, documentation practices, and ways to balance quality, cost, and time while fostering continuous learning and community involvement.

Design PatternsDocumentationSoftware Architecture
0 likes · 16 min read
Key Skills and Practices for Software Architects
21CTO
21CTO
Feb 6, 2023 · Backend Development

When Do You Really Need Microservices? A Pragmatic Guide

The article argues that only companies with annual revenues exceeding $2 billion truly need microservices, explains the evolution from monoliths to microservices, outlines their key characteristics and trade‑offs, and offers a step‑by‑step framework for aligning architecture with business growth while minimizing complexity.

ScalabilitySoftware Architecturebusiness alignment
0 likes · 7 min read
When Do You Really Need Microservices? A Pragmatic Guide
Architects' Tech Alliance
Architects' Tech Alliance
Feb 5, 2023 · R&D Management

Key Skills and Practices for Software Architects

This article outlines the role of a software architect, describing the different architectural levels, daily activities, essential skills such as design, decision‑making, communication, documentation, estimation, and how to balance technical and non‑technical responsibilities for effective system design.

Design PatternsDocumentationSoftware Architecture
0 likes · 18 min read
Key Skills and Practices for Software Architects
IT Architects Alliance
IT Architects Alliance
Feb 3, 2023 · Backend Development

How to Structure a New Project Using Domain‑Driven Design: A Step‑by‑Step Guide

This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.

Bounded ContextClean ArchitectureDomain‑Driven Design
0 likes · 9 min read
How to Structure a New Project Using Domain‑Driven Design: A Step‑by‑Step Guide
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Feb 2, 2023 · Backend Development

Evolution of a Risk Decision Engine: From Rule Sets to Drools to a Self‑Developed Engine

This article describes the progressive evolution of a consumer‑finance risk decision engine—from an initial rule‑set implementation, through a Drools‑based configuration, to a fully self‑developed micro‑service engine—detailing architectural changes, component designs, execution flow, operational challenges, and solutions such as empty‑run testing.

DroolsRule EngineSoftware Architecture
0 likes · 30 min read
Evolution of a Risk Decision Engine: From Rule Sets to Drools to a Self‑Developed Engine
Code Ape Tech Column
Code Ape Tech Column
Feb 1, 2023 · Fundamentals

What Is a Software Architect? Roles, Levels, Daily Activities, and Essential Skills

This article explains what a software architect does, outlines the three architectural levels (application, solution, enterprise), describes the architect’s daily responsibilities, and details ten essential skills—including design, decision‑making, simplification, programming, documentation, communication, estimation, balancing, consulting, and market awareness—required for a successful career in software architecture.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 16 min read
What Is a Software Architect? Roles, Levels, Daily Activities, and Essential Skills
Architect's Guide
Architect's Guide
Feb 1, 2023 · Fundamentals

Guide to Becoming a Better Software Architect: Roles, Levels, Daily Activities, and Essential Skills

This comprehensive guide explains what a software architect does, defines the role and its hierarchical levels, outlines daily responsibilities, and details ten essential skills—including design, decision‑making, simplification, programming, and documentation—to help engineers advance toward senior architectural positions.

Design PatternsSoftware Architecturearchitect role
0 likes · 14 min read
Guide to Becoming a Better Software Architect: Roles, Levels, Daily Activities, and Essential Skills
DevOps
DevOps
Jan 31, 2023 · R&D Management

Understanding Cross-Functional Requirements for Tech Leads

The article explains what cross‑functional (non‑functional) requirements are, illustrates common scenarios where they cause system failures, outlines the perspectives of different teams in identifying them, and advises Tech Leads on how to proactively address these requirements while noting an upcoming DevOps hackathon.

Non-functional RequirementsR&D ManagementSoftware Architecture
0 likes · 6 min read
Understanding Cross-Functional Requirements for Tech Leads
IT Architects Alliance
IT Architects Alliance
Jan 30, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study

This article explains the concept of software architecture, why architectural styles are chosen, compares monolithic and distributed architectures, analyzes their pros and cons, and walks through a real‑world inventory system migration from a single‑service design to a micro‑service, CQRS‑based distributed solution with code examples and discussion of distributed transactions.

Software Architecturemonolithicrefactoring
0 likes · 16 min read
From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study
Java High-Performance Architecture
Java High-Performance Architecture
Jan 21, 2023 · Fundamentals

How to Structure a New Project with Domain‑Driven Design: From Concepts to Architecture

This article explains how to start a new project using Domain‑Driven Design, covering key terminology, the evolution of architecture layers, bounded context concepts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures.

Bounded ContextClean ArchitectureDomain‑Driven Design
0 likes · 10 min read
How to Structure a New Project with Domain‑Driven Design: From Concepts to Architecture
Top Architect
Top Architect
Jan 17, 2023 · Backend Development

Applying Domain‑Driven Design: Architecture Evolution, Bounded Contexts, and Clean Architecture

This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution from monolith to microservices, bounded context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical design guidelines for backend systems.

Backend DevelopmentClean ArchitectureDomain‑Driven Design
0 likes · 10 min read
Applying Domain‑Driven Design: Architecture Evolution, Bounded Contexts, and Clean Architecture
Architect's Guide
Architect's Guide
Jan 17, 2023 · Fundamentals

Why Managing Complexity Is Futile: Understanding Complexity Transfer and Local Consequence

The article argues that complexity in software systems cannot be eliminated but only shifted, emphasizing the inevitability of leaks, the limits of local consequence, and the practical value of layering and eliminating duplication to make frequent changes easier and code more understandable.

Design PrinciplesSoftware Architecturecode organization
0 likes · 8 min read
Why Managing Complexity Is Futile: Understanding Complexity Transfer and Local Consequence
IT Architects Alliance
IT Architects Alliance
Jan 14, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring

This article explains the concept of software architecture, compares monolithic and distributed styles, discusses their advantages and drawbacks, and details a real-world inventory system migration from a monolithic design to a distributed architecture using functional and business decomposition, CQRS, and code refactoring.

Software Architecturemonolithicrefactoring
0 likes · 17 min read
From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring
Architect
Architect
Jan 8, 2023 · Backend Development

Rethinking Microservices: From Hype to Core Architectural Principles

This article critically examines the microservices movement, tracing its historical roots, debunking common hype, and arguing that the true value lies in modular design, clear team ownership, and disciplined architectural practices rather than merely scaling distributed systems.

Distributed SystemsSoftware ArchitectureTeam Organization
0 likes · 23 min read
Rethinking Microservices: From Hype to Core Architectural Principles
Continuous Delivery 2.0
Continuous Delivery 2.0
Jan 4, 2023 · R&D Management

Key Takeaways from “Continuous Delivery 2.0”: Double‑Loop Model, Organizational Culture, and Practical Software Development Practices

This article summarizes key insights from the book “Continuous Delivery 2.0”, covering the double‑loop model, organizational culture principles, practical team processes, software architecture guidelines, requirement collaboration, deployment pipelines, branch strategy, configuration management, low‑risk releases, and real‑world case studies.

Continuous DeliveryDevOpsSoftware Architecture
0 likes · 8 min read
Key Takeaways from “Continuous Delivery 2.0”: Double‑Loop Model, Organizational Culture, and Practical Software Development Practices
dbaplus Community
dbaplus Community
Jan 3, 2023 · Fundamentals

When to Choose Monolith Over Microservices: Practical Guidance for Teams

This article examines the common perceived benefits of microservices, shows how many of them can be achieved with a well‑designed monolith, and provides concrete criteria and tactics for small, medium, and large teams to decide which architecture best fits their context.

ScalabilitySoftware Architecturedependency management
0 likes · 13 min read
When to Choose Monolith Over Microservices: Practical Guidance for Teams
Architects' Tech Alliance
Architects' Tech Alliance
Jan 3, 2023 · Fundamentals

Comprehensive Overview of Software Architecture: Concepts, Layers, Evolution, and Best Practices

This article provides a detailed introduction to software architecture, covering its definition, essential concepts such as systems, subsystems, modules, components, and frameworks, various architectural layers and classifications, evolution from monolithic to micro‑service designs, common pitfalls, evaluation criteria, and recommended learning resources.

Best PracticesScalabilitySoftware Architecture
0 likes · 21 min read
Comprehensive Overview of Software Architecture: Concepts, Layers, Evolution, and Best Practices
Top Architect
Top Architect
Jan 2, 2023 · Fundamentals

Understanding SOLID Principles, UML Relationships, and Common Design Patterns

This article explains the SOLID principles, various UML relationship types, and provides detailed descriptions of 22 classic design patterns, illustrating their intents, applicability, and implementation considerations for building clean, maintainable software architectures.

Design PatternsSOLIDSoftware Architecture
0 likes · 20 min read
Understanding SOLID Principles, UML Relationships, and Common Design Patterns
dbaplus Community
dbaplus Community
Jan 2, 2023 · R&D Management

Strategic Tech Planning for Small‑to‑Mid‑Size Companies: A Practical Guide

This article explains why midsize tech teams often struggle with outdated infrastructure, outlines a ROI‑driven planning framework, presents real‑world case studies of single‑point breakthroughs and team mergers, and offers a step‑by‑step methodology for systematic technology upgrades and sustainable growth.

R&D ManagementSoftware ArchitectureTech Strategy
0 likes · 13 min read
Strategic Tech Planning for Small‑to‑Mid‑Size Companies: A Practical Guide
Programmer DD
Programmer DD
Dec 26, 2022 · Fundamentals

20 Essential Software Architecture Principles Every Engineer Should Master

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

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

Software Architecture Principles: A Guide for Architects

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

Design PrinciplesObject-OrientedSOLID
0 likes · 11 min read
Software Architecture Principles: A Guide for Architects
Architecture Digest
Architecture Digest
Dec 25, 2022 · Fundamentals

Understanding the Decorator Pattern with Practical Java Examples

This article explains the Decorator Pattern—a design pattern that lets developers extend object behavior without modifying existing code—by describing its core components, showing a generic UML diagram, and providing three detailed Java case studies covering task processing, file I/O, and logging systems.

Decorator PatternDesign PatternsObject-Oriented
0 likes · 12 min read
Understanding the Decorator Pattern with Practical Java Examples
Architects Research Society
Architects Research Society
Dec 23, 2022 · Fundamentals

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

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

Design PrinciplesSoftware Architecturemodeling languages
0 likes · 15 min read
Fundamentals of Software Design: Concepts, Principles, and Modeling Languages
Baidu Geek Talk
Baidu Geek Talk
Dec 22, 2022 · Fundamentals

Mastering the Decorator Pattern: Real‑World Java Examples for Extensible Code

This article explains the Decorator design pattern, presents its UML structure, describes the roles of abstract components, concrete components, and decorators, and demonstrates three practical Java scenarios—task processing, file I/O, and logging—showing how to extend functionality without modifying existing classes.

Decorator PatternDesign PatternsObject-Oriented
0 likes · 12 min read
Mastering the Decorator Pattern: Real‑World Java Examples for Extensible Code
Architects Research Society
Architects Research Society
Dec 21, 2022 · Fundamentals

Evolution of Architecture Styles and Domains

This article outlines the evolution of software architecture styles, explains how different perspectives define architecture styles, and presents a comprehensive table of architecture domains and sub‑domains ranging from web and mobile applications to integration, data, analytics, and BI architectures.

Domain ArchitectureSoftware Architecturearchitecture styles
0 likes · 10 min read
Evolution of Architecture Styles and Domains
Architect's Guide
Architect's Guide
Dec 13, 2022 · Fundamentals

Complexity Must Exist Somewhere: Reflections on Software Architecture and Design

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

Design PrinciplesResilience EngineeringSoftware Architecture
0 likes · 7 min read
Complexity Must Exist Somewhere: Reflections on Software Architecture and Design
ITPUB
ITPUB
Dec 12, 2022 · Fundamentals

Why Factories Matter in Go DDD: Clean Object Creation and Validation

This article explains how introducing factories in Domain‑Driven Design with Go separates object creation logic from domain responsibilities, hides implementation details, enforces invariants, and improves validation, while showing practical code patterns and design‑pattern choices for simple and complex domain objects.

DDDDomain-Driven DesignFactory Pattern
0 likes · 15 min read
Why Factories Matter in Go DDD: Clean Object Creation and Validation
Architect
Architect
Dec 11, 2022 · Fundamentals

Why Discussing the Problem Matters More Than Choosing a Solution: Lessons from a Solution Architect

The article argues that engineers should focus on thoroughly discussing and understanding the underlying business problem before jumping to favored technical solutions, illustrating this with real‑world anecdotes about solution‑architect roles, .env file debates, micro‑service hype, and the Five Whys technique.

Software Architecturemicroservicesproblem solving
0 likes · 9 min read
Why Discussing the Problem Matters More Than Choosing a Solution: Lessons from a Solution Architect
Architects Research Society
Architects Research Society
Dec 8, 2022 · Backend Development

Key Requirements, Challenges, and Best Practices for Migrating to a Microservices Architecture

This article outlines the essential requirements for empowering autonomous teams, details the challenges of transitioning and splitting monolithic systems into microservices—including organizational, technical, and cultural hurdles—and presents comprehensive best‑practice recommendations for platform design, service development, deployment, operations, and team management.

Backend DevelopmentBest PracticesSoftware Architecture
0 likes · 12 min read
Key Requirements, Challenges, and Best Practices for Migrating to a Microservices Architecture
转转QA
转转QA
Dec 8, 2022 · Backend Development

Applying AOP to Reduce Coupling in a Data Construction Platform

This article explains how Aspect‑Oriented Programming (AOP) was introduced into a data construction platform to address high development effort, strong business coupling, and maintenance difficulty by isolating cross‑cutting concerns such as logging, thereby improving modularity, development speed, and code maintainability.

AOPAspect Oriented ProgrammingData Platform
0 likes · 5 min read
Applying AOP to Reduce Coupling in a Data Construction Platform
IT Architects Alliance
IT Architects Alliance
Dec 6, 2022 · Backend Development

A Comprehensive Guide to Service Splitting in Microservice Architecture

This article systematically explores the challenges of microservice service splitting—from technical choices and architectural reliability to business model validation and team collaboration—offering static and dynamic solutions, design principles, and practical guidelines for effective service decomposition.

Enterprise ArchitectureSoftware ArchitectureSystem Design
0 likes · 7 min read
A Comprehensive Guide to Service Splitting in Microservice Architecture
21CTO
21CTO
Dec 6, 2022 · Fundamentals

Master the 23 Core Software Architecture Principles Every Engineer Should Know

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

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

Essential Software Architecture Principles with Example Implementations

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

Design PrinciplesSOLIDSoftware Architecture
0 likes · 11 min read
Essential Software Architecture Principles with Example Implementations
IT Architects Alliance
IT Architects Alliance
Dec 1, 2022 · Fundamentals

How to Become a Better Software Architect: Roles, Skills, and Roadmap

This article outlines the essential definitions, hierarchical layers, daily responsibilities, and ten core competencies—including design, decision‑making, simplification, programming, and documentation—that aspiring software architects need to master to advance from application‑level to enterprise‑level architecture.

Design PatternsSoftware Architecturearchitect skills
0 likes · 14 min read
How to Become a Better Software Architect: Roles, Skills, and Roadmap
IT Architects Alliance
IT Architects Alliance
Nov 24, 2022 · Fundamentals

Why Code Reuse Often Fails to Improve Efficiency in System Design

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

ConsistencyDesign PrinciplesSoftware Architecture
0 likes · 9 min read
Why Code Reuse Often Fails to Improve Efficiency in System Design
Baidu Geek Talk
Baidu Geek Talk
Nov 23, 2022 · Backend Development

Applying Domain‑Driven Design (DDD) to Microservice Decomposition

The article shows how Domain‑Driven Design can guide microservice decomposition by using strategic layers (core, supporting, generic domains) and tactical building blocks (aggregates, entities, value objects, services, events), illustrated with a membership‑center example and a four‑layer Go code architecture, while noting DDD’s suitability for complex domains.

Backend DevelopmentDDDGo
0 likes · 15 min read
Applying Domain‑Driven Design (DDD) to Microservice Decomposition
Top Architect
Top Architect
Nov 23, 2022 · Backend Development

Chain of Responsibility Pattern in Java: Design, Implementation, and Practical Example

This article explains the Chain of Responsibility design pattern, demonstrates its use for request validation and processing in Java backend applications, provides complete code examples—including abstract handler, concrete validators, business logic, and a test harness—while discussing its advantages, drawbacks, and real‑world analogues such as servlet filters.

Chain of ResponsibilitySoftware Architecturedesign pattern
0 likes · 11 min read
Chain of Responsibility Pattern in Java: Design, Implementation, and Practical Example
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 23, 2022 · Fundamentals

Why Design Patterns Can Overcomplicate Software and How to Avoid Their Pitfalls

Design patterns, often hailed as software design standards, can lead to over‑engineering, increased complexity, and maintenance challenges in fast‑changing internet applications, but when applied judiciously and evolved with functional approaches, they also enhance code reuse, readability, and long‑term system growth.

Design PatternsFunctional ProgrammingSoftware Architecture
0 likes · 22 min read
Why Design Patterns Can Overcomplicate Software and How to Avoid Their Pitfalls
phodal
phodal
Nov 20, 2022 · Industry Insights

Can Fklang’s DDD‑Driven DSL Bring Industrial‑Scale Software Development?

This article explores the design and implementation of Fklang, a DDD‑guided architecture DSL, detailing its layered syntax, integration with IDEs, infrastructure abstractions, AI‑assisted code generation, mock server creation, and how it aims to industrialize software development through standardized modeling and tooling.

DDDDSLDomain Modeling
0 likes · 14 min read
Can Fklang’s DDD‑Driven DSL Bring Industrial‑Scale Software Development?
21CTO
21CTO
Nov 10, 2022 · Cloud Native

How Enterprise Architecture Evolves: From Monoliths to Cloud‑Native Platforms

This article explores the evolution of enterprise technical architecture—from single‑instance monoliths through distributed and microservice designs to modern cloud‑native platforms—detailing definitions, classifications, a real‑world case study, and the stability, efficiency, and process challenges faced along the way.

Enterprise ArchitectureSoftware Architecture
0 likes · 26 min read
How Enterprise Architecture Evolves: From Monoliths to Cloud‑Native Platforms
DevOps
DevOps
Nov 10, 2022 · Cloud Native

Fifteen Years of Software Architecture Evolution: From Monoliths to Cloud‑Native Microservices

This article reviews the 15‑year evolution of software architecture—from early monolithic systems through distributed, SOA, and microservice designs—highlighting how business drivers, cloud‑native adoption, and enduring architectural goals have shaped modern software engineering.

Digital TransformationSoftware Architecturearchitecture evolution
0 likes · 13 min read
Fifteen Years of Software Architecture Evolution: From Monoliths to Cloud‑Native Microservices
DevOps
DevOps
Nov 9, 2022 · Fundamentals

Understanding Cross‑Functional Requirements for Tech Leads

The article explains what cross‑functional (non‑functional) requirements are, illustrates common scenarios where they cause issues, and provides guidance for tech leads on identifying, discussing, and prioritizing these requirements from multiple stakeholder perspectives to avoid technical debt and risk.

Non-functional RequirementsSoftware ArchitectureTech Lead
0 likes · 5 min read
Understanding Cross‑Functional Requirements for Tech Leads
21CTO
21CTO
Nov 8, 2022 · Fundamentals

Master Software Architecture Diagrams: Clear, Audience‑Focused Design Guide

This article introduces a practical methodology for creating effective software architecture diagrams, explains the purpose and classification of various diagram types—including context, container, component, and code diagrams—offers guidelines for audience‑centric design, and showcases the C4 model with real‑world examples and tool recommendations.

C4 ModelDiagrammingSoftware Architecture
0 likes · 11 min read
Master Software Architecture Diagrams: Clear, Audience‑Focused Design Guide
DaTaobao Tech
DaTaobao Tech
Nov 7, 2022 · Fundamentals

Understanding the Decorator Pattern in Java: Concepts, Implementation, and Comparison

The article explains Java’s Decorator pattern, detailing its four roles, how to build abstract components and concrete decorators, demonstrates dynamic runtime extension of object behavior through sample code, compares it with inheritance, Proxy and Adapter patterns, and outlines its advantages, drawbacks, and suitable use cases.

Code ExampleDecorator PatternSoftware Architecture
0 likes · 15 min read
Understanding the Decorator Pattern in Java: Concepts, Implementation, and Comparison
Architect's Guide
Architect's Guide
Nov 3, 2022 · Fundamentals

Understanding Software Architecture: Definitions, Layers, and Classifications

This article explains the fundamental concepts of software architecture, distinguishing systems, subsystems, modules, components, and frameworks, and then details the various layers—business, application, data, code, technical, and deployment—while outlining the architect’s responsibilities and the criteria for when architecture design is needed.

Software ArchitectureTechnical architectureapplication architecture
0 likes · 10 min read
Understanding Software Architecture: Definitions, Layers, and Classifications
Architect
Architect
Oct 30, 2022 · Fundamentals

Managing Complexity in Software Architecture

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

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

Embracing Complexity: Reflections on Software Architecture

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

Design PrinciplesResilience EngineeringSoftware Architecture
0 likes · 7 min read
Embracing Complexity: Reflections on Software Architecture
Weimob Technology Center
Weimob Technology Center
Oct 27, 2022 · Fundamentals

Mastering Design Patterns: Essential Concepts and Real-World Frontend Examples

This article introduces design patterns, explains their origins and core principles, and demonstrates how common patterns such as Publish‑Subscribe, Strategy, Adapter, Proxy, Chain of Responsibility, and Singleton can be applied in frontend development with practical code examples and usage guidelines.

Design PatternsFrontend DevelopmentSoftware Architecture
0 likes · 19 min read
Mastering Design Patterns: Essential Concepts and Real-World Frontend Examples
Programmer DD
Programmer DD
Oct 27, 2022 · Backend Development

Do Frameworks Really Damage Software Maintainability?

This article examines how adopting software frameworks—especially web frameworks—can undermine long‑term maintainability through control inversion, mismatched goals, design trade‑offs, and hidden costs, while also showing how a decoupled approach can retain benefits without the drawbacks.

BackendSoftware Architecturecode quality
0 likes · 19 min read
Do Frameworks Really Damage Software Maintainability?
Architect's Guide
Architect's Guide
Oct 26, 2022 · Fundamentals

How to Become a Software Architect: Roles, Skills, and Practices

This article explains what a software architect does, outlines the three levels of architecture, lists daily activities and ten essential skills—including design, decision‑making, communication, documentation, estimation, and marketing—while offering practical advice on design patterns, quality metrics, technology experimentation, documentation automation, conflict resolution, and influencing stakeholders.

Design PatternsDocumentationSoftware Architecture
0 likes · 18 min read
How to Become a Software Architect: Roles, Skills, and Practices
Baidu Geek Talk
Baidu Geek Talk
Oct 25, 2022 · Fundamentals

How Adapter Pattern Solves Interface Mismatches in Real-World Scenarios

This article explains the Adapter Pattern, its core roles, and demonstrates three practical applications—object adapter for document formats, class adapter for component replacement, and interface adapter for large interfaces—complete with Java code examples and key takeaways.

Adapter PatternClass AdapterDesign Patterns
0 likes · 8 min read
How Adapter Pattern Solves Interface Mismatches in Real-World Scenarios
Alibaba Terminal Technology
Alibaba Terminal Technology
Oct 19, 2022 · Mobile Development

Reimagining Mobile Development: Unified Cross-Platform Containers and the KUN Strategy

This article outlines the evolving trends in terminal devices and software architecture, argues for unified cross‑platform containers, proposes a streamlined organizational model with fewer, more versatile roles, and introduces the KUN project—a high‑performance, extensible Flutter‑based rendering engine aimed at boosting mobile development efficiency.

FlutterMobile DevelopmentSoftware Architecture
0 likes · 23 min read
Reimagining Mobile Development: Unified Cross-Platform Containers and the KUN Strategy
Top Architect
Top Architect
Oct 18, 2022 · Fundamentals

How to Create Effective Software Architecture Diagrams: 4+1 and C4 Views

This article explains the purpose and classification of software architecture diagrams, introduces the 4+1 view model and the C4 model, and provides practical guidance on choosing the right view for different audiences to produce clear, self‑describing architectural drawings.

4+1 viewC4 ModelSoftware Architecture
0 likes · 9 min read
How to Create Effective Software Architecture Diagrams: 4+1 and C4 Views
IT Architects Alliance
IT Architects Alliance
Oct 17, 2022 · R&D Management

Mastering System Architecture Diagrams: 4+1 and C4 Views Explained

This guide explains how to create clear, self‑describing system architecture diagrams by defining architecture concepts, outlining business, application, technical and data layers, and detailing the 4+1 and C4 view models with practical tips for audience‑focused visual communication.

4+1 viewC4 ModelSoftware Architecture
0 likes · 9 min read
Mastering System Architecture Diagrams: 4+1 and C4 Views Explained
IT Architects Alliance
IT Architects Alliance
Oct 16, 2022 · R&D Management

How Progressive Thinking Shapes Business Architecture for Large-Scale Websites

The article explains why a progressive, incremental approach to business architecture—balancing clear primary requirements with flexible handling of secondary and emergent features—helps large‑scale website projects avoid the pitfalls of rigid waterfall planning and enables smoother versioned development.

R&D ManagementSoftware Architectureagile
0 likes · 10 min read
How Progressive Thinking Shapes Business Architecture for Large-Scale Websites
Programmer DD
Programmer DD
Oct 12, 2022 · Backend Development

From Monolith to Distributed: How We Transformed a Stock System with CQRS

This article explains what software architecture is, why choosing an architectural style matters, compares monolithic and distributed approaches using a real‑world inventory system case study, and details the step‑by‑step functional and business splitting, CQRS implementation, code refactoring, and handling of distributed transactions.

CQRSDistributed SystemsSoftware Architecture
0 likes · 20 min read
From Monolith to Distributed: How We Transformed a Stock System with CQRS
MaGe Linux Operations
MaGe Linux Operations
Oct 10, 2022 · Backend Development

Mastering Backend Layering: From Alibaba Specs to Practical Optimizations

This article examines common pitfalls in application layering, outlines Alibaba's recommended multi‑layer architecture, proposes an optimized layering approach with clear responsibilities for controllers, services, managers, and DAOs, and discusses domain model conversions to improve maintainability and team collaboration.

Alibaba coding standardsSoftware Architecturebackend layering
0 likes · 9 min read
Mastering Backend Layering: From Alibaba Specs to Practical Optimizations
IT Architects Alliance
IT Architects Alliance
Oct 8, 2022 · Fundamentals

Why Code Reuse May Not Boost Efficiency: A Critical Look at System Design

The article examines the common belief that reuse improves productivity, explains the logical fallacies behind it, highlights the hidden costs of over‑generalization, and proposes autonomy and consistency metrics as practical guidelines for evaluating when reuse truly adds value.

ConsistencyDesign PrinciplesSoftware Architecture
0 likes · 10 min read
Why Code Reuse May Not Boost Efficiency: A Critical Look at System Design
Architect
Architect
Oct 7, 2022 · Backend Development

What Does a Software Architect Do? Roles, Skills, and Career Path

This article explains the responsibilities, required skills, and career advice for software architects, covering job duties, real‑world examples, essential technical and soft‑skill preparation, and practical tips for advancing toward and succeeding in an architecture role.

Software ArchitectureSystem Designcareer advice
0 likes · 12 min read
What Does a Software Architect Do? Roles, Skills, and Career Path
IT Architects Alliance
IT Architects Alliance
Oct 7, 2022 · Fundamentals

Eight Common Software Architecture Design Patterns and Their Advantages and Disadvantages

The article introduces eight widely used software architecture design patterns—including single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑data‑center modes—explaining their structures, typical use cases, and the pros and cons of each.

CachingDesign PatternsScalability
0 likes · 20 min read
Eight Common Software Architecture Design Patterns and Their Advantages and Disadvantages
Architect's Guide
Architect's Guide
Oct 4, 2022 · Fundamentals

Key Insights on System Architecture, Evolution, and Feedback Loops

This article shares practical experiences and concepts about software architecture, covering stakeholder‑driven definitions, non‑functional requirements, iterative evolution, closed‑loop feedback, microservice adoption, organizational impact, and the soft skills needed for effective architects.

DevOpsSoftware Architecturefeedback loop
0 likes · 14 min read
Key Insights on System Architecture, Evolution, and Feedback Loops
MaGe Linux Operations
MaGe Linux Operations
Oct 3, 2022 · Backend Development

8 Essential Software Architecture Patterns Every Engineer Should Master

This article introduces eight core software architecture design patterns—including single‑database single‑app, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their structures, typical use cases, advantages, and drawbacks to help developers choose the right architecture for their systems.

Design PatternsScalabilitySoftware Architecture
0 likes · 21 min read
8 Essential Software Architecture Patterns Every Engineer Should Master
Architects' Tech Alliance
Architects' Tech Alliance
Oct 1, 2022 · Fundamentals

Understanding Software Architecture: Essence, Layers, and Classifications

This article explains the fundamental concepts of software architecture, distinguishing it from frameworks, defining system, subsystem, module, and component, outlining the four core aspects of architecture, and detailing the various layers such as business, application, data, code, technical, and deployment architectures.

Software ArchitectureSystem DesignTechnical architecture
0 likes · 9 min read
Understanding Software Architecture: Essence, Layers, and Classifications
DaTaobao Tech
DaTaobao Tech
Sep 30, 2022 · Fundamentals

Understanding the Strategy Design Pattern in Java

The Strategy design pattern in Java encapsulates interchangeable algorithms behind a common interface, using concrete strategy classes and a context holder to delegate behavior at runtime, which enhances flexibility, adheres to the Open/Closed principle, reduces conditional complexity, though it may increase class count and require client awareness of available strategies.

Code ExampleSoftware Architecturejava
0 likes · 14 min read
Understanding the Strategy Design Pattern in Java
Top Architect
Top Architect
Sep 27, 2022 · Fundamentals

Fundamentals of Software Architecture: Concepts, Layers, and Classifications

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

Design PrinciplesSoftware ArchitectureSystem Design
0 likes · 9 min read
Fundamentals of Software Architecture: Concepts, Layers, and Classifications
IT Architects Alliance
IT Architects Alliance
Sep 25, 2022 · Backend Development

12 Proven Strategies to Seamlessly Migrate Your Monolith to Microservices

This guide presents twelve practical steps—from understanding the trade‑offs and planning the transition to adopting monorepos, CI pipelines, API gateways, feature flags, and observability—that help teams safely decompose a large monolithic application into a robust microservices architecture.

ObservabilitySoftware Architectureapi-gateway
0 likes · 14 min read
12 Proven Strategies to Seamlessly Migrate Your Monolith to Microservices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 24, 2022 · Backend Development

12 Proven Strategies to Seamlessly Migrate from a Monolith to Microservices

This article outlines twelve practical steps—including planning, adopting a monorepo, setting up CI/CD pipelines, using API gateways, containerizing, feature flags, and adding observability—to help teams transition their large monolithic applications to a robust microservices architecture with minimal disruption.

Software Architecturemicroservicesmonolith migration
0 likes · 12 min read
12 Proven Strategies to Seamlessly Migrate from a Monolith to Microservices
HomeTech
HomeTech
Sep 23, 2022 · Backend Development

Why Use Domain-Driven Design (DDD) and How to Apply It

The article explains why Domain-Driven Design (DDD) is valuable for handling complex business logic, compares it with traditional transaction‑script approaches, introduces core DDD concepts such as ubiquitous language, bounded contexts, entities, value objects, aggregates, factories, repositories and domain services, and provides practical steps and examples for adopting DDD in backend development.

DDDDesign PatternsDomain‑Driven Design
0 likes · 12 min read
Why Use Domain-Driven Design (DDD) and How to Apply It
Top Architect
Top Architect
Sep 21, 2022 · Fundamentals

Understanding Software Architecture: Principles, Patterns, and the COLA Framework

This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architectural classifications, and introduces classic patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design, extension, and specification guidelines.

COLA frameworkCQRSHexagonal Architecture
0 likes · 16 min read
Understanding Software Architecture: Principles, Patterns, and the COLA Framework
Top Architect
Top Architect
Sep 21, 2022 · Fundamentals

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

This article explains the importance of clear software architecture diagrams, defines basic concepts and various diagram types such as context, container, component, and class diagrams, offers practical guidelines for creating self‑describing, audience‑focused diagrams, and shares tools and examples to improve communication among developers, ops, and stakeholders.

C4 ModelSoftware ArchitectureSystem Design
0 likes · 12 min read
How to Create Clear Software Architecture Diagrams: Concepts, Types, and Best Practices
DaTaobao Tech
DaTaobao Tech
Sep 21, 2022 · Fundamentals

Factory Pattern: Simple Factory, Factory Method, and Abstract Factory – Concepts, Code, UML, Pros & Cons

The article explains the Factory design pattern family—Simple Factory, Factory Method, and Abstract Factory—showing how each separates object creation from use, presents Java code and UML examples, and compares their advantages such as decoupling and Open/Closed compliance against drawbacks like increased complexity and class proliferation.

Factory PatternObject-OrientedSoftware Architecture
0 likes · 19 min read
Factory Pattern: Simple Factory, Factory Method, and Abstract Factory – Concepts, Code, UML, Pros & Cons
Architect's Guide
Architect's Guide
Sep 18, 2022 · Fundamentals

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

This article explains the importance of clear architecture diagrams, defines key concepts such as architecture and architecture diagrams, outlines the 4+1 view taxonomy, offers criteria for good diagrams, addresses common pitfalls, and introduces the C4 modeling approach with practical examples and tool recommendations.

C4 ModelSoftware Architecturearchitecture diagrams
0 likes · 13 min read
How to Create Effective Architecture Diagrams: Concepts, Types, and Best Practices
DeWu Technology
DeWu Technology
Sep 16, 2022 · R&D Management

Technical Growth Path: From Engineer to Architect and Leader

The article maps a technical professional’s journey from engineer to architect and leader, urging deep mastery of code and business logic, proactive incident handling, defensive design, domain expertise, broad architectural thinking, and balanced leadership skills to achieve sustainable career growth.

Software Architecturecareer developmentengineering management
0 likes · 21 min read
Technical Growth Path: From Engineer to Architect and Leader