Tagged articles
hexagonal-architecture
81 articles · Page 1 of 1

webdreamJul 18, 2026 · Backend Development
The article explains why solid architecture matters for Java projects, outlines seven mainstream architectural patterns—including layered, DDD, hexagonal, clean, CQRS, event‑driven, and microkernel—and provides a decision guide to help teams choose the most suitable approach based on complexity, experience, performance, and evolution needs.
CQRSJavaLayered Architecture
0 likes · 11 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 the Development View— the "code floor plan" in the 4+1 view model—by detailing how code is organized, directory structures, module dependencies, build and packaging configurations, common architectural patterns, design principles, and practical solutions to typical problems such as circular dependencies and package chaos.
Design PrinciplesLayered ArchitectureOnion Architecture
0 likes · 9 min read

The article examines how software architecture has progressed from the traditional DDD four‑layer structure through Hexagonal, Onion, and Clean architectures, explaining essential versus accidental complexity, layering principles, dependency inversion, and how each pattern refines modularity, testability, and dependency direction.
CQRSDDDLayered Architecture
0 likes · 12 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

Hexagonal Architecture’s true essence lies in its ports‑and‑adapters structure and technology‑agnostic core, not the six‑sided diagram, and the article explains this concept, its driving vs. driven sides, its relation to DIP, common misconceptions, and how it aligns with Clean and Onion architectures.
Dependency Inversion PrincipleOnion Architectureclean architecture
0 likes · 11 min read

The article explains that Clean Architecture’s true essence lies in the immutable Dependency Rule—dependencies must always point inward—while the four‑layer diagram is merely a flexible skeleton, and it clarifies common misconceptions, ties to SOLID, and shows how to apply the rule across Hexagonal and Onion variants.
Dependency RuleLayered ArchitectureOnion Architecture
0 likes · 12 min read

Hexagonal (Ports‑and‑Adapters) architecture, introduced by Alistair Cockburn in 2005, separates core business logic from external concerns through defined ports and interchangeable adapters, enhancing testability, maintainability, and technology‑agnostic flexibility, and is especially suited for complex domains requiring multiple interfaces such as REST and message queues.
Javahexagonal-architecturemaintainability
0 likes · 5 min read

The article reveals that most so‑called “self‑built” enterprise systems are merely assemblies of third‑party components—databases, cloud services, SaaS tools—and explains how license changes, API disruptions, and vendor lock‑in can erode a CTO’s control, then outlines practical steps for regaining architectural decision‑making authority by 2026.
AI GatewayCTOIaC
0 likes · 13 min read

The author recounts three years of applying Domain‑Driven Design to a microservice ecosystem, sharing concrete pitfalls, code‑first modeling from database tables, and a structured 24‑article series that guides developers to refactor existing Spring Boot + MyBatis Plus projects without rewriting the framework.
Bounded ContextCQRSMyBatis Plus
0 likes · 8 min read

This article explains how hexagonal architecture serves as a solid foundation for gradually introducing domain‑driven design, outlines the stages of evolution, highlights common pitfalls, and provides concrete code examples to help teams decide when to move beyond hexagonal alone.
DDDclean architecturedomain-driven design
0 likes · 8 min read

Shopify handles over 30 TB of data each minute and millions of requests by using a disciplined, modular monolithic architecture enhanced with hexagonal design, Pods isolation, real‑time data pipelines, and a heavily sharded MySQL deployment, demonstrating that simplicity can scale to internet‑level traffic without microservices.
databaseshexagonal-architecturemonolith
0 likes · 10 min read

This article explains the fundamentals of hexagonal (ports‑and‑adapters) architecture, presents three ways to implement it in Spring Boot—including a classic version, a DDD‑enhanced version, and a simplified variant—while analyzing their advantages, disadvantages, and suitable scenarios.
domain-driven designhexagonal-architecturesoftware architecture
0 likes · 35 min read

This article explores how Domain‑Driven Design and hexagonal (clean) architecture were applied to Huolala’s user CRM, detailing the tactical design patterns, module breakdown, code examples, and the step‑by‑step migration that improved scalability, maintainability, and development efficiency.
DDDJavadomain-driven design
0 likes · 43 min read

This article explores the practical application of Domain‑Driven Design and hexagonal architecture in a real‑world CRM system, detailing strategic and tactical design, module division, code examples, and a step‑by‑step migration from a traditional layered architecture to a more flexible, maintainable backend solution.
DDDbackend developmentdomain-driven design
0 likes · 49 min read


21CTOMay 6, 2024 · Backend Development
This article narrates how McDonald’s food‑delivery platform uses a hexagonal, event‑driven, micro‑service architecture with serverless functions, message brokers, and schema registries to achieve massive scalability, low latency, and reliable order processing for millions of daily users.
backend developmentevent-driven architecturehexagonal-architecture
0 likes · 8 min read

The article explains how business complexity and maintenance pain points can be mitigated by adopting Domain‑Driven Design, strategic and tactical patterns, hexagonal architecture, and a well‑structured microservice framework—illustrated with Go code examples and practical migration steps for large‑scale systems.
BackendDDDGo
0 likes · 21 min read

This article explores the fundamentals of Domain‑Driven Design, its challenges, practical steps for applying DDD concepts such as value objects, repository patterns, hexagonal architecture, and domain layer design, and shares concrete refactoring experiences to build more maintainable, extensible, and testable systems.
DDDdomain-driven designhexagonal-architecture
0 likes · 20 min read

This article explains how to apply Domain-Driven Design (DDD) to a new project, covering terminology, architecture evolution from IAAS/PAAS/SAAS, bounded‑context boundaries, the four DDD layers, clean layered, hexagonal and onion architectures, and practical guidance for backend development.
Bounded ContextDDDLayered Architecture
0 likes · 9 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 ArchitectureCQRSModule Design
0 likes · 22 min read

This article explores Domain‑Driven Design fundamentals, illustrating how to expose hidden concepts, adopt hexagonal architecture, and implement repository patterns to achieve high scalability, maintainability, and testability in complex software systems, while addressing common pitfalls like the anemic model.
DDDanemic modeldomain-driven design
0 likes · 23 min read

The article details Bilibili’s migration of its legacy PHP live‑broadcast service to Go microservices using Domain‑Driven Design and Hexagonal architecture, describing event‑storming, six‑layer tactical design, TDD, traffic‑mirroring migration, and resulting higher reliability, lower latency, and improved maintainability.
domain-driven designhexagonal-architecturemicroservices
0 likes · 43 min read

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.
DDDLayered Architectureclean architecture
0 likes · 21 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

This article walks through the historical evolution of backend architecture—from early N‑layered designs, through DDD, Hexagonal, Onion, and finally Clean Architecture—explaining why each style emerged, how they differ, and what practical rules developers can follow to manage complexity and dependencies.
DDDN‑layeredOnion Architecture
0 likes · 17 min read

This article explains clean architecture concepts—domain, use case, and application layers—and demonstrates how to apply them in a frontend React/TypeScript project, covering design principles, layer responsibilities, dependency rules, advantages, costs, and concrete code examples for a cookie‑shop example.
clean architecturedomain-driven designfrontend
0 likes · 40 min read

The article explains how Bilibili’s senior engineer uses Domain‑Driven Design combined with hexagonal architecture to merge separate VOD and live‑stream Danmaku services into a unified platform, detailing sub‑domain decomposition, six‑sided ports, rich models, mapping logic, and the trade‑offs of improved modularity, maintainability, and reduced duplication versus added design and refactoring effort.
DDDGoKratos
0 likes · 21 min read

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.
DDDOnion Architecturehexagonal-architecture
0 likes · 9 min read

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.
Bounded Contextclean architecturedomain-driven design
0 likes · 9 min read

This article explains how to start a new project using Domain‑Driven Design, covering terminology, architectural evolution across SaaS, PaaS, IaaS, bounded‑context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and concludes with practical guidance.
Bounded ContextDDDOnion Architecture
0 likes · 8 min read

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.
CQRSDDDclean architecture
0 likes · 16 min read

This article explains that an engineer's primary responsibility is to solve business problems, explores the challenges across a product's lifecycle, outlines software complexity dimensions, and demonstrates how Domain‑Driven Design, strategic and tactical patterns, and modern architectural styles like Hexagonal and CQRS can effectively manage that complexity.
CQRScomplexity managementhexagonal-architecture
0 likes · 31 min read

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.
code scaffoldinghexagonal-architecturesoftware architecture
0 likes · 20 min read

This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.
CQRSDDDJava
0 likes · 22 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

This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

This article explains how to start a new project using Domain‑Driven Design, covering terminology, architecture evolution from monolith to microservices, bounded‑context definition, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical guidelines for effective system design.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

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.
BackendBounded ContextOnion Architecture
0 likes · 9 min read

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.
Onion Architecturebackend developmentclean architecture
0 likes · 10 min read

This article explains how to apply Domain-Driven Design (DDD) to a new project, detailing the evolution from monolithic to microservice architectures, the concepts of IaaS, PaaS, SaaS, bounded contexts, the four DDD boundaries, and clean, hexagonal, and onion architectural patterns.
Bounded ContextDDDOnion Architecture
0 likes · 9 min read

This article introduces a modular backend service architecture based on Domain-Driven Design, explaining project structure, module composition, hexagonal architecture, and practical code examples using Spring Cloud, illustrating how to achieve flexible, maintainable services through domain models, adapters, and proper boundary definitions.
Backend ArchitectureDDDSpring Cloud
0 likes · 14 min read

The article explains how applying clean separation, layered architecture, and the hexagonal ports‑and‑adapters pattern helps manage complexity, keep core domain logic isolated, and make software easier to change, test, and maintain.
Clean Codehexagonal-architecturelayered design
0 likes · 8 min read

This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architectural classifications, and introduces classic patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design, extension, and specification guidelines.
COLA frameworkCQRSOnion Architecture
0 likes · 16 min read


ITPUBJul 29, 2022 · Fundamentals
This article explores the concept of software architecture, its relationship to business, key design principles such as SOLID and Ockham's razor, various architectural styles like layered, hexagonal, and onion, and illustrates how a real‑world navigation engine team applied domain‑driven design to restructure their codebase.
Design PrinciplesLayered ArchitectureSOLID
0 likes · 24 min read

This article explains how to start a new project using Domain‑Driven Design, describes the evolution from SaaS to PaaS to IaaS, introduces bounded contexts, the four‑layer DDD boundaries, and compares clean, hexagonal, and onion architectures for building maintainable backend systems.
BackendDDDOnion Architecture
0 likes · 9 min read

Applying Domain‑Driven Design to Youzan’s Credit Core System involved consulting experts, mapping loan processes, using four‑color modeling to define documents, participants, roles and data, establishing bounded contexts, designing sub‑domains with use‑case diagrams, and adopting a layered (often hexagonal) architecture to ensure maintainable, scalable microservices.
DDDLoan SystemYouzan Credit Core System
0 likes · 6 min read

This article explains the fundamentals of software architecture, why it is needed, the responsibilities of architects, various architectural classifications, and introduces classic and modern application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.
COLACQRSDesign Patterns
0 likes · 14 min read

This article explains the fundamentals of software architecture, why architecture is needed, the responsibilities of architects, various architecture categories, common styles such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension points and standards.
COLA frameworkCQRSDesign Patterns
0 likes · 12 min read

This article explains the concept of software architecture, its necessity, the role of architects, various architectural categories, typical patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA open‑source application architecture with its layered design, extension mechanisms, and specification guidelines.
COLACQRSLayered Architecture
0 likes · 14 min read

This article explains the definition and necessity of software architecture, outlines various architectural categories such as business, application, distributed, data, physical, and operations architectures, describes layered, CQRS, hexagonal and onion models, and introduces the COLA framework with its design principles and extension mechanisms.
COLACQRSDesign Patterns
0 likes · 12 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 reviews the core concepts of Domain‑Driven Design and layered architecture, compares four‑layer, five‑layer (DCI), six‑layer, and hexagonal (ports‑and‑adapters) patterns, and provides practical guidance for selecting the most suitable architecture for microservice projects.
DCIDDDLayered Architecture
0 likes · 21 min read

This article presents a practical implementation of Domain-Driven Design (DDD) and hexagonal architecture in Ctrip's international train ticket booking platform, detailing strategic and tactical design, addressing controller bloat, over‑coupling, and anemic models, and showcasing Java code examples for aggregates, repositories, and factories.
DDDJavadomain modeling
0 likes · 17 min read

This article explains the meaning of architecture, why it is essential for any system, the responsibilities of architects, various software architecture classifications, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered, extension, and standard design principles.
COLA frameworkCQRSLayered Architecture
0 likes · 15 min read

This article explains the concept of software architecture, why it is needed, the responsibilities of architects, various architectural styles such as layered, hexagonal, onion, and introduces the COLA application architecture with its design principles, extension points, and CQRS separation.
COLACQRSDesign Patterns
0 likes · 16 min read

This article explains the definition of architecture, why it matters, the role of architects, various software architecture classifications, layered designs, and key patterns such as CQRS, hexagonal, onion, and the COLA framework, providing a comprehensive guide for building maintainable systems.
COLA frameworkCQRSOnion Architecture
0 likes · 15 min read

This article explains the definition of software architecture, why it is needed, the responsibilities of architects, various architectural styles such as layered, CQRS, hexagonal, onion, and the COLA framework, providing a comprehensive overview for developers and system designers.
CQRSDesign PatternsLayered Architecture
0 likes · 15 min read

This article explains what software architecture is, why it is needed, the responsibilities of architects, various classification types such as business, application, distributed, data, physical and operations, and introduces typical architectural styles like layered, CQRS, hexagonal, onion, and the open‑source COLA framework.
COLACQRSDesign Patterns
0 likes · 13 min read

This article explains what software architecture is, why it is essential, the responsibilities of architects, various architecture classifications, common patterns such as layered, CQRS, hexagonal and onion designs, and introduces the open‑source COLA framework with its layered structure, extension mechanisms, and normative guidelines.
COLA frameworkDesign PatternsOnion Architecture
0 likes · 13 min read

Domain-Driven Design (DDD) offers a systematic approach to separate business complexity from technical concerns, using ubiquitous language, bounded contexts, layered and hexagonal architectures, CQRS, and strategic and tactical patterns, enabling teams to build flexible, scalable systems that quickly adapt to evolving requirements.
Bounded ContextCQRSdomain-driven design
0 likes · 41 min read

This article explains the fundamental notion of software architecture, why it is needed, the responsibilities of architects, various architecture classifications, typical application architectures such as layered, CQRS, hexagonal and onion models, and introduces Alibaba's open‑source COLA framework with its layered design, extension mechanisms and standards.
COLACQRSOnion Architecture
0 likes · 13 min read

This article explains what software architecture is, why it is needed, the responsibilities of architects, various architecture classifications, common architectural styles such as layered, CQRS, hexagonal and onion, and introduces the COLA application architecture with its layered design, extension mechanisms and normative guidelines.
COLACQRSDesign Patterns
0 likes · 12 min read

This article reviews Domain‑Driven Design and layered architecture fundamentals, then explains three classic DDD layered patterns—four‑layer, five‑layer, and hexagonal architectures—detailing their layers, responsibilities, advantages, drawbacks, and practical adaptations for microservice development.
DDDLayered Architecturehexagonal-architecture
0 likes · 21 min read

This article explains how Domain-Driven Design (DDD) addresses software complexity in a reward system, detailing its background, business value, strategic and tactical design, hexagonal architecture, module decomposition, and practical advantages such as reduced development cost, lower risk, and improved maintainability.
domain-driven designhexagonal-architecture
0 likes · 14 min read

This article explains the concept of Explicit Architecture, describing how core modules, tools, ports, adapters, and component organization combine hexagonal, onion, clean, and CQRS patterns to achieve a loosely‑coupled, highly‑cohesive software system suitable for both monolithic and micro‑service applications.
CQRSOnion Architectureclean architecture
0 likes · 22 min read

Applying Domain‑Driven Design and Hexagonal architecture to a reward service clarified domain boundaries, cut integration, middleware and onboarding costs by up to 30 %, streamlined unit‑test creation, and enabled a layered, framework‑independent codebase with entities, value objects, services, events, aggregates and factories that improve maintainability, scalability and testability.
DDDStrategic Designbackend development
0 likes · 15 min read


ITPUBDec 30, 2020 · Fundamentals
This article defines software architecture, explains why it is essential, outlines the architect's responsibilities, categorizes various architecture types, and details common patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.
COLA frameworkCQRSDesign Patterns
0 likes · 15 min read

This article explains the purpose and benefits of layered software architecture, compares traditional three‑tier designs with hexagonal architecture, discusses system splitting and micro‑service considerations, and provides C# code examples illustrating domain, application, and adapter layers.
C++domain-driven designhexagonal-architecture
0 likes · 11 min read

This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architecture classifications, and introduces practical application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework, highlighting how separating business logic from technical details improves maintainability and scalability.
COLA frameworkCQRSOnion Architecture
0 likes · 16 min read

This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.
Backend ArchitectureCQRSdomain modeling
0 likes · 40 min read

This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension mechanisms, and specification rules.
COLACQRSDesign Patterns
0 likes · 14 min read

This article explains the concept of software architecture, why it is needed, the responsibilities of architects, various architectural classifications and patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA framework with its layered design, extension mechanisms, and specification guidelines.
COLACQRSOnion Architecture
0 likes · 12 min read

This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, typical architectural patterns such as layered, CQRS, hexagonal and onion architectures, and introduces Alibaba's open‑source COLA framework with its layered design, extension and specification concepts.
COLA frameworkCQRSOnion Architecture
0 likes · 14 min read

This article explains the concepts of Domain‑Driven Design, why it has gained traction in China’s internet industry, and how Alibaba Entertainment applies strategic and tactical DDD practices—such as model annotation, health‑check, and hexagonal architecture—to improve scalability, readability, and maintainability of its micro‑service systems.
backend developmentdomain-driven designhexagonal-architecture
0 likes · 13 min read

The article explains DDD’s core building blocks—entities identified by persistent IDs, immutable value objects, and aggregates that group related objects under a single root—using a car‑model case study to show how roots enforce invariants, how factories, repositories and lazy‑loaded references fit within a hexagonal architecture, and why these practices improve modular, maintainable software.
EntitiesJavaValue Objects
0 likes · 31 min read

This article explores how Domain-Driven Design (DDD) can address the growing complexity of business and technical requirements in large-scale systems, detailing its strategic and tactical processes, layered and hexagonal architectures, and integration with microservices to achieve flexible, maintainable, and scalable software solutions.
Strategic Designdomain-driven designhexagonal-architecture
0 likes · 42 min read

Domain‑Driven Design, a mindset rather than a rigid methodology, clarifies business complexity through a central domain model, layered and hexagonal architectures, bounded contexts, and repository patterns—dispelling myths that it suits only large projects or adds excessive boiler‑plate, and showing practical Java implementation.
Javaclean architecturedomain-driven design
0 likes · 20 min read

This article explains the core concepts of Domain‑Driven Design, including model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks such as entities, value objects, aggregates, repositories, factories, and services, to help developers build business‑centric enterprise applications.
DDDdomain-driven designhexagonal-architecture
0 likes · 22 min read

This article explains what software architecture is, why it is essential for any system, the responsibilities of architects, various architecture classifications, and introduces the COLA open‑source framework that combines layered, hexagonal, and onion architectures with CQRS and extensibility to separate business logic from technical details.
COLA frameworkCQRSOnion Architecture
0 likes · 14 min read

Domain-Driven Design (DDD) focuses on modeling core business complexity by building a ubiquitous language, bounded contexts, and layered architectures, and the article explains key DDD patterns such as model‑driven design, aggregates, repositories, factories, services, and hexagonal architecture, illustrated with diagrams and Java code examples.
aggregatesdomain-driven designenterprise applications
0 likes · 35 min read

This article presents a practical IoT layered architecture model, contrasting the classic three‑tier view with a four‑tier structure (hardware, coordination, service, and application layers), explains the role of each layer, and advocates using hexagonal architecture for the service layer in the Lan platform.
IoTService Layerarchitecture
0 likes · 4 min read
