I recently had the chance to interview for an SDE 2 Android role at JioCinema (Viacom18). I wanted to share my experience to help others considering similar positions or preparing for tech interviews.
I started by applying directly through the company’s website. It’s worth noting that I didn’t use a referral for this application. Shortly after, I was contacted by an HR from Viacom18, who described the interview process.
The HR informed me that the interview process would consist of three rounds:
- Problem Solving and Android Coding Round
- System Design Round
- Hiring Manager or HR Interview
First Round
After brief introductions, we dove straight into the technical discussion. Here’s a breakdown of what we covered:
The interviewer began by asking about the architectures and tech stack used at my current company. I mentioned that we use MVVM architecture and briefly mentioned that we’re trying to implement new features in Clean Architecture.
When asked to explain Clean Architecture in detail, I had to admit that we were just starting to implement it, and I hadn’t spent much time on it yet. But, I did explain everything I knew about it.
He then asked a few questions about view models, specifically how they handle configuration changes and how it is handled internally by Android.
We then discussed different types of observables, specifically LiveData and Flows. The interviewer asked which ones I use in my code and their differences. And since I mentioned I use LiveData, we discussed a few questions about it.
The conversation then shifted to threads and coroutines. We discussed the differences between them in detail, debating which is better in various scenarios. This part of the interview tested my understanding of concurrent programming in Android.
The interviewer presented me with a coding problem. I was asked to write the output of this program.
fun main() = runBlocking {
launch {
println("Coroutine with delay starts")
delay(1000L)
println("Coroutine with delay ends")
}
launch {
println("Coroutine with Thread.sleep starts")
Thread.sleep(1000L)
println("Coroutine with Thread.sleep ends")
}
println("Main program continues...")
}The final technical question was about handling multiple API calls:
- I was asked to write a suspend function that returned a value.
- This function needed to make two API calls, where the output of the first API was required for the second API call.
- The function should return the result of both APIs or return an error if either call failed.
Initially, I suggested calling the second API within the response handler of the first, but the interviewer was looking for a different approach. They suggested using async and await for the solution, which I struggled with as I hadn’t used these coroutine features extensively before.
Then we discussed about how to return data from suspend functions.
As the interview concluded, I was allowed to ask questions. However, I felt that my performance wasn’t as good as I had hoped.
While I don’t expect to be selected for the next round due to my performance, this interview was a good learning experience. It highlighted areas where I need to improve my knowledge.
This interview experience was contributed anonymously to Androiddd.com. If you have an interview experience to share, we welcome your contribution. Simply send an email to anonymous@androiddd.com. We respect your privacy and will not disclose your details unless you choose to share them.
As a token of appreciation, contributors have a chance to win a ₹1000 Amazon gift voucher (or equivalent in your required currency). Share your story, help fellow developers, and potentially win a reward!
What’s the output of that coding problem, and how do we solve the other problem? Having the 2nd API call in response of first seems like a sensible solution. Interviewers are just crazzzy.
The output will be:
Main program continues…
Coroutine with delay starts
Coroutine with Thread.sleep starts
Coroutine with Thread.sleep ends
Coroutine with delay ends
Why? The program starts on the main thread. runBlocking blocks this (current) main thread until its block finishes.
Then, the first launch creates a new coroutine without blocking the thread. It’s not executed immediately but scheduled for execution.
So is the second launch; creating the second coroutine.
The print with Main program continues… thus comes first.
runBlocking was called without specifying a Dispatcher, so according to the documentation (JVM) https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html :
The default CoroutineDispatcher for this builder is an internal implementation of event loop that processes continuations in this blocked thread until the completion of this coroutine.
Means: all in this single one thread.
The first coroutine thus runs and prints Coroutine with delay starts.
delay command suspends that first coroutine and yields execution. Conveniently enough, coroutine 2 is waiting and prints Coroutine with Thread.sleep starts.
Then, coroutine 2, of all things, blocks the single one blocked thread we have. Bummer, because that won’t yield execution. Anyway, after that 1 second we go on with printing Coroutine with Thread.sleep ends. Coroutine 2 ends, yielding others. Scheduler resumes execution of coroutine 1, which prints Coroutine with delay ends.