Today I have very exciting news for my readers and students: I’m launching TechYourChance membership program to build a community of Android developers.

More than five years ago TechYourChance started as my personal scratchpad and gradually evolved into a popular blog about Android development. Then, at the beginning of 2018, I announced that I’ll create a bit of premium content to “offset the costs” of maintaining this project. Reading that announcement today, I can’t stop laughing at myself. If I had known back then what it’ll take, I’d never go down that path. But I didn’t know. So, I struggled enormously, but eventually created my first course. Then the second one and so forth. Today, I have more than 10,000 students on Udemy who love my courses and ask for more. That’s an amazing outcome of my blissful ignorance, followed by a stubborn grind.

To be honest, my dedication to TechYourChance and its success stand in surprising contrast to many failures I’ve had over these years in other areas. For example, if you’d ask me five years ago, there is no way I’d guess that I’ll pour thousands of hours of effort into TechYourChance and it’ll become my most successful project. But that’s exactly what happened, even though I still can’t grasp its full impact and occasionally think about TechYourChance as just my small blog.

Naturally, I’ve been thinking about the future of TechYourChance. In fact, this has been the biggest question on my mind for more than a year.

See, from purely materialistic point of view, for the past year and a half, the best path forward for me was to produce more courses. In other words, money-wise, spending my time freelancing and consulting just didn’t make sense anymore. However, I created just one new course in 2019, and I haven’t created any in 2020 yet. I realized that money on its own isn’t sufficient motivator for me. Therefore, I had to find more important goal if I wanted to take TechYourChance to the next level. Luckily, I think I found it.

However, before I tell you about that big goal and the future of TechYourChance, you need to understand my view of Android ecosystem. It’s not all rainbows and unicorns, to put it mildly. So, you’re about to read some gloom stuff below. I feel kind of sorry to burden you, but this context is absolutely mandatory for this announcement. Therefore, there is no way around this unpleasant topic.

Tough Times for Android Developers

I believe that being an Android developer today is very stressful and high-risk career path. It’s not like it had ever been a walk in the park, but what I observe in Android ecosystem in the past years is just madness.

See, as I wrote at the end of 2019, despite being very active member of Android community, I constantly feel that I can’t keep up with what’s going on. This sentiment is shared by many other experienced Android developers who feel overwhelmed with changes. Not sure how new developers feel, but I’d expect them to just drown in the ocean of new libraries, changing practices and deprecations.

If I try to step back from my personal experience and see the bigger picture, it gets even more discouraging.

Looks like Google is re-architecting Android platform without sharing any long-term vision with us. If that’s even remotely the case, we’re about to experience even higher rate of changes and, consequently, even more stress in the future. In fact, it probably means that whatever “best practices” Google promotes today, many of them will become obsolete or even deprecated by the time “re-architecting of Android” completes. In other words: Android developers are doomed to waste a lot of their time and personal potential in the foreseeable future.

A Sign of the Times: Fear

Three years ago, for the first time in my life, I experienced “Android developer’s fear”. Back then, Google announced official support for Kotlin in Android and I had to decide whether to jump on the hype wagon right away, or wait. This decision was tough.

On the one hand, it was clear that Kotlin’s ecosystem was too immature. On the other hand, there were these fears of making the wrong decision for my clients and being “left behind” professionally. The worst part was that Google never shared any long-term roadmap for either Java or Kotlin in Android, so fully informed decision was not an option. Eventually, I had conducted an extensive analysis and decided (both for myself and my clients) to postpone the adoption of Kotlin. It turned out to be the right decision, but, to be honest, I still doubted it for quite a bit after that.

A bit later it struck me that a lot of developers and managers experienced this same fear. In fact, looks like it’s a major driving force behind Kotlin’s adoption (though not the only one): developers fear to be left behind; managers fear that they’ll have hard time attracting new developers in the future. Gradually, more and more companies decide to just bite the bullet and migrate to Kotlin.

However, it didn’t stop with just Kotlin. The same dynamics took place with various Jetpack libraries.

I should probably mention Jetpack Compose specifically because it’s the freaking Sword of Damocles hanging above our heads for the past year and a half. Google made it very clear that they’re serious about it, but they don’t share Compose’s roadmap with us, so we can’t even plan our actions in advance. The community is in full-reactive mode, waiting for something to happen at some point in the future. Makes me feel sorry for new Android developers who struggle to learn “modern” Android practices and then realize that all that can become legacy in just couple of years.

And then there is the fear that many Android developers are too afraid to even acknowledge: Flutter. Some developers still dismiss Flutter just because it uses Dart, due to its immaturity, because it’s not “native”, etc.. However, at this point, that’s either blissful ignorance or wishful thinking.

You probably know that I like quantitative data, so here is one very disturbing snapshot from StackOverflow Trends:

The above chart shows that Flutter-related searches are already almost 50% as common as Android-related ones, and, furthermore, that Dart already surpassed Kotlin. Sure, there are many legitimate ways to interpret this data, but dismissing Flutter is not one of them.

Given there aren’t that many apps written in Flutter, the abundance of Flutter-related questions on SO is surprising. I suspect that the reason for this is that many developers “try” Flutter in their personal time. You know, just to avoid being left behind if Flutter indeed eats away at Android jobs market in the future. Of course, much of this effort will turn out to be a waste if Flutter won’t fly.

And then there is Fuchsia lurking in the dark. Most developers aren’t concerned about it because Google hasn’t launched it yet. However, if it will launch, we’ll hit new levels of stress and doubts.

Unfortunately, despite all the fears, the uncertainty and the doubts among Android developers, Google don’t step in to help us. In my opinion, it’s just cruel, given they are the ones causing all these adverse effects in the first place.

Truth, Even if it’s Painful

I understand that the picture I’ve drawn above can be discouraging, or even depressing. Not the kind of story which encourages people to join any community at all, let alone pay for it. However, that’s my honest opinion and it has everything to do with TechYourChance going forward.

In the past five years, I’ve always shared with you my professional opinion in straightforward and honest manner, even if I knew that it’ll be seen as controversial. Sometimes, I paid the price for that (both figuratively and literally). However, that’s not something I’m willing to give up. So, you can fully expect this kind of communication going forward.

But just telling you “my truth” isn’t that useful if my opinions turn out to be wrong, isn’t it? So, you should be legitimately concerned with the accuracy of my predictions.

Well, at this point, almost all my opinions and predictions have already turned out to be correct. Even the ones that were seen as extremely controversial, or even nonsensical back in the days. Furthermore, as far as I know, almost none of my predictions turned out to be incorrect.

Accurate Analysis and Predictions

Since the question of accuracy is crucial, general claims like “my predictions turned out to be correct” probably won’t do. Therefore, I want to explicitly review some of the more important opinions and predictions that I’ve shared over the years. My goal here is not to boast, but to show you that I never let my readers and students down.

So, here is the list of my most important opinions and predictions:

• I advocated against DataBinding from the moment it was announced. I predicted that it won’t become mainstream and will eventually become obsolete. DataBinding is pretty much legacy today.
• When Google released ViewModel “architecture component”, I said that it’s unnecessary complex framework which won’t solve any real-world problems, but will create some of its own. Turned out that adding one additional lifecycle doesn’t really make handling of lifecycles easier. In addition, ViewModel turned out to be a disaster in terms of dependency injection (e.g. both Koin and Dagger have special features to handle ViewModel specifically). I also predicted the appearance of the relatively recent SavedState module, long before Google realized a need for it.
• You might remember that alongside ViewModel, Google also released Lifecycle “architecture component”. I said back then that the idea of spreading lifecycle handling over larger area of your code is counter-productive and it’s not something you should do. Well, luckily, this framework never took off in third-party apps. In fact, the only “lifecycle aware component” that got traction, LiveData, turned out to be a failure. It started as a general framework, but Google quickly realized that it’s too limited, so they “restricted” its scope to just UI. Furthermore, looks like LiveData is going to become obsolete relatively soon.
• I’ve probably been the most vocal advocate against dagger.android. The moment I saw this library, I knew it’ll be needlessly complex and will lead to a huge churn. When I created my first course on DI, I intentionally didn’t cover it and told the students to stay away. The recent release of Hilt marked the effective deprecation of dagger.android.
• Speaking of Dagger Hilt, it basically embodies the approach I’ve been recommending for years.
• In the larger context of dependency injection in Android, I predicted that Koin, despite being a nice DI framework and having decent documentation, won’t get much traction in Android world and Dagger will remain the standard. Even though there are developers who use Koin today, my prediction turned out to be correct.
• I predicted the appearance of Jetpack Compose long before Google announced they’re working on it. I also predicted that it’ll target multiple platforms (something that became officially known just recently).
• My second most controversial prediction was that RxJava will turn out to be very bad long-term dependency for Android projects. Very steep learning curve and extra-high degree of coupling, combined with questionable value proposition and lack of official support were doomed to become a liability. Got a lot of heat and even hate for sharing this opinion. Well, as of today, RxJava is dying technology and projects that won’t invest additional effort into refactoring it out will soon have troubles finding developers proficient with it. Maybe they’ll even have troubles finding developers willing to maintain RxJava code at all.

Lastly, I want to discuss my most infamous prediction in details.

In 2017, at the peak of Kotlin hype, I shared my analysis of the risks associated with premature migration to this language. To say that this article was controversial at the time is an understatement. It felt like all hell broke loose. This post earned me the reputation of “that guy who just hates Kotlin” for a long time (this always amazed me, given that in the post I had assumed that Kotlin, as a language, will be better than Java). However, having 20/20 hindsight, that post and, especially, the follow-up discussion in the comments, read totally different. Even today, three years later, Kotlin ecosystem is still relatively immature compared to Java.

Kotlin’s compile times are horrible. The tooling is still inferior and some new features lag behind for months. IDE doesn’t support some basic refactorings, like the ability to move multiple files at once. Code completion is just painfully inaccurate and slow. Kapt is bad and some companies invest major effort to just avoid using it. We know that Kotlin doesn’t magically make codebases more readable (judging by Google’s official examples, it makes bad code even worse). You can still get NPEs in Kotlin (in fact, there are multiple types of NPEs). Over these years, we saw a long list of Kotlin-specific bugs, including some that made AndroidStudio almost unusable (I still occasionally see how it colorizes Kotlin classes in real-time). There was a short wave of interest around functional programming, but it died away pretty quickly. Coroutines turned out to be very complex framework which requires a lot of time to learn.

All the above points are self-evident facts in 2020, but they weren’t back then, as you can easily see by reading the comments from that time.

In fact, I’ve just read the comments again and found something I completely forgot about. One reader asked which language I’d recommend learning to a young person. I answered this:

If you’re a backend developer, then I think that Java is the way to go. Whatever Kotlin fans say, the chances of Kotlin replacing Java for backend development are very low IMHO.
If you’re Android developer and know neither of the languages, then I think that learning Kotlin is the better option right now. Not because it is better in any way (maybe it is, maybe it isn’t), but just because it looks like Kotlin will eventually become the standard language for Android

The prediction about Kotlin in backend turned out to be absolutely correct, but that’s not the interesting part here. It’s the prediction that “Kotlin will eventually become the standard language for Android” that is stunning. Again, in 2020 it’s just a fact, but back then the idea wasn’t even in the air. In 2017 Google just announced support for Kotlin as the second language. It was only in 2019 that they officially said that Kotlin is the “preferred” language going forward. So, I managed to predict even that.

All in all, looks like my analysis and predictions about Kotlin in Android were absolutely spot on. It was much more reasonable take than the hype that surrounded Kotlin at the time. It was also much more informative than the official announcements and marketing by Google.

By the way, remember how Kotlin enthusiasts claimed that if you don’t learn Kotlin ASAP, you’ll be left behind? Well, I started to use Kotlin professionally only in 2019 and even today most of my work is in Java. Except for Coroutines, I’d describe my Kotlin chops as average at best. I don’t feel like I’m “behind” in any way and am confident that I can get decent full-time job even at Kotlin-only shop if I’ll need to. So, I tested these claims on myself, and they turned out to be just fear-mongering. As I always said, knowledge of any specific programming language is the lowest-level skill. It’s important for new developers who don’t have anything else to show, but becomes less and less important as you actually do stuff and gain real experience.

In general, if you took my advice over the past couple of years, you probably spared yourself months of effort you’d otherwise spend learning and implementing unfortunate solutions. In addition, you probably spared your company a lot of money. Depending on the size of the project, the number of developers and other factors, we can be talking anywhere from thousands to hundreds of thousands of dollars here.

By the way, if you used some of the aforementioned techs in the past, or even use them today, then you might feel uncomfortable, or even offended by the above discussion. Please don’t. First of all, we all do mistakes. That’s just part of the growth process. Second, it’s not really your fault. When Google recommends something, or when prominent conference speakers explain how great some new tech is, it’s very hard not to buy in. Especially if you don’t have many years of experience yourself. And, lastly, it’s my fault too. I surely could do much better job articulating my concerns and warning Android developers about the potential pitfalls.

The New Mission of TechYourChance

Alright, after the longest introduction in the history of launch announcements, let’s get to the point. The new mission of TechYourChance consists of the several pillars described below.

First and foremost, TechYourChance will continue to serve as the source of the most accurate information about Android development ecosystem. I’ll make sure to share more of my opinions, analysis and concerns with Android developers worldwide.

In addition, I’m launching TechYourChance premium membership program. TechYourChance members will get access to all my existing and future video courses. These courses are already the most advanced resources about Android development, but I intend to increase their depth and quality even further. My goal with video courses is to enable TechYourChance members to master the most beneficial techniques in the shortest amount of time.

That said, access to all video courses is just one of the benefits of TechYourChance membership. My longer-term goal is to create strong and warm community of professional Android developers. This community will be centered around professionalism, career development and personal achievements. Since every community needs a place to meet (even if just a virtual one), TechYourChance members will be invited to a closed community forum.

Now, I’m not naive and realize that building a community will take months of hard work. Therefore, initially, the forum will mainly serve as Q&A section for courses. That’s alright because community needs to start somewhere. Eventually, enthusiastic members will start asking more general questions, will share their opinions and show new members around, and the community will crystallize.

Lastly, if the worst doomsday scenarios about Android ecosystem will come true, TechYourChance community will weather the storm together, minimizing personal waste and business risks at every opportunity. I know all of this sounds improbable and even conspiratorial at this point, but I keep asking myself “what if it’ll happen and I’ve been standing aside for all this time?”. So, I’ll carry this responsibility going forward. If I’m wrong, it’ll become just a waste of my personal time that I’ll spend on monitoring the situation. TechYourChance members will still get the most advanced content about Android development and a community of professionals around them.

Summary

Alright, that’s it. I’m super excited about the future of TechYourChance project and can’t wait to kick it into high gear with community building.

By the way, if you don’t feel like becoming TechYourChance member right now, that’s totally fine. You’ll still see much more quality content going forward because that’s the best way to spread the word about the new community. And then, after the community will emerge and mature, I hope you’ll consider joining us once again.

To get your TechYourChance membership right now, go here.

[Edit: I’ve got a question from a loyal student who already took all my courses and wondered whether enrolling for the membership at this point is worthwhile. I can’t answer this question for you, but I do want to provide a bit more information about the new courses that will be released in the short-term. Hopefully, it’ll help you make informed decision.
Later this week, I’ll release a new course about Dependency Injection and Dagger that I’ve been working on for the past three months. My previous course was 2.5 hours in length. The new one is more than 10 hours, so it’s “a bit” more comprehensive. This course shows Kotlin exclusively. It also covers Dagger Hilt.
The topic of the next course will be decided in collaboration with TechYourChance members. Currently, Coroutines lead in this race. If you decide to join us, don’t forget to cast your vote ;)]

As always, thank you for reading and good luck to all of us!

P.S. If I might, I want to ask you about small favor. If over the years my content was helpful to you in making the right decision, or you learned something useful from my courses, or I managed to spare you time and headache in any other way, please write a short comment about that experience below. It’s called “social proof” – potential future TechYourChance members will see testimonials from other developers and get a clearer picture of what’s on the table. Thank you in advance!