Every 'Best Practice' Android Taught You Eventually Gets Overturned
Maintaining a mature Android codebase means living with multiple generations of official guidance that Google itself has deprecated. This piece names that experience and makes the case for architectural humility: plan for replaceability rather than permanence, because the 'best practice' label is provisional.
Android's official guidance has a long history of self-contradiction. The article walks through async: hand-rolled threads gave way to AsyncTask, which was deprecated into a memory-leak cautionary tale; RxJava's promise of a new mindset turned into debugging nightmares; coroutines then killed the premise that async must be complex by making it a language-level feature. Architecture patterns followed a similar arc: MVC, MVP, MVVM, MVI, and Clean Architecture each had their moment as the prescribed answer, each with its own trade-offs.
The point isn't that any of these technologies were mistakes. They each fit the assumptions of their era. The real pattern is that the industry treats each new official solution as the final word, then abandons it when the next one arrives. In a mature Android project, all these layers coexist, running simultaneously, and none of them is 'wrong.' The author's conclusion is to stop chasing best practices and instead evaluate tools on whether they allow change, support coexistence, and can be replaced.
The history shows that official Android recommendations operate on an endorsement-and-reversal cycle, so treating any of them as a permanent contract is a mistake.
When Google endorses a solution, the engineering community converts it into a form of identity, which makes the next reversal feel like a personal betrayal rather than a normal evolution.
The pattern across async and architecture suggests that the cost of migration is usually carried by developers long before the platform's official position changes, making 'best practice' a lagging indicator.
The churn in Android best practices reads as an inherent property of engineering, not a historical accident: each new framework or architecture is simply the response to whichever problem is current, so yesterday's doctrine was never meant to stick. Telegram's fragment-free codebase keeps that abstraction honest, since the officially blessed stack clearly was not a prerequisite for a large, successful production app.
This is a process of constantly solving problems.
Telegram doesn't use fragments at all.