BestHub
Sign in
Tagged articles
16 articles
Page 1 of 1
Architect
Architect
Nov 17, 2024 · Backend Development

How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat

The article presents a real‑world case of a multi‑tenant system whose business logic was tightly coupled across tenants, leading to a massive service class, and demonstrates how applying Domain‑Driven Design, the Dependency Inversion Principle, and the Factory pattern can restructure the code into isolated tenant‑specific actions, improving maintainability and testability.

Backend ArchitectureCode RefactoringDependency Inversion
0 likes · 6 min read
How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat
Architecture Breakthrough
Architecture Breakthrough
Oct 22, 2024 · Backend Development

Can You Bypass the Mid‑Platform? When Direct Calls Across Service Layers Make Sense

The article analyzes a post‑mid‑platform reconstruction architecture, questioning whether channel or product layers can call backend modules directly, whether lower‑level services can push upward without breaking dependency inversion, and clarifies the subtle distinction between top‑down calls and bottom‑up pushes.

Backend ArchitectureDependency Inversioncall vs push
0 likes · 5 min read
Can You Bypass the Mid‑Platform? When Direct Calls Across Service Layers Make Sense
DaTaobao Tech
DaTaobao Tech
Jan 8, 2024 · Fundamentals

Understanding Application Architecture: From Chaos to Order

Understanding an application's architecture—defining clear module and package hierarchies, adopting layered patterns like Hexagonal or Clean Architecture, and applying principles such as Dependency Inversion and CQRS—transforms chaotic codebases into maintainable, testable systems that reduce onboarding time and simplify future development.

CQRSDependency InversionDomain-Driven Design
0 likes · 22 min read
Understanding Application Architecture: From Chaos to Order
JD Retail Technology
JD Retail Technology
Aug 25, 2023 · Fundamentals

From Traditional Layered Architecture to Hexagonal and Clean Architecture: Principles, Problems, and Dependency Inversion

This article explains the traditional strict and loose layered architectures, highlights their coupling issues, introduces the Dependency Inversion Principle as a solution, and shows how applying it leads to hexagonal and clean architecture designs with illustrative diagrams and code examples.

DDDDependency InversionHexagonal Architecture
0 likes · 7 min read
From Traditional Layered Architecture to Hexagonal and Clean Architecture: Principles, Problems, and Dependency Inversion
Architects Research Society
Architects Research Society
Feb 10, 2023 · Fundamentals

Understanding Hexagonal Architecture: Principles and Implementation Example

The article explains the three core principles of Hexagonal (Ports‑and‑Adapters) Architecture, illustrates how to separate application, domain, and infrastructure code with concrete C# examples, and shows how this separation improves testability, dependency inversion, and modular design.

Dependency InversionDomain-Driven DesignHexagonal Architecture
0 likes · 18 min read
Understanding Hexagonal Architecture: Principles and Implementation Example
Top Architect
Top Architect
Dec 5, 2022 · Fundamentals

Essential Software Architecture Principles Explained by a Senior Architect

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

Dependency InversionInversion of Controlclean code
0 likes · 12 min read
Essential Software Architecture Principles Explained by a Senior Architect
The Dominant Programmer
The Dominant Programmer
Nov 1, 2022 · Fundamentals

Understanding SOLID Design Principles with Java Code Examples

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

Dependency InversionJavaObject-Oriented
0 likes · 17 min read
Understanding SOLID Design Principles with Java Code Examples
Continuous Delivery 2.0
Continuous Delivery 2.0
Aug 22, 2022 · Fundamentals

Key Principles for Code Review and Software Architecture

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

Dependency InversionGolangSOLID
0 likes · 44 min read
Key Principles for Code Review and Software Architecture
Architects Research Society
Architects Research Society
Aug 24, 2021 · Fundamentals

Understanding Hexagonal Architecture: Principles and Implementation Example

Hexagonal Architecture, introduced by Alistair Cockburn in 2005 and revived since 2015, separates application, domain, and infrastructure layers using ports and adapters, enabling isolated testing, clear dependency direction, and flexible code organization, illustrated with a console‑based poem‑printing example and detailed implementation guidelines.

Dependency InversionHexagonal Architectureports and adapters
0 likes · 17 min read
Understanding Hexagonal Architecture: Principles and Implementation Example
JavaEdge
JavaEdge
Oct 10, 2020 · Fundamentals

Why High‑Level Modules Should Depend on Abstractions: Mastering Dependency Inversion

This article explains the Dependency Inversion Principle, shows why traditional layered architectures suffer from maintenance and reuse problems, provides concrete Java and web examples, and demonstrates how refactoring to abstract interfaces resolves these issues for more flexible, decoupled software design.

Dependency InversionJavaSoftware Architecture
0 likes · 9 min read
Why High‑Level Modules Should Depend on Abstractions: Mastering Dependency Inversion
macrozheng
macrozheng
Jun 5, 2020 · Fundamentals

Why Interface‑Oriented Programming Makes Your Code Flexible and Extensible

This article explains the concept of interface‑oriented programming, using everyday analogies and Java code examples to show how defining contracts via interfaces decouples components, improves extensibility, and follows solid design principles such as the Open‑Closed Principle.

Dependency InversionOpen/Closed Principleinterface programming
0 likes · 11 min read
Why Interface‑Oriented Programming Makes Your Code Flexible and Extensible
Meituan Technology Team
Meituan Technology Team
Nov 8, 2018 · Mobile Development

iOS Component Communication: Category Techniques, Dependency Inversion, and Risk Management

The article explains how Objective‑C Categories can implement a low‑overhead, type‑safe communication layer between iOS components, compares alternative patterns like DI, SPI and NotificationCenter, presents performance data, and proposes two Category‑based schemes with tooling to detect method‑name conflicts and ensure maintainable modular architecture.

CategoryDependency InversionLinkMap
0 likes · 31 min read
iOS Component Communication: Category Techniques, Dependency Inversion, and Risk Management
Java Captain
Java Captain
Jun 23, 2018 · Fundamentals

Common Object‑Oriented Design Principles: SOLID, Dependency Inversion, Interface Segregation, Composite Reuse, and the Law of Demeter

This article summarizes the most widely used object‑oriented design principles—including the five SOLID rules, the Composite/Aggregate Reuse Principle, the Law of Demeter, and related guidelines—explaining their definitions, analyses, advantages, and practical examples for improving software modularity and maintainability.

Dependency InversionObject-OrientedSOLID
0 likes · 21 min read
Common Object‑Oriented Design Principles: SOLID, Dependency Inversion, Interface Segregation, Composite Reuse, and the Law of Demeter
Baixing.com Technical Team
Baixing.com Technical Team
Dec 12, 2017 · Mobile Development

Why Composition Beats Inheritance in Android List Refactoring

This article explains how refactoring the Baixing Android app’s list feature from an inheritance-heavy design to a composition-based architecture improves modularity, reduces coupling, and eases future extensions by applying OOP principles such as dependency inversion and component interfaces.

Component ArchitectureComposition over InheritanceDependency Inversion
0 likes · 11 min read
Why Composition Beats Inheritance in Android List Refactoring