Learnings from DroidCon Berlin 2021
Tags: droidcon, programming, android, conference
Published: 2021-10-24 10:52:00

I recently attended DroidCon Berlin 2021. I was fortunate enough to be able to attend Droidcon Berlin online last year, but this was my first ever in-person conference. It was a wonderful experience! And I learnt a lot!

There were a lot of great talks spanning different topics from Jetpack Compose to also the shape of media regulation to come. But I'll be giving a summary of some talks I found interesting. Slides and video recordings will be published soon on 

##Backend For Frontend(BFF)
 Backend for frontend was a talk given by Michal Szczepanik. He talked about the BFF pattern. At some point, we might have encountered a situation where API calls to the backend become clunky because the APIs weren't developed with mobile in mind. Maybe the backend was developed solely for the frontend at first. As a mobile dev, you find yourself making multiple API calls and merging them just so you can display the right data on the screen. 
The BFF pattern is a pattern that was developed by Soundcloud. They propose instead of building one general API backend that serves mobile, frontend, and external users. You should create multiple API backend for each experience. Experience doesn't outrightly mean platform. For example, if you're trying to set up a BFF system for ride-hailing. You'd have two experiences; the rider and driver experience. If the experience is the same between both IOS and Android, then you can have one BFF for both apps.
I like this approach to building apps because it provides dedicated and solutions for each client. I was also fortunate enough to speak to a mobile lead whose team uses the BFF system. Aside from having more backend devs, he didn't see any disadvantages to using the BFF pattern. In my opinion, if you already have a cross-platform team, then that's also not a disadvantage.
Here's an in-depth article about the BFF system https://samnewman.io/patterns/architectural/bff/

##The journey of adopting Jetpack Compose in Babbel’s App
Compose!! This was super fun and existing talk by 
Ahmed Mabrook and Benjamin Kadel. They talked about their bitter-sweet but mostly sweet experience adopting Compose. They can be summarised by:
1. Learn by digging into the source code.
2. Read the documentation!!
3. If you need to use existing styles and themes, use the MDC theming adapter library. 
4. No migration was needed with their current MVVM architecture. They only had to migrate from data binding to Compose's `State` and `LiveData`. 
The major takeaway from this talk is migrating to compose isn't going to be as difficult as I thought it would be. Sure switching from an imperative way of building apps to a declarative way might take some getting used to. 

##Engineering Design System
Luca Nicoletti give an awesome talk on how they engineered their design system.
According to Luca, a design system is a collection of reusable components, guided by clear standards, that can be assembled to build any number of applications. A design system is not just the design, it's code, implementation altogether.
There are many advantages to developing apps using a design system. Some of them include:
1. Consistency
2. Improved maintainability
3. Faster app development after an initial effort to build the design system.
4. Migrating to a different view system becomes a bit simpler.
Developing a design system requires a lot of effort at first. But I believe it's worth it. Especially, when you get to develop multiple apps using the design system.
When building a design system, ensure you separate your views from the state. The state should drive your views. This makes migrating to something like Compose simpler. And also strive to make your components atomic and simple.

##Offline is not an error
Offline is not error was a very very interesting talk by Yonatan (Yoni) Levin. He talked about how they handle offline first support with the editing of actions in the Monday app. His approach uses something that resembles the Command pattern (in my opinion) to separate operations from the operation executer. This makes it very easy to add support for new operations later in the future. He also uses reactive DB observations and Work manager chains as a queue. Whenever the Work manager modifies the DB, the DB emits a new flow, and the UI changes accordingly. This is just an overview using what I could remember. It involves more moving parts than what I described. It was a very interesting talk. If you need to implement offline support in your apps, I'd suggest checking it out. 

##The Billion User Open Secret
The Billion User Open Secret was a talk by Abel Adugam A. Nibori. A 20-year-old CEO from Nigeria! He talked about how to build apps for the next billion users. Most of which will come from Africa, Asia, and South America. We should consider making our app size smaller, using less data consumption amongst others. I'd suggest you check it out.


There were a lot of other interesting talks but I wasn't able to jot some things down and I could find a way to clone myself :D. But no worries, the slides, and presentations will be uploaded on Droidcon Berlin soon. I had so much fun and I can't wait to attend Droidcon Berlin 2022. Maybe who knows, I might attend as a speaker next time.