跪拜 Guibai
← Back to the summary

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.

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.

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:

Until reality educated everyone:

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.

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:

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."

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.

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 Activity first, and worry about it when it runs."

MVC

"Code isn't elegant, but it survives"

MVP

"Decoupled, but also decoupled from the human element"

More interfaces than business logic, more code than requirements.

MVVM

"Looks modern at last"

But reality:

MVI

"Immutable state, everything predictable"

The price:

Clean Architecture

"This isn't architecture, it's a religion"

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

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

"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:

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.

Comments

Top 3 from juejin.cn, machine-translated. The original thread is authoritative.

Android打工仔 2 likes

This is a process of constantly solving problems.

golyu 1 likes

I can relate deeply.

冬天里的Java 1 likes

Telegram doesn't use fragments at all.