Hey I have a quick question how something bothering me for some time assuming : ```val pagerState = ...

# compose

[nitrog42]

Hey I have a quick question how something bothering me for some time
assuming :

val pagerState = rememberPagerState(pageCount = 2)

can we write

val selectedTabIndex = pagerState.currentPage
TabRow(selectedTabIndex = selectedTabIndex,...)

or do we have to do :

val selectedTabIndex = remember(pagerState) { pagerState.currentPage }

?

[nitrog42]

which can be summed up by "can we still use standard variable declaration in a composable method or do we always have to use remember" ?

[Albert Chang]

The former.

can we still use standard variable declaration in a composable method or do we always have to use remember

You can.

[CLOVIS]

Basically:
• If you use a normal variable, it will be re-initialized on every recomposition (= don't use normal variables for expensive calculations)
• remember tells compose to observe that object and recompose if it changes (= for stuff that doesn't change, or shouldn't update the UI, remember is useless)

For example, if you have a list of tabs, or whatever else that's hard-coded, won't change, and is cheap to compute, normal variables are fine

[nitrog42]

for the 2nd fact, is it remember or more the user of a mutableState ?

[Adam Powell]

Remember and snapshot observation are orthogonal. Remember has no direct relation to snapshot observation, which is why you often see remember and mutableStateOf together; you often want to have both and need to say them both in those cases.

[Adam Powell]

What remember will do is recompute the result value if one of its key parameters is different during a subsequent recomposition

[Zach Klippenstein (he/him) [MOD]]

If you want a longer explanation about remember vs mutableStateOf, this might help

[nitrog42]

well I like the first part of your serie, because what I find hard right now is to understand what really happens on recomposition (which code I wrote will be called again, which code won't)