# modularization

Published articles for modularization.

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

## How we standardized MariaDB in our Integration Server

DevFeed: [How we standardized MariaDB in our Integration Server](<https://devfeed.tech/articles/how-we-standardized-mariadb-in-our-integration-server-20462.md>)

Original publisher: [Read original article](<https://eng.wealthfront.com/2026/03/26/how-we-standardized-mariadb-in-our-integration-server/>)

Author: Eloy Gonzalez

Published: 2026-03-26T18:59:43Z

Content type: article

Language: en

Sources: [Wealthfront](<https://devfeed.tech/sources/wealthfront.md>)

Topics: [MariaDB](<https://devfeed.tech/topics/mariadb.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Jenkins](<https://devfeed.tech/topics/jenkins.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [careers](<https://devfeed.tech/tags/careers.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering-culture](<https://devfeed.tech/tags/engineering-culture.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [jenkins](<https://devfeed.tech/tags/jenkins.md>), [locking](<https://devfeed.tech/tags/locking.md>), [migration](<https://devfeed.tech/tags/migration.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [production](<https://devfeed.tech/tags/production.md>), [sql](<https://devfeed.tech/tags/sql.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [wealthfront-engineering](<https://devfeed.tech/tags/wealthfront-engineering.md>)

### AI overview

Wealthfront describes migrating its Integration Server from HSQLDB to MariaDB to improve parity with production. The article covers the migration strategy, architectural hurdles, and benefits for data integrity, concurrency, locking, and production-like testing.

### Source excerpt

Engineering at Wealthfront is centered on the idea that code should be written to facilitate testing, not the other way around. Without a staging environment to fall back on, we maximize confidence through a sophisticated, multi-layered testing strategy. While unit tests provide our most rigorous line of defense, our Integration Server is the workhorse that... Read more

## XcodeGen and the quest to modularize the Wealthfront iOS app

DevFeed: [XcodeGen and the quest to modularize the Wealthfront iOS app](<https://devfeed.tech/articles/xcodegen-and-the-quest-to-modularize-the-wealthfront-ios-app-20461.md>)

Original publisher: [Read original article](<https://eng.wealthfront.com/2026/03/02/xcodegen-and-the-quest-to-modularize-the-wealthfront-ios-app/>)

Author: Matthew Bommer

Published: 2026-03-02T17:56:41Z

Content type: tutorial

Language: en

Sources: [Wealthfront](<https://devfeed.tech/sources/wealthfront.md>)

Topics: [XcodeGen](<https://devfeed.tech/topics/xcodegen.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [Xcode](<https://devfeed.tech/topics/xcode.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [careers](<https://devfeed.tech/tags/careers.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [ios](<https://devfeed.tech/tags/ios.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [swift](<https://devfeed.tech/tags/swift.md>), [wealthfront-engineering](<https://devfeed.tech/tags/wealthfront-engineering.md>), [xcode](<https://devfeed.tech/tags/xcode.md>), [xcodegen](<https://devfeed.tech/tags/xcodegen.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

Wealthfront describes adopting XcodeGen to generate Xcode project files from declarative YAML, reducing project-file merge conflicts and making build configuration more reviewable. The team also plans to use it to support modularizing its large iOS application into independently compilable modules.

### Source excerpt

Every iOS application starts as a monolith. Xcode's default project structure places all source files, resources, and build configuration into a single module (or target, for all the iOS devs reading this). For small apps, this works fine. For a 10+ year old financial application with roughly 2,000 Swift and a handful of Objective-C files,... Read more

## Modularizing Rails Monoliths One Bite at a Time

DevFeed: [Modularizing Rails Monoliths One Bite at a Time](<https://devfeed.tech/articles/modularizing-rails-monoliths-one-bite-at-a-time-20038.md>)

Original publisher: [Read original article](<https://technology.doximity.com/articles/modularizing-rails-monoliths-one-bite-at-a-time>)

Author: Doximity

Published: 2023-12-05T13:00:00Z

Content type: article

Language: en

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

Topics: [Ruby on Rails](<https://devfeed.tech/topics/ruby-on-rails.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>)

Tags: [microservices](<https://devfeed.tech/tags/microservices.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [rails](<https://devfeed.tech/tags/rails.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [ruby-on-rails](<https://devfeed.tech/tags/ruby-on-rails.md>)

### AI overview

The article describes using a phased refactoring approach and the packwerk gem to modularize growing Rails monoliths into modules with enforced boundaries. It presents the modular monolith as a lower-complexity alternative to adopting microservices and references Doximity's experience.

### Source excerpt

As Rails monoliths grow, coupling becomes increasingly difficult to manage. Developers often reach for microservices to help simplify things, but instead find higher complexity. The Modular Monolith approach is a proven, lightweight alternative that offers the benefits of enforced boundaries without being cumbersome. I spoke at the 2023 Rocky Mountain Ruby conference on how teams can use a phased approach to refactoring toward this style using the packwerk gem. At Doximity, we've used this gem and a phased approach to break some of our most critical rails applications into modules that are easier for our teams to work with. In November, 2023, I also chatted with Elise Shaffer on The Ruby on Rails Podcast about our experience with application modularization at Doximity. Be sure to follow @doximity_tech if you'd like to be notified about new blog posts.

## Scaling Teams Mobile Development -- The Mental Model

DevFeed: [Scaling Teams Mobile Development -- The Mental Model](<https://devfeed.tech/articles/scaling-teams-mobile-development-the-mental-model-22784.md>)

Original publisher: [Read original article](<https://medium.com/microsoft-mobile-engineering/scaling-teams-mobile-development-the-mental-model-8224afb1e4ba?source=rss----87f10537e947---4>)

Author: Anand Nath

Published: 2023-03-03T02:22:43Z

Content type: article

Language: en

Sources: [Android@Microsoft - Medium](<https://devfeed.tech/sources/android-microsoft-medium.md>)

Topics: [Mobile](<https://devfeed.tech/topics/mobile.md>), [Development](<https://devfeed.tech/topics/development.md>), [App](<https://devfeed.tech/topics/app.md>), [Code](<https://devfeed.tech/topics/code.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [code](<https://devfeed.tech/tags/code.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [development](<https://devfeed.tech/tags/development.md>), [integration](<https://devfeed.tech/tags/integration.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [ios](<https://devfeed.tech/tags/ios.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [mobile-development](<https://devfeed.tech/tags/mobile-development.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [patterns](<https://devfeed.tech/tags/patterns.md>)

### AI overview

This article presents a mental model for scaling partner integrations in the Microsoft Teams mobile codebase. It describes the existing tight coupling between feature producers and consumer entry points, then proposes decoupling them through interfaces, a producer registry, and a manager that handles feature discovery and coordination.

### Source excerpt

Scaling Teams Mobile Development -- The Mental Model In the article Scaling Teams Mobile Development -- Evolving the design pattern we explored how multiple partner teams working on a large code base can be streamlined by employing the contributor design pattern. I decided to write this article as a prequel. In this article we will discuss the problem statement in a more generic way and draw some parallels with popular design patterns. Photo by Xavi Cabrera on Unsplash We started with the following mission statement in mind: Make partner integrations with Teams mobile easier, well segregated, with clear protocols. Teams is a complex mobile application with a LOT of integration points. Partner teams surface their features through these entry points. The following image highlight few entry points available in Teams. Few entry points in Teams mobile app When we looked at the partner integration story in Teams codebase, it became evident that the whole integration story is a Producer-Consumer design pattern which is not implemented correctly. Producer -- Consumer deep coupling Here is the mental model that we built: Entry points are consumers of features and partner teams are producers of features. In the existing method, each partner team directly integrated with the entry point. This meant each consumer had to know the producers directly and when a new producer was added, the consumer had to be updated. This resulted in tight coupling. This is not a scalable model. N x N relationship between Producers and Consumers For the system to scale we need to decouple the producers and the consumers and build strong contracts between them. We wanted to safeguard changes to the consumer. At the same time, we wanted to make the producers independent and able to churn out their features fast. We also wanted to centralize control on producers and its features for deciding their ordering, filtering, enablement etc. So, we evolved this design pattern, where we define multiple Feature in

## Mastering The Gradle Dependency Tree

DevFeed: [Mastering The Gradle Dependency Tree](<https://devfeed.tech/articles/mastering-the-gradle-dependency-tree-25156.md>)

Original publisher: [Read original article](<https://blog.droidchef.dev/mastering-the-gradle-dependency-tree/>)

Author: Ishan Khanna

Published: 2023-01-11T23:09:51Z

Content type: tutorial

Language: en

Sources: [Ishan Khanna](<https://devfeed.tech/sources/ishan-khanna.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Library](<https://devfeed.tech/topics/library.md>), [Maven Central](<https://devfeed.tech/topics/maven-central.md>)

Tags: [debug](<https://devfeed.tech/tags/debug.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [library](<https://devfeed.tech/tags/library.md>), [maven-central](<https://devfeed.tech/tags/maven-central.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [resolved](<https://devfeed.tech/tags/resolved.md>), [transitive-dependencies](<https://devfeed.tech/tags/transitive-dependencies.md>)

### AI overview

This tutorial explains Gradle dependencies, transitive dependencies, dependency configurations, and dependency trees. It also presents five ways to generate a dependency tree and discusses managing versions to avoid conflicts and unnecessary project bloat.

### Source excerpt

Learn everything about the Gradle Dependency Tree and Five Different Ways to Generate Them.

## Impact of Dependency Tree Depth on Gradle Builds

DevFeed: [Impact of Dependency Tree Depth on Gradle Builds](<https://devfeed.tech/articles/impact-of-dependency-tree-depth-on-gradle-builds-25155.md>)

Original publisher: [Read original article](<https://blog.droidchef.dev/impact-of-dependency-tree-depth-on-gradle-builds/>)

Author: Ishan Khanna

Published: 2022-12-05T07:46:58Z

Content type: tutorial

Language: en

Sources: [Ishan Khanna](<https://devfeed.tech/sources/ishan-khanna.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [build times](<https://devfeed.tech/topics/build-times.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-times](<https://devfeed.tech/tags/build-times.md>), [caching](<https://devfeed.tech/tags/caching.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [tips-and-tricks](<https://devfeed.tech/tags/tips-and-tricks.md>)

### AI overview

This tutorial examines how dependency tree depth affects Gradle build times in modularized, multi-project builds. It analyzes changes at the top, middle, and bottom of the dependency tree and explains Gradle tasks, dependency graphs, and task output caching.

### Source excerpt

In this post, Ishan shows the impact of dependency tree depth on Gradle Builds with a complete analysis of changes at the Top, Middle, and Bottom of the Dependency Tree.

## Building Plugable Features on Android

DevFeed: [Building Plugable Features on Android](<https://devfeed.tech/articles/building-plugable-features-on-android-30602.md>)

Original publisher: [Read original article](<https://ryanharter.com/blog/2022/08/building-plugable-features-on-android/>)

Published: 2022-08-07T15:05:54Z

Content type: tutorial

Language: en

Sources: [Blogs on Ryan Harter](<https://devfeed.tech/sources/blogs-on-ryan-harter.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [App](<https://devfeed.tech/topics/app.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [screen](<https://devfeed.tech/topics/screen.md>), [feature flags](<https://devfeed.tech/topics/feature-flags.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [building](<https://devfeed.tech/tags/building.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [developer](<https://devfeed.tech/tags/developer.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [modularization](<https://devfeed.tech/tags/modularization.md>)

### AI overview

This article discusses modularizing Android projects with Gradle and designing reusable developer settings features. It describes aggregating feature dependencies and moving each feature's debug configuration alongside the code it configures.

### Source excerpt

As Gradle projects and their teams grow, modularization becomes an important tool to help ensure developers can continue to be productive without stepping on each other's toes. This can lead to some interesting architectural challenges, however, when creating features that require aggregating dependencies. One example of a feature like this could be a developer settings screen, which allows configuration of different features within an app, and whose features might change between apps.

## Dagger Tips: Guide to using Dagger-Android effectively

DevFeed: [Dagger Tips: Guide to using Dagger-Android effectively](<https://devfeed.tech/articles/dagger-tips-guide-to-using-dagger-android-effectively-25929.md>)

Original publisher: [Read original article](<https://itnext.io/dagger-tips-guide-to-using-dagger-android-effectively-c3e5b2883b38?source=rss-7a8d96da8cb6------2>)

Author: Gabor Varadi

Published: 2021-02-13T05:05:50Z

Content type: tutorial

Language: en

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

Topics: [Dagger](<https://devfeed.tech/topics/dagger.md>), [Android](<https://devfeed.tech/topics/android.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Development](<https://devfeed.tech/topics/development.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [dagger-2](<https://devfeed.tech/tags/dagger-2.md>), [dagger-android](<https://devfeed.tech/tags/dagger-android.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [development](<https://devfeed.tech/tags/development.md>), [guide](<https://devfeed.tech/tags/guide.md>), [interface](<https://devfeed.tech/tags/interface.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [module](<https://devfeed.tech/tags/module.md>), [scalability](<https://devfeed.tech/tags/scalability.md>)

### AI overview

A guide to using Dagger-Android, explaining its field-injection approach, the modularization constraints it addresses, and alternatives involving interfaces or shared superclasses. The article notes that Dagger-Android has been superseded by Hilt for common injection cases.

### Source excerpt

Something people could ask me as they're reading this title: "Hold on a second, isn't Dagger-Android no longer in active development? Isn't it made obsolete with the introduction of Hilt?" Technically, yes. Dagger-Android is superseded by Hilt. So there is a good chance that if you are already using Hilt, then for the most common cases (injecting Activity, Fragment, ViewModel, Worker), you don't need to think about Dagger-Android whatsoever. However, as I still see @ContributesAndroidInjector popping up every now and then, I feel that it's best if I write an article on how it works, what it intended to solve, how to use it, and how NOT to use it (for better scalability). What was Dagger-Android? Dagger-Android was a way to field-inject classes (not necessarily just Android classes since Dagger 2.20+) without having to define a fun inject(target: MyConcreteClassTarget) injector method on the component -- as we don't know the class itself. When do you want to avoid creating fun inject(t: T) in a component? After all, this is what normally allows field injection to be type-safe. The answer is, when you can't. If you use a modularization pattern where :app contains the ApplicationComponent(or SingletonComponent), then while ApplicationComponent can see any Activity or Fragment within the app, the submodules don't see :app and therefore don't see ApplicationComponent. Therefore, they can't call component.inject(this)! On the other hand, if you were to define an Application.ActivityLifecycleCallbacks to do it automatically, that wouldn't work with the standard approach -- as you see only the superclass, but not the concrete class! So if one wants to use field injection with our provided restrictions, there are two options: Expose an interface from the child module that defines the injection targets, and implement that on the ApplicationComponent -- then make it possible to access it (for example, using the ApplicationContext for lookup) and cast it to the interface to be abl

## 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

## Android library development - Modularization

DevFeed: [Android library development - Modularization](<https://devfeed.tech/articles/android-library-development-modularization-28691.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2020/11/04/library-modularization/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2020-11-04T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [Android Library](<https://devfeed.tech/topics/android-library.md>), [Library](<https://devfeed.tech/topics/library.md>), [SDK](<https://devfeed.tech/topics/sdk.md>), [Development](<https://devfeed.tech/topics/development.md>), [Android Gradle Plugin](<https://devfeed.tech/topics/android-gradle-plugin.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-gradle-plugin](<https://devfeed.tech/tags/android-gradle-plugin.md>), [android-jetpack](<https://devfeed.tech/tags/android-jetpack.md>), [android-library](<https://devfeed.tech/tags/android-library.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [development](<https://devfeed.tech/tags/development.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [library](<https://devfeed.tech/tags/library.md>), [maven](<https://devfeed.tech/tags/maven.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [sdk](<https://devfeed.tech/tags/sdk.md>)

### AI overview

This article explains modularization challenges in Android libraries and SDKs, including missing submodule dependencies and unintended exposure of submodule APIs. It presents three approaches: publishing submodules to Maven, bundling them into a fat AAR, or creating a single-module SDK.

### Source excerpt

With modularization being all the hype, should you also modularize an SDK? Are fat aar files really needed? And how do you prevent internal APIs from being exposed on your public interface?

## Modularization - Lessons learned

DevFeed: [Modularization - Lessons learned](<https://devfeed.tech/articles/modularization-lessons-learned-28681.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2019/06/12/modularizationtips/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2019-06-12T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>), [Git](<https://devfeed.tech/topics/git.md>), [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>)

Tags: [android-studio](<https://devfeed.tech/tags/android-studio.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [git](<https://devfeed.tech/tags/git.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tips](<https://devfeed.tech/tags/tips.md>)

### AI overview

The article shares lessons learned from modularizing apps at Philips Hue. It covers simplifying module configuration, visualizing module dependencies, organizing settings.gradle, and structuring large multi-module projects.

### Source excerpt

Wrapping up this series on modularization I'd like to share some of the things we've learned at Philips Hue while going through this process the past year.

## Modularization - How to approach

DevFeed: [Modularization - How to approach](<https://devfeed.tech/articles/modularization-how-to-approach-28680.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2019/04/24/modularizationhow/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2019-04-24T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [Library](<https://devfeed.tech/topics/library.md>), [legacy](<https://devfeed.tech/topics/legacy.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [android-library](<https://devfeed.tech/tags/android-library.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [library](<https://devfeed.tech/tags/library.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

This tutorial explains two strategies for gradually modularizing an existing Android app: converting the old app into a library and pulling code up, or keeping the old app in place and pushing modules down. It describes the trade-offs and migration challenges of each approach, including legacy dependencies and upfront changes.

### Source excerpt

Now that we have a clear idea of how a modularized app could look like how can this be applied to an existing app? Part four will dive deeper into how existing apps can be sliced and how you can gradually migrate to a fully modularized architecture.

## Modularization - Real-life example

DevFeed: [Modularization - Real-life example](<https://devfeed.tech/articles/modularization-real-life-example-28679.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2019/04/02/modularizationexample/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2019-04-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [navigation](<https://devfeed.tech/topics/navigation.md>), [App](<https://devfeed.tech/topics/app.md>), [test](<https://devfeed.tech/topics/test.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [sample](<https://devfeed.tech/tags/sample.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

This tutorial presents a practical example of a multi-module application architecture. It examines the resulting application structure, navigation graphs, staged rollouts, testing, and a production application using the architecture.

### Source excerpt

With a clear view on how multi-module apps should be architected, let's dive into a real-life practical example. We'll discover how the architecture results in a clear application structure, how navigation is handled, how to use staged rollouts, how to test everything and even look at a production app that is using this architecture.

## Modularized Architecture for Android Apps

DevFeed: [Modularized Architecture for Android Apps](<https://devfeed.tech/articles/modularization-a-successful-architecture-28678.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2019/03/18/modularizationarchitecture/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2019-03-18T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [App](<https://devfeed.tech/topics/app.md>), [Android](<https://devfeed.tech/topics/android.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [ui](<https://devfeed.tech/topics/ui.md>), [screen](<https://devfeed.tech/topics/screen.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [screen](<https://devfeed.tech/tags/screen.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

This tutorial presents a modularized architecture for Android apps. It describes splitting apps into independent feature modules connected through a simple startActivityForResult contract, with shared business logic and UI components organized into library modules.

### Source excerpt

Now that we've established that modularization is a really good thing to strive for, how should a modularized app look like? How are the different modules connected?

## Modularization - Why you should care

DevFeed: [Modularization - Why you should care](<https://devfeed.tech/articles/modularization-why-you-should-care-28677.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2019/03/06/modularizationwhy/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2019-03-06T00:00:00Z

Content type: article

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [modules](<https://devfeed.tech/topics/modules.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Development](<https://devfeed.tech/topics/development.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>)

Tags: [app-size](<https://devfeed.tech/tags/app-size.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [development](<https://devfeed.tech/tags/development.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

This first post in a series explains why app modularization can be useful. It covers potential benefits including faster builds through Gradle caching and parallelism, on-demand delivery, simpler development, module reuse, experimentation, scaling teams, refactoring, and test automation.

### Source excerpt

Modularizing your app seems to be all the hype these days. But why should you actually care? What are the benefits for you and your team?

## Lazy Angular Modules

DevFeed: [Lazy Angular Modules](<https://devfeed.tech/articles/lazy-angular-modules-21219.md>)

Original publisher: [Read original article](<https://juri.dev/blog/2014/07/lazy-angular-modules/>)

Published: 2014-07-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [Juri Strumpflohner](<https://devfeed.tech/sources/juri-strumpflohner.md>)

Topics: [Angular](<https://devfeed.tech/topics/angular.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Single-page application (SPA)](<https://devfeed.tech/topics/spa.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [mvc](<https://devfeed.tech/topics/mvc.md>)

Tags: [angular](<https://devfeed.tech/tags/angular.md>), [guide](<https://devfeed.tech/tags/guide.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lazy-loading](<https://devfeed.tech/tags/lazy-loading.md>), [modularization](<https://devfeed.tech/tags/modularization.md>), [modules](<https://devfeed.tech/tags/modules.md>), [mvc](<https://devfeed.tech/tags/mvc.md>)

### AI overview

This article examines lazy loading approaches for Angular modules and argues for organizing Angular applications by feature rather than by MVC folders. It discusses startup performance, modularization, maintainability, and examples from the Angular community.

### Source excerpt

Lorem ipsum dolor sit amet