# clean-architecture

Published articles for clean-architecture.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Make scalable routing system for your Flutter Apps

DevFeed: [Make scalable routing system for your Flutter Apps](<https://devfeed.tech/articles/make-scalable-routing-system-for-your-flutter-apps-23053.md>)

Original publisher: [Read original article](<https://medium.com/flutter-community/make-scalable-routing-system-for-your-flutter-apps-73510bf3d602?source=rss----86fb29d7cc6a---4>)

Author: Kanan Yusubov

Published: 2026-07-29T15:25:43Z

Content type: tutorial

Language: en

Sources: [Flutter Community - Medium](<https://devfeed.tech/sources/flutter-community-medium.md>)

Topics: [Flutter](<https://devfeed.tech/topics/flutter.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [navigation](<https://devfeed.tech/topics/navigation.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>), [Usability](<https://devfeed.tech/topics/usability.md>)

Tags: [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [flutter](<https://devfeed.tech/tags/flutter.md>), [go-router](<https://devfeed.tech/tags/go-router.md>), [modular-router](<https://devfeed.tech/tags/modular-router.md>), [modules](<https://devfeed.tech/tags/modules.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [router](<https://devfeed.tech/tags/router.md>), [routing](<https://devfeed.tech/tags/routing.md>), [routing-system](<https://devfeed.tech/tags/routing-system.md>), [usability](<https://devfeed.tech/tags/usability.md>)

### AI overview

This tutorial describes a scalable, decoupled routing system for Flutter apps. It explains a wrapper built on go_router that adds typed route arguments, native and path parameters, cross-module modularization, nested routes, presentation modes, and type-safe route guards.

### Source excerpt

Recently, I've been working on migrating our app's routing system. We previously used auto_route, but eventually realized its tightly coupled nature made it incredibly difficult to scale across independent modules. Furthermore, its heavy reliance on code generation became a bottleneck for our workflow. To resolve this, we decided to architect a clean, scalable, and highly decoupled routing system. Our new solution is a powerful wrapper built on top of go_router. It abstracts away the raw string navigation and supercharges the router with custom features to maximize usability and type safety. In this blog post, I will walk you through the core benefits of this new routing system, covering the following key topics: Unified Routing Protocol (AppRouteInfo) Strictly Typed Route Arguments Native & Path Parameters Support Cross-Module Modularization (AppModuleRouter) Hierarchical Back stack & Sub-Routes (Nested Route Definitions, Decoupled Cross-Module Navigation) Dynamic Presentation Modes (e.g., Native, ModalSheet, NoTransition) Guard Interceptor Mechanism (Type-Safe Redirects, Global Interceptors) Note: This blog will show the general usage and problems it solved. For more detailed code, you can check the following link: https://github.com/thisisyusub/scalable-routing-system-demoArchitectural Structure of Routing System Here is how the demo application is structured to achieve a fully decoupled, scalable routing system: scalable_routing_system_demo (main app): The entry point of the application responsible for wiring up all services, dependency injection, and global route configurations. app_routes: Houses all route definitions, parameters, routing protocols, and models to ensure fully type-safe navigation. This is decoupled from the core routing package to separate app-specific business needs from generic routing mechanics. routing_system (core router): A generic, domain-agnostic router package that has zero knowledge of the app's specific routes. It exclusively provid

## When Clean Architecture Overhead Is Justified in Larger Projects

DevFeed: [When Clean Architecture Overhead Is Justified in Larger Projects](<https://devfeed.tech/articles/clean-architecture-is-overhead-26177.md>)

Original publisher: [Read original article](<https://journal.optivem.com/p/clean-architecture-is-overhead>)

Author: Valentina Jemuović

Published: 2026-07-28T06:01:50Z

Content type: opinion

Language: en

Sources: [Optivem Journal](<https://devfeed.tech/sources/optivem-journal.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Databases](<https://devfeed.tech/topics/databases.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [developer](<https://devfeed.tech/tags/developer.md>), [developers](<https://devfeed.tech/tags/developers.md>), [orm](<https://devfeed.tech/tags/orm.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The article argues that Clean Architecture adds real overhead through extra interfaces, abstractions, indirection, and separate domain and ORM entities. It contends that this trade-off becomes worthwhile as midsize and enterprise projects grow, because decoupling business logic from infrastructure and database structures makes change easier.

### Source excerpt

Stop counting lines of code

## Clean Architecture Mistake: ORM ≠ Domain

DevFeed: [Clean Architecture Mistake: ORM ≠ Domain](<https://devfeed.tech/articles/clean-architecture-mistake-orm-domain-26178.md>)

Original publisher: [Read original article](<https://journal.optivem.com/p/clean-architecture-mistake-orm-domain>)

Author: Valentina Jemuović

Published: 2026-07-09T06:02:30Z

Content type: opinion

Language: en

Sources: [Optivem Journal](<https://devfeed.tech/sources/optivem-journal.md>)

Topics: [Object-relational mapping](<https://devfeed.tech/topics/orm.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [orm](<https://devfeed.tech/tags/orm.md>)

### AI overview

The article warns that ORM entities should not be confused with domain entities.

### Source excerpt

Do NOT confuse ORM entities with domain entities.

## Teaching the Agent Our Craft: Structured Agentic Development on a Real Codebase

DevFeed: [Teaching the Agent Our Craft: Structured Agentic Development on a Real Codebase](<https://devfeed.tech/articles/teaching-the-agent-our-craft-structured-agentic-development-on-a-real-codebase-33280.md>)

Original publisher: [Read original article](<https://8thlight.com/insights/teaching-the-agent-our-craft-structured-agentic-development-on-a-real-codebase>)

Author: Alex Haldeman

Published: 2026-07-06T16:00:00Z

Content type: article

Language: en

Sources: [8th Light](<https://devfeed.tech/sources/8th-light.md>), [8th Light Insights](<https://devfeed.tech/sources/8th-light-insights.md>)

Topics: [Agentic development](<https://devfeed.tech/topics/agentic-development.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Development](<https://devfeed.tech/topics/development.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [ai-and-emerging-tech](<https://devfeed.tech/tags/ai-and-emerging-tech.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [structured](<https://devfeed.tech/tags/structured.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

8th Light describes a structured agentic development workflow built around Claude Code. The approach adapts Research-Plan-Implement by separating research, planning, and implementation, adding review cycles and involving product managers and designers at each transition. It also applies test-driven development, clean architecture, and explicit project conventions to address common agent failure modes.

### Source excerpt

The Mission We recently partnered with a startup that had developed a clinically proven approach to alleviating neuroplastic chronic pain. Their program worked: a coach-led model that helped patients ease chronic pain at a lower cost than conventional treatment. The problem was reach. The in-person model could not scale to the demand they were seeing, and there were not enough coaches to close the gap. We were brought in to build a digital platform that could deliver the program to every patient who needed it. Our Development Philosophy and Inspiration At 8th Light, we approach agentic development the same way we approach any software engagement: with discipline around test-driven development, clean architecture, and code that is built to embrace change. But agentic development comes with its own failure modes. An agent produces code that covers the happy path and misses critical behaviors. A context window fills with stale reasoning from earlier attempts, and the agent starts working against itself. Without explicit conventions, the output works but looks like nobody on the team wrote it. Tyler Burleigh's Research-Plan-Implement gave us a useful frame for thinking about this. His core observation: the bottleneck is not code generation, it is ensuring the model understands what to build before it starts building. RPI addresses that by separating research, planning, and implementation into distinct phases, each with a review cycle before the next begins. We adapted that structure into our Claude Code workflow, with the additional goal of keeping product managers and designers genuinely in the loop at each transition, not just developers. What follows is a description of the harness we built from a Claude Code-specific perspective. The HarnessStructure Before walking through the pieces, it helps to see how they fit together. Everything that teaches the agent our craft lives in a handful of files at the project root and inside a single .claude/ directory. None of it is

## Let Koin Shape your Application Architecture

DevFeed: [Let Koin Shape your Application Architecture](<https://devfeed.tech/articles/let-koin-shape-your-application-architecture-22974.md>)

Original publisher: [Read original article](<https://blog.insert-koin.io/let-koin-shape-your-application-architecture-9cd60b1e02b0?source=rss----925561f2ecdf---4>)

Author: Gabriel Bronzatti Moro

Published: 2026-07-06T12:01:01Z

Content type: tutorial

Language: en

Sources: [Koin developers - Medium](<https://devfeed.tech/sources/koin-developers-medium.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Software](<https://devfeed.tech/topics/software.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [developer](<https://devfeed.tech/tags/developer.md>), [koin](<https://devfeed.tech/tags/koin.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [software](<https://devfeed.tech/tags/software.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-design](<https://devfeed.tech/tags/software-design.md>)

### AI overview

This tutorial explains how Koin can support application architecture based on Clean Architecture and software design practices. It describes using Koin to create and manage object instances, including singleton and factory definitions, with Ktor's HttpClient as an example.

### Source excerpt

Hey, friends! 👋 Today we're going to explore application architecture and how Koin can help us build scalable, maintainable applications by applying the principles of Clean Architecture and other software design best practices. Application architecture is a fundamental skill for every software engineer. A well-designed architecture makes applications easier to understand, test, extend, and maintain as they grow over time. A collection of LEGO towers in various stages of construction -- Unsplash by richard_heFoundation When we think about software architecture, we often picture layered diagrams -- data, domain, and presentation -- along with classes such as use cases, handlers, repositories, and helpers. But how do all these components work together? How do we establish a reliable communication protocol between them? Architecture is more than just organizing classes into packages. It's about defining how objects communicate and collaborate working toward a common goal. With that in mind, let's begin our journey with a simple principle: Every object instance should be created by Koin. My only responsibility as a developer is to describe how each object should be instantiated, while Koin takes care of the creation process.SingletonSingleton Café generated by ChatGPT Koin makes it easy to define singletons, whether you're using the @Single annotation or the single { ... } DSL. By declaring a singleton, you're telling Koin to create and manage a single instance of that object for the lifetime of the application. In the example below, we define an HttpClient as a singleton: @Module class NetworkModule { @Single fun provideHttpClient(): HttpClient { return HttpClientBuilder.build( baseUrl = BuildKonfig.HOST, ) } ... } HttpClient is a class provided by Ktor, and it should typically be instantiated only once. By declaring it as a singleton, Koin ensures that the same HttpClient instance is shared throughout the application. The Singleton pattern is commonly used for objects tha

## What Should Repositories Return in Domain-Driven Design?

DevFeed: [What Should Repositories Return in Domain-Driven Design?](<https://devfeed.tech/articles/what-should-repositories-return-in-domain-driven-design-39768.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/what-should-repositories-return-in-domain-driven-design>)

Author: Furkan Kolcu

Published: 2025-09-09T16:41:47Z

Content type: article

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [Repositories](<https://devfeed.tech/topics/repositories.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>)

Tags: [aggregates](<https://devfeed.tech/tags/aggregates.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [domain-driven-design](<https://devfeed.tech/tags/domain-driven-design.md>), [domain-driven-design-ddd](<https://devfeed.tech/tags/domain-driven-design-ddd.md>), [examples](<https://devfeed.tech/tags/examples.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [practical](<https://devfeed.tech/tags/practical.md>), [repositories](<https://devfeed.tech/tags/repositories.md>), [repository-pattern](<https://devfeed.tech/tags/repository-pattern.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This article examines what repositories should return in Domain-Driven Design. It compares aggregates, DTOs or arrays, and primitives or special results, concluding that repositories should return aggregates when domain behavior is needed and primitives when they express valid domain-level answers.

### Source excerpt

Repositories are a core part of Domain-Driven Design, but what they should return is often debated. Should it be aggregates, DTOs, or simple values? In this post, I share practical guidelines, examples, and tradeoffs to help clarify how to keep repositories focused on serving the domain.

## Building Your First Kotlin Multiplatform App: From Setup to iOS App Store with Compose Multiplatform (2025 Guide)

DevFeed: [Building Your First Kotlin Multiplatform App: From Setup to iOS App Store with Compose Multiplatform (2025 Guide)](<https://devfeed.tech/articles/building-your-first-kotlin-multiplatform-app-from-setup-to-ios-app-store-with-compose-multiplatform-2025-guide-39342.md>)

Original publisher: [Read original article](<https://kt.academy/article/kmp-to-compose-guide>)

Published: 2025-07-28T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Databases](<https://devfeed.tech/topics/databases.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [android](<https://devfeed.tech/tags/android.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [app-store](<https://devfeed.tech/tags/app-store.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [build](<https://devfeed.tech/tags/build.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [development](<https://devfeed.tech/tags/development.md>), [guide](<https://devfeed.tech/tags/guide.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ios-development](<https://devfeed.tech/tags/ios-development.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [setup](<https://devfeed.tech/tags/setup.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

A tutorial for building Kyklos, a Kotlin Multiplatform subscription-tracking app with shared Compose Multiplatform UI and business logic for Android and iOS. It covers project setup, Clean Architecture, SQLDelight database integration, Material Design 3, testing, and deployment.

### Source excerpt

A comprehensive guide to building your first Kotlin Multiplatform app using Compose Multiplatform, covering setup, development, and deployment

## Building a Note-Taking App in Compose

DevFeed: [Building a Note-Taking App in Compose](<https://devfeed.tech/articles/building-a-note-taking-app-in-compose-20024.md>)

Original publisher: [Read original article](<https://technology.doximity.com/articles/building-a-note-taking-app-in-compose>)

Author: Doximity

Published: 2023-07-05T19:47:00Z

Content type: tutorial

Language: en

Sources: [Doximity](<https://devfeed.tech/sources/doximity.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [App](<https://devfeed.tech/topics/app.md>), [Code](<https://devfeed.tech/topics/code.md>), [Template](<https://devfeed.tech/topics/template.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [class](<https://devfeed.tech/tags/class.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [collect](<https://devfeed.tech/tags/collect.md>), [compose](<https://devfeed.tech/tags/compose.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [di](<https://devfeed.tech/tags/di.md>), [extension-function](<https://devfeed.tech/tags/extension-function.md>), [flow](<https://devfeed.tech/tags/flow.md>), [icons](<https://devfeed.tech/tags/icons.md>), [implement](<https://devfeed.tech/tags/implement.md>), [koin](<https://devfeed.tech/tags/koin.md>), [list](<https://devfeed.tech/tags/list.md>), [state](<https://devfeed.tech/tags/state.md>), [state-management](<https://devfeed.tech/tags/state-management.md>), [view](<https://devfeed.tech/tags/view.md>)

### AI overview

A case study showing how to build a note-taking app with Jetpack Compose. It models note state, renders the notes UI, collects note data through a presenter and Clean Architecture use cases, and plans events for adding, editing, checking, and deleting notes.

### Source excerpt

In this case study, we will build a note-taking app that lets the user add, edit and delete notes. It uses Compose for both the view and presentation layers! Note: This is a follow up to Part 1: Simplifying State Management with Compose and assumes the reader is already familiar with Jetpack Compose. The Template I find it useful to start with the model that represents the state of the screen we're building. It will have a list of notes, with each note containing properties for the text and checkbox: data class NotesUiModel(val notes: List<Note>) : UiModel { data class Note(val text: String, val isChecked: Boolean) : UiModel } It'll be the job of the presenter to produce this model. Initially, let's implement a stub to return an empty list of notes (we'll ignore parameters for now): class NotesListPresenter : Presenter<NotesUiModel, Unit> { @Composable override fun present(params: Unit): NotesUiModel { return NotesUiModel(notes = emptyList()) } } Then we can build our view to render the model that's returned by the presenter: @Composable fun NotesScreen() { val presenter: NotesListPresenter = koinInject() // we use koin for DI val uiModel = presenter.present(Unit) Column { TopAppBar(title = { Text("Notes") }) Notes(uiModel) } } } The View The views themselves are pretty self-explanatory if you're already familiar with building UIs in Compose. For the notes, we'll take in a NotesUiModel argument and create a LazyColumn with the notes property. A FAB button is used for adding new notes, although we'll skip the triggering of events and return to this part in a little bit: @Composable private fun Notes(uiModel: NotesUiModel) { Box { LazyColumn { items(uiModel.notes) { note -> Note(note) } } FloatingActionButton(onClick = { /* TODO */ }) { Icon(imageVector = Icons.Rounded.Add) } } } Then we can render each note with a checkbox, text field and delete button: @Composable private fun Note(uiModel: Note) { Row { Checkbox( checked = uiModel.isChecked, onCheckedChange = { /* T

## Simplifying State Management with Compose

DevFeed: [Simplifying State Management with Compose](<https://devfeed.tech/articles/simplifying-state-management-with-compose-20043.md>)

Original publisher: [Read original article](<https://technology.doximity.com/articles/simplifying-state-management-with-compose>)

Author: Doximity

Published: 2023-07-05T19:45:00Z

Content type: tutorial

Language: en

Sources: [Doximity](<https://devfeed.tech/sources/doximity.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Android](<https://devfeed.tech/topics/android.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Development](<https://devfeed.tech/topics/development.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-ui](<https://devfeed.tech/tags/compose-ui.md>), [interoperability](<https://devfeed.tech/tags/interoperability.md>), [state](<https://devfeed.tech/tags/state.md>), [state-management](<https://devfeed.tech/tags/state-management.md>), [xml](<https://devfeed.tech/tags/xml.md>)

### AI overview

This tutorial explains how Doximity's Android team experimented with using the Compose Runtime instead of ViewModels to manage screen state in the refreshed Amion physician scheduling tool. It describes the related presentation-layer and clean-architecture patterns, including interoperability with existing XML and Compose UI, and introduces foundations for a follow-up note-taking app.

### Source excerpt

The recent release of Doximity's refreshed physician scheduling tool Amion involved a significant overhaul of the user interface (UI) layer using Jetpack Compose. As part of the development process, we decided to experiment with shifting from ViewModels to utilizing the Compose Runtime for managing screen state. This article explores the motivations behind this approach and demonstrates an overall improvement to the view layer and presentation logic using the patterns developed in Amion 6.0.0. Note: This is part one of a two-part article. In part two, we will build a note-taking app using the foundations covered here. Understanding the Presentation Layer The Android team at Doximity builds apps following the basic principles of clean architecture, which involves separating the app into layers, each with their own responsibilities. In our app, we have a view layer, responsible for rendering UI components (Compose UI, XML views, etc.), and a presentation logic layer, responsible for producing screen state. Every navigable point in the app corresponds to one or more UI components and is associated with one or more screen state producers. Inspiration and Initial Experiments The decision to leverage Compose for managing state was inspired by (at the risk of sounding like r/mAndroidDev) Jake Wharton's article The State of Managing State (with Compose). While the release of Circuit occurred midway through our development, it was deemed more of a framework that required significant buy-in, whereas we aimed to build a flexible pattern with smoother interoperability with our existing architecture, that at the time mostly utilized ViewModel with XML and Compose UI. When we think about the presentation layer in Android as developers, we have to think about: What is the state of the screen? That is, not just when the user first sees it, but what does it look like when it's loading, what happens when there is an error, how will the state of components of the screen interact, and

## Notes from the Clean Architecture book

DevFeed: [Notes from the Clean Architecture book](<https://devfeed.tech/articles/notes-from-the-clean-architecture-book-26135.md>)

Original publisher: [Read original article](<https://vadzimv.dev/2021/09/28/notes-from-clean-architecture-book.html>)

Author: Vadzimv Dev Blog

Published: 2021-09-28T09:30:00Z

Content type: article

Language: en

Sources: [vadzimv Dev Blog](<https://devfeed.tech/sources/vadzimv-dev-blog.md>)

Topics: [maintenance](<https://devfeed.tech/topics/maintenance.md>), [Code](<https://devfeed.tech/topics/code.md>), [releases](<https://devfeed.tech/topics/releases.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [article](<https://devfeed.tech/tags/article.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [notes](<https://devfeed.tech/tags/notes.md>)

### AI overview

Notes on selected topics from the Clean Architecture book, focusing on component cohesion principles and acyclic dependencies. The article explains trade-offs among the Reuse/Release Equivalence, Common Closure, and Common Reuse principles, and describes how versioned components and ownership can support independent development.

### Source excerpt

New things that I found in the Clean Architecture book.

## Structural and navigation anti-patterns in modularized Android applications

DevFeed: [Structural and navigation anti-patterns in modularized Android applications](<https://devfeed.tech/articles/structural-and-navigation-anti-patterns-in-modularized-android-applications-25933.md>)

Original publisher: [Read original article](<https://proandroiddev.com/structural-and-navigation-anti-patterns-in-modularized-android-applications-a7d667e35cd6?source=rss-7a8d96da8cb6------2>)

Author: Gabor Varadi

Published: 2020-12-25T11:38:05Z

Content type: article

Language: en

Sources: [Stories by Gabor Varadi on Medium](<https://devfeed.tech/sources/stories-by-gabor-varadi-on-medium.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [modules](<https://devfeed.tech/topics/modules.md>), [navigation](<https://devfeed.tech/topics/navigation.md>), [Code](<https://devfeed.tech/topics/code.md>), [Dagger](<https://devfeed.tech/topics/dagger.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>), [RxJava](<https://devfeed.tech/topics/rxjava.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [antipattern](<https://devfeed.tech/tags/antipattern.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [dagger-2](<https://devfeed.tech/tags/dagger-2.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [domain-driven-design](<https://devfeed.tech/tags/domain-driven-design.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [navigation-architecture](<https://devfeed.tech/tags/navigation-architecture.md>), [rxjava](<https://devfeed.tech/tags/rxjava.md>)

### AI overview

This article examines structural and navigation anti-patterns in modularized Android applications. It traces the history of Android Clean Architecture and argues that organizing an application around top-level data, domain, and presentation modules can be problematic, particularly when the structure is adopted from educational examples rather than feature-based organization.

### Source excerpt

Structural and navigation anti-patterns in multi-module and modularized applications: The case against "Android Clean Architecture" and the "domain" moduleTop-level "domain" module is a code smell. Merry Christmas to all! The subject of this article is one that has been on my mind for a very long time. After all, "Clean Architecture" is often seen as the end goal, the hallmark of the finest of Android application code structure -- it is the best of the very best. The name itself, "Clean Architecture", signals that it's a good thing ~ after all, who wants to work with "messy" code in comparison? Of course, the title of this article shows that this isn't the conclusion we'll come to. The following tweet is closer to our final evaluation -- let us analyze why it might be accurate. Clean architecture + Android for us was like building a beautiful sailing boat in your backyard because someone on TV convinced you it's better for crossing the sea than an inflatable, while you live in the mountains and also your house is on fire. https://t.co/iGqy25wk7m The history of "Android Clean Architecture"The origins To understand "Clean Architecture" as done on Android, we must trace it back to its roots, and where/when it was made popular in the first place. As far as I'm aware, it dates back to 2014, the original proposition in "Fernando Cejas: Architecting Android... the clean way?". It was a highly influential article, as it revolutionized the structure of Android apps. Code that is actually separated across layers (back when Fragments were untrustworthy, and all code was in OS-level components), rather than just throwing everything into 2000+ line Activities? A pioneer of its time. One interesting decision however in the representative sample code was that in order to signify the strict separation of layers, these layers were each separated from one another using top-level Gradle modules, each labeled data, domain, and presentation. As we will see, this is the downfall of the sampl

## Clean architecture for Android with Kotlin: a pragmatic approach for starters

DevFeed: [Clean architecture for Android with Kotlin: a pragmatic approach for starters](<https://devfeed.tech/articles/clean-architecture-for-android-with-kotlin-a-pragmatic-approach-for-starters-27142.md>)

Original publisher: [Read original article](<https://antonioleiva.com/clean-architecture-android>)

Published: 2018-09-30T00:00:00Z

Content type: tutorial

Language: en

Sources: [Antonio Leiva](<https://devfeed.tech/sources/antonio-leiva.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [dependency-inversion](<https://devfeed.tech/tags/dependency-inversion.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [oop](<https://devfeed.tech/tags/oop.md>), [programming](<https://devfeed.tech/tags/programming.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

A pragmatic introductory tutorial on clean architecture for Android apps using Kotlin. It focuses on dependency inversion, explains the tradeoff between decoupling and added complexity, and introduces a five-layer application structure.

### Source excerpt

Everything Android, Kotlin and other random topics

## Rewriting the trivago Android app: challenges and lessons learnt

DevFeed: [Rewriting the trivago Android app: challenges and lessons learnt](<https://devfeed.tech/articles/rewriting-the-trivago-android-app-challenges-and-lessons-learnt-28065.md>)

Original publisher: [Read original article](<https://tech.trivago.com/post/android-new-architecture/>)

Author: Rafael Ortega Lupión Follow

Published: 2018-02-06T00:00:00Z

Content type: article

Language: en

Sources: [Trivago](<https://devfeed.tech/sources/trivago.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [android-development](<https://devfeed.tech/topics/android-development.md>), [Development](<https://devfeed.tech/topics/development.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [cross-functional-teams](<https://devfeed.tech/tags/cross-functional-teams.md>), [development](<https://devfeed.tech/tags/development.md>), [good-practices](<https://devfeed.tech/tags/good-practices.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [tests](<https://devfeed.tech/tags/tests.md>), [ux](<https://devfeed.tech/tags/ux.md>)

### AI overview

The trivago Android development team describes the challenges and lessons of rewriting its app, focusing on architectural decisions, cross-functional collaboration, workflow, product goals, and user experience.

### Source excerpt

How the Android development team came up with a new architecture based on clean principles and what we learnt along the way.

## June meetup at Button: Clean Architecture & UI Navigation - touchlab

DevFeed: [June meetup at Button: Clean Architecture & UI Navigation - touchlab](<https://devfeed.tech/articles/june-meetup-at-button-clean-architecture-ui-navigation-touchlab-38140.md>)

Original publisher: [Read original article](<https://touchlab.co/2017-6-june-meetup-at-button-clean-architecture-ui-navigation>)

Published: 2017-06-21T20:18:56Z

Content type: article

Language: en

Sources: [Touchlab | Enterprise Mobile Innovation & Development](<https://devfeed.tech/sources/touchlab-enterprise-mobile-innovation-development.md>)

Topics: [navigation](<https://devfeed.tech/topics/navigation.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [Library](<https://devfeed.tech/topics/library.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [components](<https://devfeed.tech/tags/components.md>), [event](<https://devfeed.tech/tags/event.md>), [ios](<https://devfeed.tech/tags/ios.md>), [meetup](<https://devfeed.tech/tags/meetup.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [net](<https://devfeed.tech/tags/net.md>), [talks](<https://devfeed.tech/tags/talks.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

A recap of touchlab's June meetup at Button, featuring the launch of the cross-platform Doppl project, a demo of Button, and talks on UI navigation and Android Architecture Components.

### Source excerpt

For our June meetup, we reconvened at Button's new event space. Our members were treated to talks in a sunlit room and a balcony overlooking 23rd Street.

## Nov. Meetup: Testable Android Architecture, and Mobile Platform Independent Architecture - olin

DevFeed: [Nov. Meetup: Testable Android Architecture, and Mobile Platform Independent Architecture - olin](<https://devfeed.tech/articles/nov-meetup-testable-android-architecture-and-mobile-platform-independent-architecture-olin-38110.md>)

Original publisher: [Read original article](<https://touchlab.co/2016-11-november-meetup>)

Published: 2016-11-21T21:15:10Z

Content type: news

Language: en

Sources: [Touchlab | Enterprise Mobile Innovation & Development](<https://devfeed.tech/sources/touchlab-enterprise-mobile-innovation-development.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [App](<https://devfeed.tech/topics/app.md>), [Large Screen](<https://devfeed.tech/topics/large-screen.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [community](<https://devfeed.tech/tags/community.md>), [event](<https://devfeed.tech/tags/event.md>), [ios](<https://devfeed.tech/tags/ios.md>), [meetup](<https://devfeed.tech/tags/meetup.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [talk](<https://devfeed.tech/tags/talk.md>)

### AI overview

A November meetup recap covering talks on testable Android architecture and architecture for mobile applications targeting Android and iOS. The event also included an AnDevCon giveaway and an announcement about Droidcon Dominican Republic.

### Source excerpt

For November we headed to Oscar Health's SoHo office. Before the talks, Kevin and I held a Twitter contest to give away an event passport to AnDevCon!

## The Repository Pattern: History, Abstraction, and Android Use Cases

DevFeed: [The Repository Pattern: History, Abstraction, and Android Use Cases](<https://devfeed.tech/articles/the-evolution-of-the-repository-pattern-be-aware-of-over-abstraction-25444.md>)

Original publisher: [Read original article](<https://hannesdorfmann.com/android/evolution-of-the-repository-pattern/>)

Author: Hannes Dorfmann

Published: 2016-07-17T09:00:00Z

Content type: article

Language: en

Sources: [Hannes Dorfmann](<https://devfeed.tech/sources/hannes-dorfmann.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [android-development](<https://devfeed.tech/topics/android-development.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blog](<https://devfeed.tech/tags/blog.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [opinion](<https://devfeed.tech/tags/opinion.md>)

### AI overview

This article traces how the Repository Pattern is defined in different contexts and programming languages. It argues that the original definition can introduce unnecessary abstraction and overengineering, especially in Android, while discussing a more practical interpretation for common use cases.

### Source excerpt

A listener from our podcast, The Context, that Artem Zinnatullin and I run asked me, if I can give him an example of the Repository Pattern. So I googled around and stumbled upon some blog posts and found out that the term Repository Pattern is used and described in many different ways.