In the early days of development, I had no idea about testing. I kept avoiding testable code and ended up with multiple production bugs and issues. After realising the importance of writing clean and testable code, I started to explore multiple solutions and testing frameworks for creating an easily testable...

Before building a product, we need to set some requirements, architecture designs, security concerns etc. These play an important role in organizing, creating fast and scalable applications. A typical mobile system design includes application features, architecture design, and out-of-scope requirements like crash reporting, analytics etc.

You might wonder how software engineers are able to write well-structured, flexible, and clean code. You might also wonder what patterns and principles they follow to master clean code. Let’s break down the topic into smaller chunks and look at the core principles and key points to master clean, flexible,...

Survive Recomposition Use remember to retain state across recompositions. For example, store a text field’s value to prevent resetting during UI updates.

This explores common naming patterns used in software architecture and explains their purposes. Each pattern serves a specific role in creating maintainable and well-structured code. Understanding these patterns helps developers choose appropriate names that clearly communicate a component’s responsibility.

Resource Management Use the use() function for resources like files or databases to ensure automatic closure, even if an exception occurs. This will help in prevent the memory leaks and close the FileDescriptors which is unused to work.

Use App Startup for Initialization The App Startup library simplifies application-level initialization by centralizing component setup. Instead of relying on base application (which add overhead and cause slow app launch), App Startup allows you to define initializers, reducing startup time and improving efficiency.

Choosing the right software architecture is a crucial decision that can significantly impact your project’s success. While there’s no one-size-fits-all solution, there are clear principles and considerations that can guide your decision-making process.

In Essentialism, Greg McKeown draws on experience and insight from working with the leaders of the most innovative companies in the world to show how to achieve the disciplined pursuit of less.

Coroutines And Flow are one of the ways to deal with asynchronous programming with multiple operators like RxJava. In Android, We use coroutines for dealing with multi-threading, concurrency, thread locks etc. And Kotlin Flow used used for asynchronous data streams like RxJava. In this article, we are heading towards Kotlin...

When building Android applications that load images from URLs, implementing an efficient caching strategy is crucial for performance and user experience. Without proper caching, your app might repeatedly download the same images, leading to poor performance and potential Out of Memory (OOM) exceptions. Caching is a technique to store frequently...

In an ever-growing code base, scalability, readability, testability, and overall code quality often decrease over time. This comes as a result of the codebase increasing in size without its maintainers taking active measures to enforce an easily maintainable structure. Modularization is a means of structuring your codebase in a way...

Clean Architecture typically consists of three main layers: Data, Domain, and Presentation, each with distinct responsibilities and dependencies.

As Android apps grow in size, it’s important to design architecture that allows the app to scale, increases the app’s robustness, and makes the app easier to test. Here are some design principles we can follow to design our app:

Let’s talk about something that’s been bugging Android developers for ages - Clean Architecture. You know how everyone’s always like “Should I use MVVM? Or maybe MVP?” Well, let me tell you something cool - it’s not just about picking one and sticking with it.

Imagine that, we have to create lots of objects which are depends on one another to perform some operations. As codebase grows, we need some external support to manage those objects in flexible way. It’s a bad practise if we create same objects again and again. It push Garbage collector...