DEV Community: Ishan Khanna

Mastering The Gradle Dependency Tree

Ishan Khanna — Wed, 11 Jan 2023 23:09:51 +0000

The Gradle dependency tree is the backbone of your Gradle builds. Its representation can help you visualize the structure of all of the gradle dependencies in a project, as well as any transitive dependencies. Not so long ago I wrote a Twitter thread sharing some tips to debug your slow Gradle builds which led me into the journey of diving deeper into this topic.

This is a great question to refresh and revise what I have learned over the years from my ex-colleagues especially @inyaki_mwc & @jperezalv

I'll try to summarize what usual suspects I can recall in the 🧵 https://t.co/lgZDmeIKTn

— Ishan Khanna (@droidchef) November 17, 2022

In this article, I discuss

What are dependencies and transitive dependencies in Gradle?
What is a dependency tree in Gradle?
What are the different dependency configurations in Gradle?
Five ways to generate a dependency tree in your Gradle project.

By reading the whole article, you will

have a solid understanding of Gradle dependency tree
be equipped with the knowledge to generate a Gradle dependency tree using different ways for any project.

Let's get started by covering some basics.

What is a Dependency in Gradle?

A dependency in Gradle is a relationship between two elements that allow one to access the content, resources, or libraries of the other element. It can be between modules within a project or external dependencies from external sources such as Maven Central and JCenter.

A Gradle dependency establishes an association between the two elements by specifying the version of the dependency being used. When Gradle constructs a dependency tree, it takes into account both transitive and direct dependencies.

What is a Transitive Dependency in Gradle?

A transitive dependency in Gradle is a dependency that is implied by another dependency and thus pulled into the project from an external source.

Transitive dependencies are resolved using the version of the library declared by the original dependency, and all of them for that library is then included in your project.

This can lead to unnecessary bloat in your projects if you are not careful about managing your gradle dependencies.

Different Types of Transitive Dependencies

They can be both direct and indirect ; for example, if you declare a direct dependency on Library A, which has a transitive dependency on Library B, you will also end up with Library B included as a transitive dependency in your project.

🧠

Transitive dependencies can become complex when multiple modules have different versions of the same library; Gradle will attempt to resolve this by picking the newest version available.

It is important to manage these various versions carefully to avoid conflicts or other unexpected behavior in your project.

Configuring Gradle Dependencies in a Gradle Project

Gradle allows us the ability to group dependencies by specifying a dependency configuration. You may have seen words like implementation, androidTestImplementation or testImplementation in your project’s build.gradle files.

By default, a Gradle build doesn’t support any dependency configuration however they integrate with your build via plugins such as the Android plugin, Kotlin Plugin, or the Java Plugin.

These configurations are used by Gradle to generate classpaths for building project for production or testing.

It is important to know this before you generate your dependency tree as you might start wondering why are there multiple configurations in your build.

With the basics out of the way, now it is time to actually start generating the dependency tree.

Generating A Gradle Dependency Tree

There are five ways to generate the Gradle dependencies. The quickest way is to use the dependencies task. However, it may not always be suitable or give you the best results. So we will walk through all the different ways you can generate and visualize it.

“I personally don’t use or recommend using Android Studio for anything other than writing code, especially if you are working on a relatively large code base. However, I still do talk about it for anyone feeling adventurous.”

Prerequisite

If you would like to follow the commands I run in the sections below. You can set up a lightweight sample project I created to demonstrate the impact of dependency tree depth on your gradle builds by completing the steps below.

Open your Terminal and Go to the directory where you save your projects, for me, it is ~/dev/

cd ~/dev/

Clone a sample root project like this

git clone git@github.com:droidchef/dep-height-example.git

Change the directory to the root project like this

cd dep-height-example

Now you are ready to run all the commands mentioned in the steps below.

1. Using Dependencies Task in Command Line

The easiest way to generate a dependency tree for your project is to run the dependencies task at the root of your project and here is how you do it.

In your terminal, Go to the root directory of your application and Run the following on the command line

./gradlew :{moduleName}:dependencies

Here {moduleName} should be replaced with the name of the module you want to want to view the dependency tree for.

The sample which is a multi-module project has a module named contractor and I will try to list the gradle dependencies for it by running the following

./gradlew :contractor:dependencies

Here is what the output looks like

As you can see, the output of the dependencies task is extremely verbose as it contains results for all configurations, classPaths, elements, and their respective metadata.

Fortunately, our amazing colleagues at Gradle have provided us with a mechanism to control the result to only show specific types of configurations and this is what you will be using most of the time during your investigations.

How to filter dependencies by configuration?

You can use the configuration parameter with the dependencies task in Gradle to view dependencies for a specific configuration type.

This is how you would construct your gradle task

./gradlew :{yourModuleName}:dependencies --configuration {yourConfigurationName}

Here is an example showing implementation dependencies for the contractor module of the sample multi-module project

./gradlew :contractor:dependencies --configuration implementation

Here is the example result

List of Supported Parameters for Configuration Task

The configuration parameter supports the following inputs

compile
testCompile
implementation
testImplementation

If your root project is an Android project then you also have access to these along with the above-mentioned inputs

androidTestCompile
androidTestImplementation

Here are the examples showing how you can use the above parameters

./gradlew :{moduleName}:dependencies --configuration compile
./gradlew :{moduleName}:dependencies --configuration testCompile
./gradlew :{moduleName}:dependencies --configuration testImplementation
./gradlew :{moduleName}:dependencies --configuration androidTestCompile
./gradlew :{moduleName}:dependencies --configuration androidTestImplementation

2. Using Project Report Plugin

If you have a large project or a small screen you can also generate the dependencies report using a plugin. The plugin is called The Project Report Plugin. It will give you an HTML-based dependencies report that allows you to browse the whole dependency tree in your favorite browser.

It is extremely easy to set up and here is how you do it.

How to Integrate Project Report Plugin?

Open the build.gradle file in the root directory of your project.
Add this to the top of the file

apply plugin: 'project-report'

plugins {
    id 'project-report'
}

Sync the Project in your IDE ( Optional )
Run the following command in your terminal

./gradlew htmlDependencyReport

Open the HTML Report generated by Gradle. The file path is usually {project root}/build/reports/project/dependencies/index.html where {project root} refers to the root directory of your project.

You can also Command (or Cmd) ⌘ + Click on this file:// path and it should open in your browser.

When you open this report you will see the project for which the report was generated.

Click on the root project URL to see the searchable dependency report

Click different dependency configurations to view the report in detail.

3. Using Gradle Dependency Graph Generator Plugin

Now if you are really interested in digging deep into your project’s dependency structure. There exists a third-party Gradle plugin that is built primarily for this purpose. I personally find it useful when dealing with modularization or if I want a glance at the whole dependency tree at once.

It is called gradle-dependency-graph-generator-plugin , developed and maintained by Niklas Baudy.

You can use it to generate a visual graph for your project’s dependencies in formats like png, SVG, and dot.

How to Integrate Gradle Dependency Graph Generator Plugin?

Open the build.gradle file of your root project

You can also add it to a specific project or module and it will work fine

Add the following to the Gradle file.

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "com.vanniktech:gradle-dependency-graph-generator-plugin:0.8.0"
  }
}

apply plugin: "com.vanniktech.dependency.graph.generator"

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "com.vanniktech:gradle-dependency-graph-generator-plugin:0.8.0"
  }
}

plugins {
 id 'com.vanniktech.dependency.graph.generator' version '0.8.0'
}

Sync with gradle in your IDE and Run this task in your terminal

./gradlew generateDependencyGraph

This will generate the gradle dependencies graph in this directory build/reports/dependency-graph/ that looks like this.

4. Using Gradle Build Scan

Gradle build scans are like an X-ray for your Gradle and Maven builds.

If you are using build scans in your Gradle project. You get access to the project dependencies for free. If you have never generated a Gradle build scan before, you can generate one right now for free in under two minutes.

The only thing you need is the --scan parameter at the end of any Gradle command you run in your terminal.

Let’s use a simple command to list the tasks of the project to generate a build scan.

Go ahead and run this command in the root directory of your project.

./gradlew tasks --scan

Once the build ends, you will be prompted for a confirmation to generate the build scan. This is because Gradle will be collecting build information and information about your hardware and sending it to their servers.

If you are okay with this, type yes and hit Enter.

Then you’ll see a link to your personal build scan access page in your terminal.

Open that URL in your browser and this is what you will see.

Now to get information about your dependencies click on the Dependencies item in the left menu navigation menu.

This will show you an interactive searchable dependency report in which

You can search for dependencies.
You can see dependencies for different configurations.
You can find out which library or module or project uses this dependency.
You can even see which repository they come from.

In addition to this, there is a lot more information you have access to in this build scan report. However, this is out of the scope of this article.

Finally, let’s look at the most straightforward way to generate the dependency tree for your project using android studio.

5. Using Android Studio's Gradle Plugin

You can use Android Studio’s Gradle plugin to generate and view the structure of gradle dependencies. This might seem like the easiest way. However, I do not recommend this for large-scale projects since it can slow you down significantly. This is the reason, I am discussing this approach as the last one.

How to generate Gradle Dependency Tree with Android Studio?

First open your Android Studio and Click on the Gradle Tab.

For an Android Project Then expand :yourmodule -> Tasks -> android . Finally, double click on androidDependencies to execute the task.
For a Java or Kotlin Project Then expand :yourmodule -> Tasks -> help . Finally, double click on dependencies to execute the task.

Android Studio Showing Dependency Generation Task in Gradle Project

After this task finishes executing it will print the whole dependency tree report in the console of Android Studio.

Output of Dependencies Task in Android Studio Console.

What are Omitted Dependencies?

You might have come accross a message in the output that says

(*) - dependencies omitted (listed previously)

It means gradle removes duplicate sections from your dependencie tree to keep the output concise. It doesn't actually affect your real dependency graph.

What are Failed Dependencies?

In the output of your dependency tree if any dependency is marked as FAILED then it means that Gradle could not locate it in any of your configured repositories.

It could be due to many reasons including but not limited to:

Incorrect versioning
Connectivity Issues
Proxy Concerns on your machine
Misspelled dependency name

What is Dependency Configuration Inheritance?

As you might have seen in the screenshots above Dependency Configurations support inheritance. When a dependency configuration inherits from another configuration, it automatically gets access to all the dependencies of its parent.

For example, consider an Android project. The app's build.gradle file will have its own dependencies, such as the Android Support Library and any third-party libraries that the project uses.

However, these dependencies can also be inherited from other scopes, such as a library module or even your organization’s internal repository of pre-packaged libraries. This allows you to easily keep your project up-to-date with the latest libraries and also simplifies maintenance.

Gradle dependency configuration inheritance makes it easy to manage complex projects and keep them organized.

Conclusion

By reading this post, you should now have a solid understanding of Gradle dependency tree and are now equipped with the knowledge to generate a Gradle dependency tree using different ways for any project. Please share this article on LinkedIn and Twitter.

If you have any doubts regarding this, feel free to leave a comment below!

Flutter vs Jetpack Compose: The Battle of the Decade

Ishan Khanna — Wed, 16 Nov 2022 03:38:11 +0000

Introduction

In the blue corner, we have Flutter. In the red corner, we have Jetpack Compose. These two titans have been locked in an epic struggle for supremacy ever since Google first announced Jetpack Compose in 2018. But who will come out on top? Let's find out!

The Blade Runner Scenario

In the original Blade Runner movie from 1982, humanity has developed a form of synthetically-created life that is so realistic, it's difficult to tell them apart from humans. These "replicants" are used for dangerous or otherwise undesirable jobs, and when they start rebelling against their human masters, a special type of police officer known as a "blade runner" is tasked with hunting them down and retiring them.

Similarly, in the world of mobile app development, there are two types of developers: those who use Flutter, and those who use Jetpack Compose. When Google first announced Jetpack Compose, many thought it would be the end of Flutter. After all, why use a cross-platform framework when you can just use the native tools provided by Google?

But just like the replicants in Blade Runner, Flutter refused to go down without a fight. And in the two years since Jetpack Compose was first announced, Flutter has only become more popular. So what gives? Let's pit these two frameworks against each other in a head-to-head battle to see which one comes out on top.

Language

Flutter uses Dart—an object-oriented language created by Google—while Jetpack Compose uses Kotlin, a statically typed programming language created by JetBrains. Both languages have their pros and cons, but we're going to give this round to Dart because it is easier to learn for beginners and because it performs better than Kotlin when it comes to runtime speed and memory usage.

I personally found Dart easier to learn when I was Flirting with Flutter at Getaround a few years back.

Community Support

When it comes to community support, there is no clear winner when comparing Flutter vs Jetpack compose.

Flutter has a large and active community of developers who are constantly creating new plugins, sharing tips and tricks, and helping each other out. Jetpack Compose also has a strong community of developers, although it is not quite as large as the Flutter community.

However, what Jetpack Compose lacks in community size, it makes up for in quality—the Jetpack Compose team is very responsive to issues raised on the GitHub repository and they are always working on new features and improvements.

One surprising thing I found during my research was that when you compare the trends for both frameworks on Stackoverflow, Jetpack Compose is nowhere close to Flutter.

Comparison of % of Flutter vs Jetpack Compose Stack Overflow questions monthly (as of November 11, 2022)

I believe this because Flutter works cross platform and so often times people are just looking for the same thing on multiple platforms and that contributes significantly to the question bank.

Documentation and Resources

Both Flutter and Jetpack Compose have excellent documentation that is easy to follow and packed with plenty of code examples. In addition, both frameworks have a wealth of resources available online, including video tutorials, blog posts, articles, and more. We're going to call this one a tie.

Ease of Use

Jetpack Compose wins this round hands down. While both frameworks are relatively easy to use, Jetpack Compose takes the cake when it comes to ease of use thanks to its declarative UI approach.

This means that you can build your UI using simple Kotlin code instead of having to worry about all the underlying complexity.

I know and understand that Flutter is also declarative, however it is not straightforward to access OS-level components directly without a bridging logic.

Build Systems

Flutter uses its own custom Dart tooling to compile code ahead-of-time into native ARM assembly code for iOS and Android.

On the other hand, Jetpack Compose uses the standard Kotlin compiler to build your app's UI.

A misconception I had for a long time was that @Composable uses an annotation processor, which is NOT true!

Compose works with the aid of a Kotlin compiler plugin in the type checking and code generation phases of Kotlin: there is no annotation processor needed in order to use compose. – Under the hood of Jetpack Compose — part 2 of 2 by Leland Richardson

When comparing the addition of Flutter vs Jetpack Compose to existing applications, both bring a significant warm-up overhead and slow down the app that isn't entirely built with them.

Marketing & Brand Perception

To better understand how teams at Google are supporting their respective frameworks I found that they aren't leaving any stone unturned to attract developers.

Marketing

When comparing the marketing of Flutter vs Jetpack Compose both teams have their ads running on Google.

Flutter vs Jetpack Compose Google Ads Comparison

Search Trends

I also compared search trends for Flutter vs Jetpack and the results are quite shocking.

The search interest for Flutter is almost double that of Compose as you can see in the image below.

Comparison of Google Search Trends for Flutter vs Jetpack Compose

In fact, you can even compare the breakdown by region to see developers in which countries are heavily invested in Flutter vs Jetpack Compose.

Excluding Canada, France, Spain, and the Philippines, Flutter dominates the search trends all over the world.

Google Search Trends for Flutter vs Jetpack Compose by Region

Frankly, I am surprised to see this result given how the brand perception and adoption feels like in the industry based on social media.

Adoption

In order to understand how companies and individuals are perceiving the benefits, ease of use, and impact of Jetpack Compose for their Android projects I used a proxy metric to see how many talks were presented at Droidcon(s) in the last five years about both the topics and the results looked like this.

To plot the charts above, I looked at all the videos posted on Droidcon.com and looked for specific keywords in their titles. The keywords I looked for in the beginning were "Flutter" and "Jetpack Compose" and it resulted in the chart on the left-hand side.

However, I realized a lot of talks used the word "Compose" in their title and so I ran my analysis again to find an astounding result that shows how popular "Compose" has been at Droidcon events in the last few years with the interest only growing over time.

I know Flutter community organises their own separate events as well so this might not feel like an apples to apples comparison but it serves as a decent data point to predict the trends and inclination of the Android community at the very least.

Flutter vs Jetpack Compose: A Developer's Perspective

As a developer who has used both frameworks, I can say without hesitation that Jetpack Compose is a joy to use. It's so much easier to create beautiful user interfaces with Jetpack Compose than it is with Flutter—and that's not even taking into account the fact that you can also use Kotlin instead of Dart with Jetpack Compose (although Dart is a perfectly fine language).

However, there are still some things that Flutter does better than Jetpack Compose. For one thing, the hot reload feature in Flutter is indispensable when you're trying to rapidly prototype an app idea. And although Jetpack Compose has made great strides in recent months, it's tooling still isn't quite as good as Flutter's—which is something that Google will need to address if it wants Jetpack Compose to truly succeed.

Conclusion

So there you have it—a head-to-head comparison of Flutter and Jetpack Compose. While both frameworks have their own strengths and weaknesses, we think that overall Jetpack Compose comes out on top thanks to its ease of use and strong community support. However, ultimately the best framework for you will depend on your own specific needs and preferences.

Four Ways to Remove Duplicates From an Array in Kotlin

Ishan Khanna — Sun, 23 Oct 2022 02:29:26 +0000

Introduction

There are a few ways to remove duplicates from an array in kotlin:

Using the toSet() function
Using the toHashSet() function
Using the toMutableSet() function
Using the distinct() function

To understand the usage of each function let us consider the following example:

You have a data class called Node:

data class Node(val id: Int, val fullyQualifiedName: String)

and, an array of Nodes:

val nodes = arrayOf(
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(2, "dev.droidchef.usecase.DeleteAllNodes"),
    Node(3, "dev.droidchef.usecase.SetAllNodes"),
    Node(4, "dev.droidchef.usecase.GetAllNodes"),
    Node(5, "dev.droidchef.usecase.WipeAllNodes")
)

Using the toSet() function

This function will create a new Set (which is a data structure that doesn't allow duplicate entries) from the given array. This is the simplest and the best way to remove duplicates from an array in kotlin.

Points To Remember

Return type of toSet() is a Set<T>
Internally it calls toCollection()
It guarantees the preservation of the iteration order of the elements.

Code Sample

data class Node(val id: Int, val fullyQualifiedName: String)

val nodes = arrayOf(
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(2, "dev.droidchef.usecase.DeleteAllNodes"),
    Node(3, "dev.droidchef.usecase.SetAllNodes"),
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(4, "dev.droidchef.usecase.WipeAllNodes")
)

val deDupedNodes = nodes.toSet()
deDupedNodes.forEach {
    println(it)
}

Code Output

Node(id=1, fullyQualifiedName=dev.droidchef.usecase.GetAllNodes)
Node(id=2, fullyQualifiedName=dev.droidchef.usecase.DeleteAllNodes)
Node(id=3, fullyQualifiedName=dev.droidchef.usecase.SetAllNodes)
Node(id=4, fullyQualifiedName=dev.droidchef.usecase.WipeAllNodes)

Using the toHashSet() function

This function will create a new HashSet (which is a data structure that doesn't allow duplicate entries) from the given array.

Points To Remember

Return type of toHashSet() is a HashSet<T>
Internally it calls toCollection()
It does not guarantee the preservation of the iteration order of the elements.

Code Sample

data class Node(val id: Int, val fullyQualifiedName: String)

val nodes = arrayOf(
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(2, "dev.droidchef.usecase.DeleteAllNodes"),
    Node(3, "dev.droidchef.usecase.SetAllNodes"),
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(4, "dev.droidchef.usecase.WipeAllNodes")
)

val deDupedNodes = nodes.toHashSet()
deDupedNodes.forEach {
    println(it)
}

Code Output

Node(id=1, fullyQualifiedName=dev.droidchef.usecase.GetAllNodes)
Node(id=2, fullyQualifiedName=dev.droidchef.usecase.DeleteAllNodes)
Node(id=3, fullyQualifiedName=dev.droidchef.usecase.SetAllNodes)
Node(id=4, fullyQualifiedName=dev.droidchef.usecase.WipeAllNodes)

Using the toMutableSet() function

This function will create a new MutableSet (which is a data structure that doesn't allow duplicate entries) from the given array.

Points To Remember

Return type of toMutableSet() is a MutableSet<T>
Internally it calls toCollection()
It preserves the iteration order of the elements as it uses LinkedHashSet<T> implementation of a MutableSet<T>

Code Sample

data class Node(val id: Int, val fullyQualifiedName: String)

val nodes = arrayOf(
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(2, "dev.droidchef.usecase.DeleteAllNodes"),
    Node(3, "dev.droidchef.usecase.SetAllNodes"),
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(4, "dev.droidchef.usecase.WipeAllNodes")
)

val deDupedNodes = nodes.toMutableSet()
deDupedNodes.forEach {
    println(it)
}

Code Output

Node(id=1, fullyQualifiedName=dev.droidchef.usecase.GetAllNodes)
Node(id=2, fullyQualifiedName=dev.droidchef.usecase.DeleteAllNodes)
Node(id=3, fullyQualifiedName=dev.droidchef.usecase.SetAllNodes)
Node(id=4, fullyQualifiedName=dev.droidchef.usecase.WipeAllNodes)

Using the distinct() function

This function will return a new array that contains only the unique elements from the given array. This is the most flexible way to remove duplicates, as you can still use the original array if you need to. However, it is not the most efficient one.

Points To Remember

Return type of distinct() is an Array
Internally it calls toMutableSet() followed by toList()
Only use this if you want your return type to be an Array.
It does not guarantee the preservation of the iteration order of the elements.

Code Sample

data class Node(val id: Int, val fullyQualifiedName: String)

val nodes = arrayOf(
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(2, "dev.droidchef.usecase.DeleteAllNodes"),
    Node(3, "dev.droidchef.usecase.SetAllNodes"),
    Node(1, "dev.droidchef.usecase.GetAllNodes"),
    Node(4, "dev.droidchef.usecase.WipeAllNodes")
)

val deDupedNodes = nodes.distinct()
deDupedNodes.forEach {
    println(it)
}

Code Output

Node(id=1, fullyQualifiedName=dev.droidchef.usecase.GetAllNodes)
Node(id=2, fullyQualifiedName=dev.droidchef.usecase.DeleteAllNodes)
Node(id=3, fullyQualifiedName=dev.droidchef.usecase.SetAllNodes)
Node(id=4, fullyQualifiedName=dev.droidchef.usecase.WipeAllNodes)

Challenges with Removing Duplicates from An Array in Kotlin

One of the common challenges people have when trying to remove duplicates from an array is not knowing which method to use. There are a few different ways to do it, and each has its own benefits and drawbacks. Another challenge is efficiency - if you're working with a large array, you need to make sure that the method you're using is efficient enough to handle it. Otherwise, you could end up with a very slow process.

Conclusion

There are a few different ways to remove duplicates from an array in kotlin, each with its own benefits and drawbacks. The best way to choose which method to use depends on your specific needs. If you're working with a large array, you need to make sure that the method you're using is efficient enough to handle it.

Frequently Asked Questions

Q: What is the best way to remove duplicates from an array in kotlin?

A: The best way to remove duplicates from an array in kotlin is to use the toSet() method if you don't mind working with a Set<T> and it also preserves the iteration order. If you don't care about the order and only want to have an Array<T> as the return type then you should use distinct()

Q: What are some of the challenges people face when trying to remove duplicates from an array?

A: Some of the challenges people face when trying to remove duplicates from an array include not knowing which method to use and efficiency. If you're working with a large array, you need to make sure that the method you're using is efficient enough to handle it.

Q: What is the most efficient way to remove duplicates from an array in kotlin?

A: The most efficient way to remove duplicates from an array in kotlin is to use the toSetOf() function. This function will create a new Set<T> (which is a data structure that doesn't allow duplicate entries) from the given array. It uses a hashing algorithm to store the elements in the set, so it's very efficient.

Don't forget to checkout my website for more tutorials about Android & Kotlin Tutorials and Mobile Career Development Tips.

Five Costs Engineers Don’t Know About Breaking A Critical Path In The App

Ishan Khanna — Sat, 22 Oct 2022 05:12:08 +0000

Introduction

When you break an app in production, the first thing leaders are interested to know is the estimated impact.

The impact is what largely decides what course of action you take thereafter. If you perform retrospectives or postmortems you’d try to be more accurate with your estimates, however, based on my personal experience, most developers fail to see impact beyond direct revenue or crashes.

In this post, I will discuss five different types of costs you incur when you break an app in production.

The five types of costs associated with breaking a flow in your app are:

Explicit Loss of Revenue
Collateral Damage to the Business
Cost of Investigation
Cost of Fixing
Cost of Remediation

Let’s look at each one of them in a little more detail.

Cost 1: Explicit Loss of Revenue

When you break a critical path in your app, this leads to a loss in revenue.

Depending on the business model you operate under, the revenue loss could be immediate or lagging. For example, if you are selling goods or items that a user will consume, you could notice a drop in revenue soon enough, provided you have sufficient monitoring in place. On the other hand, if you are selling subscriptions, you could lose out on your subscribers in the subsequent cycle which could be a lagging indicator or you would fail to convert users into paying customers.

This is what most people are able to figure out since this is what the bottom lines are made up of.

Cost 2: Collateral Damage to The Business

Apart from losing out on sales and conversion for certain items or subscriptions. You also end up hurting various other aspects of your business when you break a critical path in your app.

Brand Perception

A lot of apps today depend on some form of organic growth. A dent in the brand perception can hurt the business significantly. Since brand perception is not something that you can measure easily. Its effects show up on the charts over months and sometimes even quarters.

App Ratings

Another thing that can easily get affected here is the overall ratings in various app stores. Users that are savvy and care about app ratings can easily pick your competitor over you just because of that number.

User Retention and Engagement

An app or an experience that doesn’t work for a user will eventually lead to them leaving your app sooner than you’d expect them to. Driving users out of your app will bring the overall retention and engagement numbers down. This hurts a lot of businesses that rely on a network of how many active users exist on their app at any given point in time.

Customer Acquisition Cost

The more users you acquire over time, the harder it becomes to target the relevant people with the ads for your product. This leads to a rise in customer acquisition cost. The users that have installed your app either organically or through a paid ad, contribute to this if they leave the ecosystem due to a bad experience.

Cost 3: Cost of Investigation

Depending on the nature of the fire and its impact, you’d start investigating the issues.

Needless to say this is one of the things engineers enjoy the most. However, pulling people away from their regular tasks to deal with fires has a huge impact on productivity since it requires context switching. You also need people who have domain knowledge and technical understanding of the areas that are currently dealing with fire. That kind of expertise may not always be available.

In addition to engineering resources, you would also end up involving Quality Assurance to ensure the fix works as expected and product managers to plan a proper course of action whenever needed.

Cost 4: Cost of Fixing

Once the investigation is complete and you have isolated the issue. The process to fix the issue starts.

Here someone would either commit a new change or revert an old commit, run the tests, and ensure everything works fine. Wait for your continuous integration to pass. Cherry-pick the commit into a new branch. Generate the artifacts, run your regression tests, and eventually submit the builds to the relevant stores.

All of this again, costs time and effort. None of which is free.

Cost 5: Cost of Remediation

Often times when you break the app, product and engineering are not the only ones that are dealing with the fire.

Remember the times when you had to take to social media to get the attention of a business you were frustrated with? Yeah, that happens too and that’s where your marketing and communications teams come in. They have to deal with any negative PR that gets generated due to this issue. In addition to this, your customers could also start flooding your customer service teams.

An increase in customer service inbound leads to either an increased backlog of tickets your team has to deal with or some additional expense your company has to bear by adding more representatives to cater to this issue.

Conclusion

I speak from years of experience working on apps operating in very different industries and teams of all sizes big and small. It is not common to come across engineers who think about these things before shipping their next feature, fix, or a refactor.

Before you make a change be it a feature or a fix, ask yourself. What can go wrong and if there is a way I can either prevent it from happening today or I can immediately mitigate the crash/problem by guarding my change behind a feature flag? It will always be appreciated by your teammates and your managers.

How does Anonymous Feedback Impact Engineering Teams?

Ishan Khanna — Thu, 08 Sep 2022 15:59:56 +0000

What is anonymous feedback?

When you provide someone feedback without your name associated with it, it is called anonymous feedback. For example, you could provide feedback to someone's manager asking them not to reveal your identity when they pass it on to the person who this feedback is about.

Many tools like Impraise, Lattice, and, Workday that companies use for employee and performance management provide an option for giving anonymous feedback nowadays.

Even though the manager can see, who gave what feedback to whom. The receiver cannot see the sender's name.

The Expectation vs The Reality

The number one expectation a team, an organization, or a company has from an anonymous feedback culture is an increase in the feedback that people can get about themselves and or their work.

It is almost never the case. I say almost because I am sure someone somewhere in some way might have proven in a study that anonymous feedback works for certain teams.

Let's discuss the following reasons to understand why I feel the reality is completely different.

Lack of Accountability

My first and foremost issue with anonymous feedback is the lack of accountability.

Try to think about the answers to the following questions:

When trying to submit your work to your peers, say a pull request for code review or a proposal for an idea. Do you ensure that your work is of good quality?
Ever wanted to write a blog post or ended up writing one but didn't publish, telling yourself this isn't your best work?
Made a cool library or project but didn't have the courage to open source it, thinking about all the criticism you'd expose yourself and your project to?
We've all been there and we'll always think about these things. For one and only one reason, accountability. If something can be tied back to you, you are accountable for it.

Most people are never taught how to give proper feedback that matters, until very late in their lives. Add to this, the power dynamics of the company's hierarchy, the office politics, and the cultural diversity to the mix. Anonymity makes it easier to deliver sub-par feedback.

As long as a certain quantity of feedback gets passed around in the organization, the management can just use those statistics to demonstrate a "so-called-healthy culture of feedback". However, it is not really helping anyone. Neither the provider nor the receiver and definitely not the organization.

Delusion of Transparency

Another common misconception among the masses is the fact that anonymous feedback can promote more transparency. To a certain extent, this is true, however, more often than not. People mistake the cloak of anonymity as a weapon for vendetta.

The receiver, even if they know who gave them the feedback, can't really confront the provider. They have no chance of improvement as a lot of the anonymous constructive feedback is mostly rants or venting letters.

To be clear confrontation here should not be taken in the literal sense. I'll explain to you why, in the next section.

Negligible Scope of Improvement

Obviously, who doesn't like to be praised? But it isn't the praise that makes us better, it is the criticism. Constructive feedback, marinated with empathy and thoughtfulness, layered with X, and seasoned with actionable opportunities is what brings the best out of people who want to rise and shine.

But this is hard, and anonymity makes it even harder to go the extra mile and deliver feedback that is easy to process, contextualize, understand, and act upon. Hence, anonymous feedback usually offers little to no scope for improvement.

Now you must be wondering if there are so many issues with anonymous feedback, why do companies allow it?

I am sure an experienced human resource professional could give you a thousand more reasons however, based on my personal experience and research here are three reasons why organizations do it.

Reason 1: Anonymity will increase the quantity of feedback

As I mentioned above, for organizations, it is mostly about the numbers. As long as they can broadcast these numbers in presentations and company-wide meetings. It helps them with their narrative of claiming that we have great feedback or an open or transparent culture.

Reason 2: Anonymity makes certain employees feel safer

This is absolutely true, there are certain sections of employees in every organization who would always feel more comfortable providing anonymous feedback. These could be people from underrepresented or marginalized populations. People early on in their careers or people who are shy in general or people who don't have the best communication skills in the common language of the org. They could also be people who fear retaliation in any way, shape, or form.

Reason 3: Anonymity could lead to higher engagement

This is somewhat synonymous with reason number one, however, it more relates to the feedback being given to the leadership or the organization as opposed to the feedback being shared among peers.

So what can be done to fix this? Well, nothing can replace good actionable feedback. It does not matter if it is anonymous or not, as long as it is actionable.

However, as discussed above, not everyone knows how to provide good feedback, and sometimes it is just hard to provide feedback even if you know how to.

Invest in Feedback Training

The first step in improving the quality of feedback for your teams should be to provide them ample training on what is considered good feedback, and when and how to provide it.

What here translates to Actionable
When here translates to Immediately
How here translates to a framework that people can use.

Here is a simple framework that you can start using today to provide feedback to people that actually helps them.

I learnt about it while working at Booking a few years ago. It is called the BIO Feedback model.

BIO is an acronym for Behavior, Impact, and Opportunity and it focuses on a fluent approach that asks you to point out behavior you observed in someone, the impact it has in that situation, and the opportunity or options the person has to make improvements and grow.

Let me illustrate it with an example:

Situation: Your product manager never scheduled a single retrospective in the whole quarter and you want to provide feedback on this.

Here is one way how I would approach them.

Hey $_product_manager_name, I noticed that we have been working throughout the quarter without doing any retrospectives on our team (The Behavior). I believe the team is not thoroughly aware of the things that are going well and the things that can be improved to ensure high productivity, impact, and happiness of the team (The Impact). I would suggest scheduling an hour in the coming sprint or week to do a retrospective on the team's performance and processes for this past quarter. We will use this opportunity to highlight our wins and make sure we keep doing what is working well for us. Also, we'll try to find out what hasn't worked well for us this past quarter and find out ways to improve in the upcoming quarters (The Opportunity).

As you can see, the product manager now has ample context around why this feedback was delivered. They have been made aware of the impact some teammates might be having due to this. Lastly, you've provided them with an opportunity to improve and grow themselves.

This is just an illustrative example, I am not of the belief that it is solely a Product Manager's or Engineering Manager's responsibility to organize retrospectives. If you feel something is not working well, just raise your hand, take the lead and organize a retrospective.

Deanonymysing Feedbacks

Once your teams get into the habit of providing good, actionable feedback to one another. This will happen automatically. Once I realized I had started providing actionable feedback, even in the tools that by default anonymize my feedback, I started adding my name at the end of the feedback.

This allows the receiver to reach out to me, to ask for clarifications in case there is a misunderstanding or they need more context or any support from me in terms of the opportunity.

Conclusion

In the end, I'd like to say, feedback is a very critical part of your growth journey. No one that has climbed any ladder of success has done so without feedback. If you're not getting good feedback from your teammates, manager, customers, or anyone that matters to you, you should proactively ask for it.

It is not easy, it is not comfortable and it makes you vulnerable. But if you get past those feelings, there is an abundance of growth waiting for you.

Before you go, let's connect with each other on Twitter!

Conditional Provisioning with Dagger

Ishan Khanna — Wed, 25 May 2022 06:30:34 +0000

In this article, you’ll learn how to use Dagger for conditionally provisioning (providing) your dependencies without adding stress to your memory.

As your product grows. You often start trying out new things with it. Since we don’t always know what’ll work best for the users, we often try multiple strategies to solve a problem. This is done through some sort of an A/B test. However, this comes at a cost. The cost is that two distinct solutions exist in the same version of the app, to solve one customer pain point. Let’s try to see it through a lens of an image editing application.

Introducing the Sample App

Imagine you have an app that allows users to edit photos and share them. For editing photos, we use a library called SimplePhotoEditor. This library could be your in-house implementation, a third-party proprietary solution, or even an open-source project that you are using, but that is irrelevant and I wanted to get that out of the way.

Now you come across a library called ComplexPhotoEditor which offers you better photo editing capabilities and promises higher performance when compared to its alternatives in the market.

As you are a very dedicated and passionate engineer, you decide that you want to give this new library a try in your app and see if your users find your app to be more useful, robust, and whatnot.

Understanding the Sample Use Case

Both the libraries require a lot of memory as soon as they are initialized and want to hold on to a significant amount of it, throughout their lifetime during the app’s session. Not going to comment on the design of the library :]

So as soon as someone initializes an object of either of the two libraries we’d see a significant spike in resource allocation. Since we need at least one of the two libraries at all given times, we’ll have to live with that overhead, however, having both of them taking up their fair share of resources doesn’t really make sense. So in the next section, we’ll look into implementing this behavior.

Implementing the Use Case

Let’s say we have an interface called ImageManipulationStrategy which has a method to manipulate the input and return an output.

interface ImageManipulationStrategy { 
 fun manipulate(image: Image): Image 
}

In order to support both the libraries, we have their respective implementations in our app, that look like this

class SimpleImageManipulationStrategy(
 private val SimpleImageEditor: simpleImageEditor
    ): ImageManipulationStrategy {

     override fun manipulate(image: Image): Image {
         // manipulate with simpleImageEditor
     }
}

and this

class ComplexImageManipulationStrategy(
 private val ComplexImageEditor: complexImageEditor
    ): ImageManipulationStrategy {

     override fun manipulate(image: Image): Image {
         // manipulate with complexImageEditor
     }
}

Now when using these strategies in other classes we can easily swap them in our Dagger Module like this

@Provides
fun imageManipulationStrategy(
  simpleImageManipulationStrategy:SimpleImageManipulationStrategy,
  complexImageManipulationStrategy:ComplexImageManipulationStrategy,
) : ImageManipulationStrategy {
    // provide the desired strategy
}

While this works fine, there is a problem with providing the dependency this way and we’ll see that in the next section.

Understanding the Problem

As we can see Dagger at Runtime will not know which dependency we actually might get in our method, so it’ll initialize both of them. So that whichever one we need, is readily available at our disposal in the method.

Having both of them initialized when we only know one is going to be needed, is the problem here. Now, this can occur in any case, where initializing a class is expensive and you might have to choose between those implementations, wasting resources on at least one of them.

The solution to this problem is pretty simple and we’ll see that in the next section.

Understanding the Solution

Dagger exposes the Provider<T> class to us. So instead of using the default mechanism of providing the dependencies, we can defer the initialization by using this class.

The way it works is that Dagger will provide you the Provider<T> object and you can use it to get() the actual dependency.

Here is how it’d look in practice

@Provides
fun imageManipulationStrategy(
    simpleProvider: Provider<SimpleImageManipulationStrategy>,
    complexProvider: Provider<ComplexImageManipulationStrategy>,
) : ImageManipulationStrategy {
    return if (myConditionIsMet) {
        simpleProvider.get()
    } else {
        complexProvider.get()
    }
}

and this will ensure that Dagger doesn’t initialize a dependency unnecessarily when we don’t need it to.

Conclusion

You don’t always want to rely on Dagger to provision dependencies for you directly.
You should always assess if any of your dependencies are hungry for resources.
It is possible to conditionally provision dependencies in your graph at runtime, with Dagger.
Dagger exposes a class called Provider
When using an object of Provider<T>, Dagger won't initialize the dependency unless the get() method on this object is called.

Originally published at https://www.droidchef.dev on April 2, 2022.