BestHub
Sign in
Tagged articles

Dependency Inversion

21 articles · Page 1 of 1
Linyb Geek Road
Linyb Geek Road
Aug 4, 2026 · Backend Development

Why AI Coding Is Slower in Java and Five Steps to Build a Harness Environment

The article explains why AI‑assisted coding works smoothly for lightweight projects but stalls on Java micro‑services due to cloud‑only dependencies, and presents a five‑principle harness‑engineering approach—dependency inversion, zero‑intrusion profile isolation, CLI tool integration, local validation scripts, and a checklist—to create a fully local, AI‑friendly development loop that dramatically reduces iteration time.

AI codingCLIDependency Inversion
0 likes · 21 min read
Why AI Coding Is Slower in Java and Five Steps to Build a Harness Environment
IT Learning Made Simple
IT Learning Made Simple
Jul 18, 2026 · Fundamentals

Key Takeaways from Clean Architecture: A Practical Summary

This article distills the core concepts of Robert C. Martin’s Clean Architecture, covering layered design, SOLID principles, component cohesion and coupling rules, boundary strategies, the onion model, and why databases are merely infrastructure, all illustrated with concrete code examples and diagrams.

Clean ArchitectureDependency InversionSOLID
0 likes · 12 min read
Key Takeaways from Clean Architecture: A Practical Summary
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Backend Development

How to Layer Code with DDD: Four‑Layer Architecture, DIP & Hexagonal

This article explains why and how to separate a system into four DDD layers—User Interface, Application, Domain, and Infrastructure—illustrates the benefits of clear responsibilities, demonstrates dependency inversion and hexagonal architecture with concrete Spring Boot examples, and warns of common pitfalls.

DDDDependency InversionSpring Boot
0 likes · 10 min read
How to Layer Code with DDD: Four‑Layer Architecture, DIP & Hexagonal
ZhiKe AI
ZhiKe AI
Jun 5, 2026 · Fundamentals

Understanding Onion Architecture: Beyond the Concentric Circles

The article explains that Onion Architecture’s essence lies in inward‑facing dependencies rather than the visual onion shape, details its six‑layer structure, clarifies common misconceptions, and compares it with Clean and Hexagonal architectures to show how it improves testability and replaceability.

Clean ArchitectureDependency InversionDomain-Driven Design
0 likes · 12 min read
Understanding Onion Architecture: Beyond the Concentric Circles
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.

Dependency InversionDomain-Driven DesignModule 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
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 InversionDesign PrinciplesInversion of Control
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 InversionDesign PrinciplesObject-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 InversionDesign PrinciplesSOLID
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
Nullbody Notes
Nullbody Notes
Nov 15, 2020 · Fundamentals

Factory Method Pattern in Go: A Foodie's Take on Object Creation

This article walks through implementing Simple Factory and Factory Method patterns in Go, showing how to encapsulate object creation with a Food interface, concrete types, and factory structs, and explains the pointer vs value implementation rules and design‑principle benefits.

Dependency InversionDesign PatternsFactory Method
0 likes · 7 min read
Factory Method Pattern in Go: A Foodie's Take on Object Creation
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 InversionDesign PrinciplesSpring
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 PrincipleSoftware Design
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