:wave: If composable functions can execute in any ...

# compose

[hawklike]

👋 If composable functions can execute in any order and the remember is a composable function, it means we have no guaranteed order in which they will be executed? Or remember functions run sequentially?

@Composable
private fun Foo() {
    val context = LocalContext.current

    val cameraManager = remember {
        context.getSystemService(Context.CAMERA_SERVICE) as? CameraManager
    }

    val backCamera = remember(cameraManager) { <------- are we sure the cameraManager is initialized?
        cameraManager?.cameraIdList?.firstOrNull()
    }

    ...
}

[Timo Drick]

I don't think that you can say this. And inside of you composable function the code is executed sequentially except when you use corotines or other threads.

[hawklike]

Why is that? From docs:

If a composable function contains calls to other composable functions, those functions might run in any order.

The Foo is a regular composable function that calls other composable functions, the remember functions. Why do you think it executes sequentially?

[Timo Drick]

Composable functions are executed several times and e.g. the code inside the remember block is only executed once or dependent on the key. But still the code is executed sequentially more or less 🙂. Unfortunately compose is very complex under the hood. So it is difficult to assume general things. But when you assign a variable than this must be executed instantly otherwise the UI would be stuck.

[hawklike]

What it means executed sequentially more or less, please? Can we assume that a composable function prior to other composable functions will always be called before them (if it will be called)?

[Timo Drick]

Yes at the end it is just kotlin code. But things which are inside curly braces coulb be executed later. This is a kotlin convention because this is just the last parameter of a function.

[Timo Drick]

So for your example remember is definitely executed immediately. But the part inside of the curly braces. You never now until you look inside of the function. Because this block is just one parameter

[Timo Drick]

But remember must return some thing. Otherwise this code would not compile.

[Loney Chou]

I think the documentation needs to be more clear about what "in any order" means. From my experience, it actually means "they may be skipped, or executed sequencially". So it's not that in any order, it's just that some of the composable functions will be skipped this time, but executed another time, so it feels like they are not sequencial. It's a special side effect of smart recomposition.

[hawklike]

Thank you.

[dewildte]

Any @Composable function can be chosen to be invoked by the runtime at arbitrary points in time.
But once a function is invoked then it’s body will be executed sequentially.
There is no way to get around that.
That’s what the annotation is for, it allows the compiler to see all the composable functions declared in the code
prior to runtime.

[Albert Chang]

I believe the doc meant all composable functions without return value, which means they don't have data dependencies on each other. Composable functions without return value can potentially run in any order once multithreaded composition is enabled.
The doc mention that even if it's not true for now because not assuming execution order (i.e. not relying on side effects) is the best practice, and will reduce the work needed to support multithreaded composition when it's out.