Over the past few months, I've been fully immersed in research and development for our exciting new mobile project. Throughout this journey, I've engaged in discussions with mobile engineers from different companies, and one recurring theme caught my attention: the abundance of suggestions to adopt new tools, frameworks, and trends, sometimes without a clear need.

"It was discussed at a conference."

"Some interesting statistics about it were published in a Medium post."

"A verified account tweeted about it."

"One of the FAANG companies is encouraging developers to use it."

"If you don't use this tech, developers may not be attracted to join your team."

Before we dive into this topic, let's shift our perspective. Instead of criticizing this hype driven behavior, let's approach it from a different perspective.

A Popular but Flawed Decision

A few years ago, the RxJava framework was all the rage in Android development. It seemed like everyone was using it, and there was considerable hype surrounding its benefits. It was praised in every conference, numerous blog posts were written about its features and advantages, and there were plenty of sample projects on GitHub encouraging the community to use it.

However, as time passed, I noticed a decline in its popularity. Looking at Google Trends and Stack Overflow statistics, it became apparent to me that RxJava was slowly becoming a legacy dependency.

Let's take a journey through time and explore the Interest over time chart. Back in the early days of 2017, the keywords "RxJava," "RxJava2," and "RxAndroid" were gaining immense popularity in Google searches, reaching their peak. It seemed like everyone was curious about the RxJava framework family, including RxJava2 and RxAndroid.

But as time went on, the excitement gradually faded, and these once-high-flying keywords experienced a notable decline in interest. RxJava, in particular, faced a significant drop, losing around 75% of its former popularity.

Examining the Stack Overflow statistics, the numbers tell a clear story: the interest in RxJava has dwindled significantly. This trend suggests that developers are gradually moving away from using RxJava in their projects. While we can't definitively declare RxJava as completely obsolete, the signs of decline are strong enough to make us reconsider its future usage.

You might be wondering what happened in 2017. Ah, the turning point in the Android world arrived that year - the emergence of Kotlin! Google's official support for this language was a game-changer, and developers quickly embraced it.

But, as the story goes, this was not the only factor impacting RxJava's fate. In my opinion RxJava faced its own set of challenges. Its steep learning curve and a rather complex API made it less approachable, especially when compared to the elegance of flow and Kotlin coroutines. Moreover, it delved into the realms of Reactive Programming and Multithreading, which lead to violations of the Single Responsibility Principle.

In retrospect, considering all these factors, it's not surprising that RxJava's destiny became evident. The tech landscape is ever-evolving, and the emergence of a more developer-friendly language like Kotlin naturally led to some shifting preferences in the Android community.

Suppose you are a mobile team leader back in 2017

Put yourself in the shoes of a mobile team leader during the peak popularity of RxJava, you find yourself facing a critical decision. Developer's community is enthusiastic about using this framework, pointing to its widespread adoption and fearing that not using it might make it difficult to attract developers to join your team.

With these considerations in mind, you take the plunge and decide to integrate RxJava into your big project. However, since RxJava is a framework once it sets foot in your codebase, it tends to spread like wildfire, making it challenging to contain its influence, even reaching your tests.

Fast forward a few months, and a new trend has emerged in the tech world, capturing everyone's attention. Blog posts and tweets about this fresh tool create a buzz, hinting at a new trend on the rise. But here's the twist - your project is already entwined with RxJava. The thought of migrating away from it now feels like a monumental task, far from a simple switch.

As your team members suggest migration, you weigh the options carefully. But limited budget and time constraints hold you back from embracing this change wholeheartedly. It's a tough situation to be in, caught between the desire to adopt new technology and the practicality of staying on course.

Adding to the complexity, you realize that new developers are showing less interest in joining your team as they may not be familiar with RxJava. The shine of RxJava, which once attracted talents, has lost some of its luster, making recruitment a bit more challenging.

You can't help but reflect on your initial concerns when you first considered using RxJava. Those worries have now become a reality, and you find yourself navigating through a maze of unanticipated challenges.

Avoiding Regrettable Decisions

Most bad decisions have one thing in common: unexpected challenges arise.

There are things we know and understand, called "known knowns".

There are things we know about but don't understand, called "known unknowns".

There are things we understand but are not aware of, called "unknown knowns".

And finally, there are things we are not aware of nor understand, called "Unknown Unknowns" or "blind spot".

As leaders, it's essential to recognize that we can't possibly foresee every blind spot. It's not a flaw; it's just part of being human. The key to making sound decisions lies in acknowledging this reality and taking proactive steps.

The first step is to reach out to others who have faced similar decisions. Their experiences can be like treasure troves of wisdom, filled with insights that we might never have stumbled upon on our own. By engaging in open conversations and listening to their stories, we can learn valuable lessons and broaden our perspective.

It's equally crucial to welcome different opinions, even those that challenge our own ideas. Sometimes, these dissenting voices can unveil hidden truths, illuminating aspects we might have missed or overlooked. Embracing diverse viewpoints enriches our decision-making process and leads to more well-rounded choices.

When we encounter major decisions, it's like standing at a crossroads. To gain confidence in our chosen path, we should subject our ideas to thorough testing, especially by those who might think they won't work. This might feel like a daunting challenge, but it's a powerful way to uncover what we didn't know before. Embracing the feedback, both positive and negative, helps us navigate the uncertainties with greater assurance.

In the end, leadership is not about having all the answers, but rather about seeking the best solutions through collaboration, learning, and humility. Together, we can chart a course towards success, even amidst the vast unknowns that lie ahead.

Tried and True Solutions

As we navigate the vast sea of technology options, it's crucial to anchor ourselves to choices that are "Tried and True". Opting for tech stacks that are standard, well understood, and reliable gives us a solid footing to build upon. These are the technologies that have stood the test of time and earned their place in the community over the years.

When we build softwares, we're essentially crafting solutions to real-world business problems. Each decision we make, be it about languages, tools, frameworks, architectures, or algorithms, shapes the map of our journey. That's why it's vital to deeply understand these choices, not only their strengths but also their weaknesses and potential pitfalls. Such knowledge empowers us to make informed decisions and navigate challenges with confidence.

In a world where buzzwords and trends abound, it's tempting to be swayed by the excitement of the latest and greatest. However, we should be cautious about making decisions based solely on hype. Relying too much on fleeting trends can create blind spots, leaving us vulnerable to unforeseen obstacles that may arise.

For me, I find comfort in leaning towards tried and true solutions. They offer a level of stability and reliability that aligns well with achieving our project goals. But I also recognize that decisions don't happen in isolation. Each choice we make has a ripple effect, impacting not only our team but the entire company.

Moving forward with a small tech stack is a fascinating challenge. By choosing essential tools wisely and encouraging creativity, we can achieve impressive results and build a strong foundation for future growth.

In the end, technology is a tool, and our choices should be guided by the needs of our team and the vision we have for our projects. By staying grounded in tried and true solutions while being open to innovation, we can chart a course towards a bright and prosperous future.

Conclusion

In conclusion, it is important for team leaders to make decisions based on a thorough understanding of the technologies and trends they are considering. While new tools and frameworks may seem enticing, it is crucial to carefully evaluate their long-term viability and potential drawbacks. Blindly following trends can lead to challenges and difficulties down the line. By seeking advice from experienced individuals, considering different perspectives, and prioritizing tried and true solutions, leaders can make more informed decisions that benefit their team and the overall success of their projects and company. It is essential to strike a balance between embracing innovation and relying on reliable technologies to ensure the best outcomes.