From Single Module to Multiple Modules: A Cleaner and More Efficient Approach to App Development

Introduction

In the world of app development, managing large codebases can be a daunting task. Initially, many projects start with a single module containing everything: business logic (BL), user interface (UI), unit tests, and every feature flow. While this approach can work for small projects, it often leads to challenges as the project grows. Merging conflicts, tightly coupled code, and a lack of modularity can slow development and increase the risk of bugs. This article explores the transition from a single module to multiple modules, highlighting the benefits and providing practical examples.

The Challenges of a Single Module Approach

When an app starts as a single module, all components are intertwined. It includes:

• Feature Flows: Different features and their respective flows are combined in one place.
• Networking: API calls and network-related logic are handled within the same module.
• Data Transfer Objects (DTOs): Data structures for communication between different parts of the app are centrally located.
• Design and UI Components: User interface elements and design logic are included in the same module.

While this approach might be convenient initially, it presents several issues as the app scales:

• Merging Conflicts: Multiple developers working on different features can cause frequent conflicts when merging code.
• Lack of Isolation: Bugs in one feature can affect others, making it harder to isolate and fix issues.
• Restricted Development: Developers may unintentionally modify parts of the codebase outside their designated features, leading to unexpected behaviors and reduced productivity.

Transitioning to Multiple Modules

We transitioned from a single module to multiple modules to address these challenges. This approach involves splitting the codebase into distinct modules, each responsible for a specific aspect of the app. Here’s how this modularization works:

• Feature Modules

Each feature has its module. For instance:

- Buying Flow: Display product list, select product, checkout and payment.

- Settings Flow: Manages user profiles, settings, and preferences.

- Core Modules: The core functionality that is shared across features is separated into dedicated modules:

- Networking Module: Manages API calls, including setup, request handling, and responses.

- DTO Module: Contains data transfer objects used across different features.

- UI Components Module: Houses reusable UI elements and design patterns.

- Common Modules

Common modules provide common services and helpers:

- Logging Module: Standardizes logging across the app.

- Analytics Module: Manages analytics and tracking.

Benefits of Modularization

1. Improved Code Management

- Each module can be developed, tested, and maintained independently.

- Changes in one module do not affect others, reducing the risk of bugs and integration issues.

2. Enhanced Collaboration

- Developers can work on different modules simultaneously without interfering with each other’s work.

- Code ownership is clear, reducing the likelihood of conflicts and merge issues.

3. Scalability and Flexibility

- New features can be added as separate modules without impacting existing functionality.

- Modules can be reused across different projects, improving development efficiency.

4. Better Testing and Debugging

- Unit tests can be more focused and easier to manage within specific modules.

- Bugs are easier to isolate and fix since modules are decoupled from each other.

In Prezzee, we evolved from a single-module architecture to a modular one. Initially, the app contained all feature flows, networking, DTOs, and design elements in a single module. This setup led to frequent conflicts and slow development cycles.

With modularization, we restructured the app as follows:

- Buying Flow Module: Manages display product list, select product, checkout, and payment.

- Setting Flow Module: Manages user profiles, settings, and preferences.

- Networking Module: Centralizes API calls and network logic.

- DTO Module: Contains all data transfer objects used across the app.

- UI Components Module: Houses reusable UI elements and design patterns.

Conclusion

Transitioning from a single module to multiple modules is a significant step towards a cleaner and more efficient architecture. It allows for better code management, enhanced collaboration, and improved scalability. By modularizing your app, you can ensure that each part of the project is well-isolated, easier to maintain, and more resilient to changes. This approach not only improves the developer experience but also leads to a more robust and scalable app.

In the case of Prezzee, modularization has proven to be a valuable strategy, enabling our team to work more efficiently and deliver higher-quality software.