Trying to summarize the difference between the app...

# compose

[Daniele B]

Trying to summarize the difference between the apps of the “past” and the apps of the “future”:

[Joost Klitsie]

I have some questions: How is a ui layer fully decoupled from a viewmodel? Also what does declarative/imperative ui has to do with coupling? And in what way do you mean web services are ui agnostic in the future?

[Joost Klitsie]

Also 85% sounds a bit high for shared code

[Daniele B]

@Joost Klitsie Leland Richardson explains it well here, about how declarative UIs are able to have a minimum coupling with the ViewModel:
https://medium.com/androiddevelopers/understanding-jetpack-compose-part-1-of-2-ca316fe39050

[Daniele B]

This picture represents it very well:

[Daniele B]

Without having to couple the data to the UI component IDs, and having a ViewModel which is fully shared, 85% is fully achievable.

[Daniele B]

You can find more infos on my article:
https://danielebaroncelli.medium.com/the-future-of-apps-declarative-uis-with-kotlin-multiplatform-d-kmp-part-1-3-c0e1530a5343

[Daniele B]

This picture helps to understand too:

[Daniele B]

[Daniele B]

When I say webservices can be “UI-agnostic”, I mean that the shared client-side logic can play a big role, so that all processing can be done there.
The webservices don’t need to have any knowledge about how the data is going to be used, and can provide optimized/normalized data, without any formatting/redundancy, which in previous thin-client apps were a common practice, aimed to reduced client-side logic. The shared client-side logic will do all.

[Joost Klitsie]

Well that article doesnt say it is fully decoupled, it says it has less dependencies. It even states that you will always have some ui code in your application (aka coupling). I mean your viewmodel does need to provide some data your ui can display, so you will have coupling there. I do like my viewmodels to dictate the values of a view, because of testability and that means higher coupling than if you'd put mapping of domain objects to ui elements all in your view, which sacrifices testability but gives you a higher grade of decoupling.

[Joost Klitsie]

I use mvvm in my test application, and i achive 9000 loc in common, 6000 in react and 3500 in my android app. So that is at best 70% on the android app, but still crazy good. I think the fancier your ui, the lower it will get. 1 project is not a good representation, i can write a lib with 1000 lines of code and then a ui with 10 lines of code, hurray 99% reused!

[Joost Klitsie]

I think jetbrains should do a bigger survey to show the real numbers

[Joost Klitsie]

Also your api data driven comparison doesnt really need kmp to work, this is already possible and already done nowadays id say, anyway your services will be most likely even more event driven if you look at cloud functions which are gaining popularity

[Daniele B]

The “secret sauce” for achieving 85% shared code is definitely the MVI pattern and Kotlin’s StateFlow, which allows you to have a multi-platform observable (inbuilt in the language) instead of platform-specific observables such as LiveData.
If you use StateFlow to pass the data to your UI layer, there is no coupling. Which means the ViewModel (which is platform-independent) doesn’t need to know anything about the platform-specific implementation of the UI. The ViewModel just provides the data. And it’s up to the UI layer to decide how to use it.

[Daniele B]

What I am saying about data-optimized webservices, is that it’s now better achievable thanks to multi-platform.
Previously, when you had to replicate any logic for each platform, you tended to have webservices directly linked to screen (one API per screen), in orer to minimize client-side logic replication.
Nowadays, as you can just write client-logic once, you can apply all kind of data optimizations.

[Joost Klitsie]

Well i use mvvm with flows so that shouldnt have more code (as my viewmodels are in common)

[Joost Klitsie]

I do not think passing domain objects to a view is the best thing to do

[Joost Klitsie]

Its a shortcut

[Joost Klitsie]

But talking about apis, we use on my project (like at my work, not kmp) we also download data objects, nothing in the api is architected to serve specific screens

[Daniele B]

I do not think passing domain objects to a view is the best thing to do

it’s just data, strings, already formatted, and ready to be displayed on the UI layer.
The formatting is done in the shared ViewModel.

[Daniele B]

But talking about apis, we use on my project (like at my work, not kmp) we also download data objects, nothing in the api is architected to serve specific screens

Of course, in many cases it’s important to apply client-side logic, even if the client-logic is not shared and needs to be replicated for each platform. But that comes with a cost (of replication).
In KMP, there are not costs of replication, so such client-side logic can be very extensive. And many advanced things can be done to improve the user experience. At no cost.

[Joost Klitsie]

Well that means some coupling right? The viewmodel has to poop out the data such that the view can display it. I mean it does have less coupling if you dont have to worry about the imperative view, but still its something

[Joost Klitsie]

Which is fine

[Daniele B]

Well that means some coupling right? The viewmodel has to poop out the data such that the view can display it. I mean it does have less coupling if you dont have to worry about the imperative view, but still its something

UI Components in the imperative (view-based) UI systems have IDs.
When I talk about coupling, I mean that the ViewModel (which is not the same as saying the Android's ViewModel component) needs to link data to each UIcomponent ID. This happens in both Android and iOS, view-based system.
In a KMP/MVI/DeclarativeUIs project, the ViewModel can be totally decoupled in the sense that it doesn't need to link data to UI components. It just provides the app state (which is a data object), and it's up to the declarative UI layer to use it in the way it wants.

[Joost Klitsie]

I do agree with thelis point a lot: when we dont need to duplicate logic, we can invest more in extending functionality. Hybrid apps fail to be cheaper i guess because of the costs of fighting against the frameworks, kotlin doesnt have this issue. I will have a presentation soonish about kmp at my company and i do hope to convince some souls, but at the same time I'll try not to overpromise. Code sharing between backend and frontend will be a big point as well (even though its quite minimal compared to the frontend apps code sharing).
Promising a new wave of apps might scare off old fashioned java guys, but promising them way better tooling might just get their attention.