1 views collected around this technical thread.
This guide explains the purpose of UseCases, best practices for their responsibilities, naming conventions, thread‑safety considerations, common anti‑patterns, and answers frequent questions, providing Kotlin code examples to illustrate correct and incorrect implementations.
The team refactored a high‑traffic Vue2 detail page to Vue3 using Clean Architecture, separating entities, use‑cases, adapters, and framework layers, while employing AST‑based tooling, comprehensive unit/E2E/visual tests, and a gray‑release strategy, resulting in reduced duplication, better test coverage, and a reusable migration pipeline.
This article explains how to start a new project using Domain-Driven Design, covering IAAS/PAAS/SAAS terminology, architecture evolution, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their impact on microservice design.
UseCase objects, placed in the Domain layer of modern Android architecture, encapsulate complex business logic that was previously crammed into ViewModels, thereby enforcing clean separation of concerns, adhering to the Single Responsibility Principle, and making the codebase clearer, more maintainable, and scalable.
This article shares practical experiences and detailed technical solutions for applying Domain‑Driven Design, Clean (Onion) Architecture, CQRS, and Saga patterns in backend systems, covering theory recap, modeling methods, module separation, code examples, and distributed transaction strategies.
The article explains clean, hexagonal, and DDD layered architectures, detailing each layer’s responsibilities, principles, and evolution, and shows how DDD layering enhances microservice design, promotes strict separation, supports architectural evolution, and guides the transition from traditional three‑tier systems to modern domain‑driven microservices.
This article provides a detailed overview of the latest 2023 trends, tools, libraries, architectural patterns, and best practices for developing modern Android applications, covering everything from Kotlin and Jetpack Compose to Clean Architecture, modularization, performance optimization, and Google Play features.
The article explains why solid software architecture matters, introduces Robert C. Martin’s Clean Architecture and its framework‑, UI‑, database‑, and service‑independent principles, compares it with Hexagonal and DDD layered styles, details strategic and tactical phases for front‑end MVVM projects, provides layered code samples, and weighs its benefits against the initial overhead, urging teams to choose the approach that fits their project’s complexity and lifespan.
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.
This article explains why code architecture matters, compares Clean, Hexagonal, Onion and COLA patterns, describes their layered structures and separation‑of‑concerns principles, and provides a practical Go project layout with concrete code examples to illustrate how each layer interacts.
This article explains the COLA (Clean Object‑Oriented and Layered Architecture) framework, its layered structure, component breakdown, and practical implementation details with SpringBoot, including code examples, module organization, and design principles for building maintainable backend systems.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution, bounded contexts, the four DDD boundaries, and common architectural styles such as clean layered, hexagonal, and onion architectures.
This article explains how to apply Domain‑Driven Design (DDD) to a new project, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models.
This article explains how to start a new project using Domain‑Driven Design (DDD), covering service terminology, architectural evolution from monolith to microservices, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their practical benefits for backend systems.
This article explains how to apply Domain-Driven Design (DDD) from project inception, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models to achieve modular, maintainable systems.
This article explains how the author applied Domain‑Driven Design to build a microservice for an internal trading center, reviewing DDD strategic and tactical design, various architecture layer theories, a customized layered architecture, Maven module structure, and detailed responsibilities of each layer while sharing practical tips and challenges.
The article explains why layered architectures such as Clean, Onion, and Hexagonal are essential for reducing coupling and improving maintainability, introduces the COLA (Clean Object‑oriented and Layered Architecture) derived from them, and presents a concrete Go project scaffold with clearly defined Domain, Application, Infrastructure, and Adapter layers and recommended directory layout.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, the evolution from SaaS to IaaS, bounded‑context concepts and division rules, the four DDD boundaries, and how clean, hexagonal, and onion architectures realize these principles for scalable backend systems.
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.
The team combats outdated documentation and costly front‑end maintenance by treating unit tests for the use‑case layer as living documentation, using BDD‑style Given‑When‑Then tests that assert only observable behavior, which improves code readability, eases onboarding, and provides a reliable safety net for future changes.