Every 'Best Practice' Android Taught You Eventually Gets Overturned
The Collapse of an Android Engineer's Technical Faith
Every Android engineer has, at some point, sincerely believed in "best practices."
We wrote code according to official docs, adjusted our architecture following Google I/O slides, refactored projects again and again, and told ourselves quietly:
"This time, it should be the end."
Later we discovered that Android's "best practices" are more like a "ha."
1. The Starting Point of Faith
"As long as we follow official recommendations, we can't go wrong"
For a long time, Android engineers held a simple consensus:
"Don't mess around, follow the official path."
Because the Android world is too fragmented: devices, systems, vendors, version numbers, all of it drains an engineer's mental energy.
So when the official said "this is the recommended approach," we accepted it almost with gratitude.
Until we found out:
"Official recommendations themselves keep being overturned by the official side."
2. The First Crack in the Native Myth
From Activity to Fragment
Android development's earliest faith came from the native SDK itself.
- Faith: Since Google gave us
Activity, it must be the perfect page container. - Reality: After Fragment appeared, the lifecycle became a black art: "Why does
onSaveInstanceStatestill execute?" "Where is thisIllegalStateExceptioncoming from?"
Fragment didn't solve complexity, it exposed it.
From that moment, many engineers first realized:
Native SDK ≠ Best Practice
3. The Power Shift of Async Tasks
The first true collapse of Android technical faith
If there is one "best practice" that has been repeatedly overturned the earliest, it's async.
Nearly every generation of Android engineers has been personally trained by the official side on "the correct way to do async."
Thread / Handler Era
"As long as you're careful enough, you won't make mistakes"
In early Android, there were no constraints, no guidance.
- Manually writing
Thread - Managing
Handleryourself - Handling thread switching yourself
- Ensuring no leaks, no crashes, no out-of-bounds
Async relied on experience, thread safety on self-discipline.
That was an era of "trading hair for stability."
AsyncTask
"Official says you don't need to worry anymore"
Later the official side stepped up:
"Stop writing threads manually, use
AsyncTask."
It looked like the endgame:
- Automatic thread pool
- Clear callbacks
- Extremely fast to pick up
Until reality educated everyone:
- It barely understands the lifecycle
- Configuration changes hand you a brand-new task
- Memory leaks come as naturally as air
In the end, AsyncTask became a "complete gallery of memory leak examples" and entered Deprecated.
RxJava
"This time, we've really reached the end"
Around 2016–2017, RxJava took the stage.
It promised not just "async," but a new way of thinking.
- Callback hell was flattened
- Operators could be composed infinitely
- Code looked like mathematical formulas
In those years almost everyone said:
"If you don't know RxJava, you're not a qualified Android engineer."
But soon reality started to bite:
- One
flatMapcan cost half an hour of debugging - You don't know which chain the exception came from
- Only one person on the team dares to touch it
This was the first time people began to realize:
Powerful doesn't mean suitable for a team.
Kotlin Coroutines
"We're not changing tools, we're changing cognition"
Coroutines didn't come to "kill RxJava."
What it truly did was something more brutal:
It negated the premise that "async must be complex."
- Sequential code for async logic
- Structured concurrency
- Lifecycle can finally be constrained
Coroutines didn't end the async war, but it changed the direction of the war:
Async should not be a matter of faith; it should be a language-level capability.
The Truth of the Async War
Looking back at this history, you'll find:
No async solution was "wrong." They served different assumptions of their era.
- Thread assumed you were careful enough
- AsyncTask assumed you didn't need control
- RxJava assumed you could handle abstraction
- Coroutines assumed the language could cover for you
What truly collapsed was never the technology itself, but our obsession with "the endgame."
4. The Civil War of Architecture Patterns
MVC → MVP → MVVM → MVI → Clean
Android was once a wasteland with no official architecture advice.
The earliest architecture consensus was only one sentence:
"Just write it in
Activityfirst, and worry about it when it runs."
MVC
"Code isn't elegant, but it survives"
- View and Controller are mixed together
- Business logic lives in
Activity - Lifecycle relies on experience, state on prayer
MVP
"Decoupled, but also decoupled from the human element"
- Presenter takes over logic
- Interfaces abstracted layer by layer
- One feature split into five or six files
More interfaces than business logic, more code than requirements.
MVVM
"Looks modern at last"
- DataBinding + ViewModel
- Official side finally took a clear stance
But reality:
- XML errors read like cryptic messages
- State sources start going out of control
MVI
"Immutable state, everything predictable"
- Unidirectional data flow
- Immutable State
The price:
- Mental load spikes
- Boilerplate code multiplies
Clean Architecture
"This isn't architecture, it's a religion"
- Entity / UseCase / Repository / DataSource
- Boundaries at every layer
- Every line of code is proof: "I haven't been polluted by UI."
The Truth of the Civil War
They were not eliminating each other; they were solving problems at different stages.
5. UI Construction's Self-Denial
XML → Compose
ConstraintLayout- XML makes you question your life
- Everyone adopts
Jetpack Compose
So projects enter an era where View and Compose coexist for a long time.
6. Language and Identity's Backstab
Java → Kotlin → Multi-platform anxiety
- Kotlin First
- Coroutines, DSL, null safety
- Flutter / RN / CMP
"Am I even still an Android engineer?"
7. The Real Moment of Collapse
In the same mature project, all these technologies can coexist simultaneously.
They are all running. None of them is wrong.
What's wrong is only that we once believed there would be an end.
8. So What Should We Believe Now?
Stop believing in "best practices."
What's truly worth trusting is only:
- Whether it allows change
- Whether it supports coexistence
- Whether it can be replaced
Conclusion
The technical faith of Android engineers was not shattered by a single update.
It was slowly broken down in one "this is the last refactor" after another.
In the world of Android, the only skill that never goes stale is the ability to adapt to change.
Top 3 from juejin.cn, machine-translated. The original thread is authoritative.
This is a process of constantly solving problems.
I can relate deeply.
Telegram doesn't use fragments at all.