Tagged articles
coupling
27 articles · Page 1 of 1
This article catalogs common pitfalls and anti-patterns that erode evolutionary architecture, including the last 10% trap in low-code tools, component reuse bottlenecks, vendor lock-in, leaky abstractions, resume-driven development, inappropriate governance, and business-driven coupling, with concrete case studies and fitness function strategies.
anti-patternscomponent reusecoupling
0 likes · 35 min read

This article dissects orchestration-driven SOA, a 1990s enterprise architecture pattern centered on a central ESB and strict service taxonomy, explaining its layered topology, how reuse led to tight coupling and bloated models, the difficulties of distributed transactions, and why its failures directly inspired modern microservices principles.
ESBSOAcoupling
0 likes · 18 min read

This article explains core architecture design principles—including layered, hexagonal, and COLA structures—covers cohesion and coupling types with evaluation criteria, presents practical strategies to reduce coupling, and details domain‑driven design concepts such as bounded contexts, aggregates, and repository patterns, all illustrated with concrete code examples and decision records.
Cohesionarchitecturecoupling
0 likes · 14 min read

The article examines coupling problems caused by multiple backend controllers and third‑party push interfaces, proposes a dedicated TPS microservice that centralizes third‑party calls via Feign, outlines its implementation with Java code, enums, factories, and demonstrates how this reduces duplication and improves maintainability.
BackendFeignarchitecture
0 likes · 9 min read

This article analyzes the high coupling caused by multiple backend controllers and third‑party push interfaces, then proposes a dedicated TPS microservice that encapsulates third‑party calls via Feign, standardizes parameters, and reduces code duplication for frontend and backend systems.
BackendFeignarchitecture
0 likes · 11 min read

This article analyzes the coupling problems caused by multiple controller calls and third‑party push interfaces, proposes a TPS microservice to centralize third‑party interactions, demonstrates Java Feign interfaces and enum‑based routing, and shows how backend and frontend can achieve low‑coupling architecture while reducing code duplication.
API DesignBackendFeign
0 likes · 9 min read

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.
CohesionDesign Principlesabstraction
0 likes · 10 min read

The article explains how high coupling caused by multiple front‑end controllers and repetitive back‑end push‑service code can be eliminated by introducing a dedicated TPS microservice that encapsulates third‑party integrations and exposes a unified Feign interface for all business systems.
FeignJavacoupling
0 likes · 6 min read

Understanding tight and loose coupling in system design, this article explains their trade‑offs, introduces a coupling degree metric based on graph theory, demonstrates calculations with example module dependencies, and discusses when each approach is preferable for performance, maintainability, and scalability.
Loose Couplingcouplinggraph theory
0 likes · 6 min read

The article analyzes coupling problems caused by multiple backend controllers and third‑party push interfaces, proposes a dedicated TPS microservice to encapsulate third‑party calls, demonstrates Feign integration with Java code examples, and concludes with a summary of benefits and further considerations.
BackendFeignarchitecture
0 likes · 8 min read

The article analyzes high coupling problems caused by multiple controller calls and third‑party integrations in a Java settlement backend, and proposes a dedicated TPS microservice with unified Feign interfaces, enum‑based routing, and factory patterns to decouple frontend and backend logic while providing implementation examples and diagrams.
FeignJavabackend development
0 likes · 7 min read

This article explains how to organize Android Gradle modules using component design principles—covering cohesion, coupling, module splitting, encapsulation, and integration—while relating them to SOLID and providing concrete examples, formulas, and best‑practice guidelines.
AndroidCohesionComponent Principles
0 likes · 24 min read

Discover ten practical C++ class design guidelines—from embracing modern standards and namespace modularization to minimizing class size, ensuring low coupling, high cohesion, immutability, and leveraging tools like CppDepend—to write cleaner, more maintainable, and thread‑safe code.
Best PracticesC++Cohesion
0 likes · 11 min read

This article explains the concept of coupling, demonstrates how traditional object creation leads to high coupling, and shows how using interfaces, the factory pattern, and reflection—culminating in Spring IOC—can dramatically lower coupling, improve reuse, and simplify maintenance in Java backend development.
Factory PatternIoCJava
0 likes · 8 min read

Software teams often grow to handle rising workload, yet adding features makes development exponentially harder because essential complexity dominates, hidden feature coupling and inevitable code decay increase system intricacy, and only refactoring, anti‑corrosion practices, and thorough documentation can mitigate the resulting business system complexity.
agile developmentcode-qualitycoupling
0 likes · 31 min read

This article explains how modules, coupling, and cohesion shape software architecture, outlines the six interface design principles, and illustrates them with classic design patterns such as Facade, Bridge, and Adapter, showing why low‑coupling and high‑cohesion lead to maintainable, extensible code.
Cohesioncouplingdesign patterns
0 likes · 5 min read

This article examines the trade‑offs between RPC and event‑driven communication in microservice architectures, detailing different types of coupling, the benefits and drawbacks of event notification and event sourcing, practical examples, and strategies such as API gateways and internal microservice design to reduce tight coupling.
API gatewayRPCcoupling
0 likes · 22 min read

This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling, designing service gateways, and deciding the appropriate number of microservices.
RPCcouplingevent-driven
0 likes · 20 min read

This article explains the importance of solid software design principles—covering readability, reusability, extensibility, maintainability, cohesion, coupling, and the seven SOLID rules—to help developers create flexible, robust, and easy‑to‑maintain systems.
CohesionDesign PrinciplesSOLID
0 likes · 16 min read

The article explains the concept of software testability, outlines controllability and observability factors, discusses cohesion and coupling, suggests practices such as TDD and design patterns, and introduces tools like testability‑explorer and Sonar for measuring and enhancing testability.
Cohesioncode qualitycoupling
0 likes · 8 min read

This article explains software design patterns, their origins, key examples, and how MITRE system engineers can apply them to manage coupling and interface design in large enterprise service environments, emphasizing loose coupling, best‑practice guidelines, and practical lessons learned.
couplingdesign patternsinterface design
0 likes · 13 min read

The article examines synchronous request‑response microservices, outlining their numerous drawbacks such as tight coupling, scalability limits, failure handling, API versioning challenges, data access coupling, distributed monolith risks, and testing difficulties, while also acknowledging their undeniable advantages and the prevalence of hybrid architectures.
Request/ResponseSynchronousarchitecture
0 likes · 8 min read

This article explains the concept of coupling in object‑oriented programming, distinguishes strong and weak coupling with Java examples, and presents two practical techniques—upcasting/interface callbacks and the adapter pattern—to achieve low coupling and improve code modularity.
JavaOOPcoupling
0 likes · 6 min read

The article explains the concepts of modules, coupling, and cohesion, outlines key interface design principles such as Single Responsibility and Dependency Inversion, and illustrates these ideas with practical examples of design patterns like Facade, Bridge, and Adapter, including code snippets.
Cohesioncouplingdesign patterns
0 likes · 4 min read

The article explains how microservices communicate via RPC or event‑driven approaches, analyzes different coupling types, compares event notification and event sourcing, discusses API‑gateway and service composition, and offers practical guidance on limiting microservice count and using internal microservice design.
API gatewayRPCcoupling
0 likes · 19 min read

This article explores how coupling and cohesion influence React component design, compares several prop‑passing techniques—from static components to object, selective, map/array, and child‑object approaches—and offers guidance on selecting the most suitable pattern based on project context and maintainability.
CohesionPropsReact
0 likes · 12 min read

This article explains core OO architecture principles such as low coupling and high cohesion, outlines methods to reduce coupling, advocates composition over inheritance, and provides concise overviews of widely used design patterns like MVC, MVVM, Factory, Singleton, Builder, and many others.
OO architecturecouplingsoftware design
0 likes · 7 min read
