Tagged articles
dependency inversion
22 articles · Page 1 of 1
This article explains why independently deployed services can still have chaotic internal architecture, and demonstrates how to separate business rules, use cases, ports, and adapters to ensure dependencies point inward, enabling testable, evolvable systems without mechanically applying layered templates.
Layered Testingbusiness rules isolationclean architecture
0 likes · 22 min read

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 codingHarness EngineeringJava
0 likes · 21 min read

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.
Layered ArchitectureSOLIDclean architecture
0 likes · 12 min read

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.
DDDLayered ArchitectureSpring Boot
0 likes · 10 min read

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.
Onion Architectureclean architecturedependency inversion
0 likes · 12 min read

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.
Factory Patternbackend architecturecode refactoring
0 likes · 6 min read

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 architecturecall vs pushdependency inversion
0 likes · 5 min read

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.
Application ArchitectureModule Designcqrs
0 likes · 22 min read

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.
DDDLayered Architecturedependency inversion
0 likes · 7 min read

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

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.
Clean CodeDesign PrinciplesInversion of Control
0 likes · 12 min read

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.
Design PrinciplesJavaOpen-Closed
0 likes · 17 min read

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.
Design PrinciplesSOLIDdependency inversion
0 likes · 44 min read

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

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.
GoSimple FactorySingle Responsibility
0 likes · 7 min read

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.
Design PrinciplesJavaSpring
0 likes · 9 min read

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.
Open/Closed Principledependency inversioninterface programming
0 likes · 11 min read

This article explains the seven SOLID design principles, illustrates dependency inversion with a car analogy, introduces inversion of control and IoC containers, and shows how these concepts improve code maintainability and modularity in software development.
IOC ContainerInversion of ControlSOLID
0 likes · 10 min read

This article explains the strategic benefits of using interfaces in software design—standardization, abstraction, and decoupling—illustrates when and why to apply them, and shows how the Dependency Inversion Principle enables flexible, testable, and maintainable architectures.
API standardsabstractiondependency inversion
0 likes · 11 min read

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.
CategoryLinkMapcomponent communication
0 likes · 31 min read

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.
SOLIDdependency inversioninterface segregation
0 likes · 21 min read

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
