Opening the shutter on snapshots (dcSF 23)

Jetpack Compose shows the power of a custom compiler plugin. But not all the magic happens during compilation. A lot of Compose features are based on a runtime library that doesn't require any compiler support: the snapshot system. It might seem like magic at first, but it's just built on top of things you might already know: ThreadLocals, linked lists, and, yes, even regular old callbacks. Once you understand how Compose thinks about state, you might find ways to use its tools in your own code – even outside of Compose.

Transcript

1. Zach Klippenstein (he/him) Google Opening the shutter on snapshots name/job/thanks
2. not this talk this talk snapshots Not snapshots intro: Low-level talk You don’t need to know this to use compose! Target: Used compose a bit, snapshots seem magic 2 Goals: - convince you they’re not magic - give you enough context to read impl code Questions: might not have time, tweet me
3. What for? What do they do? How do they work? What can we do with them? Before talking about snapshots, I want to talk about fi les.
4. Imagine collaborating with your team on a fi le server Everyone editing directly
5. Totally unmanageable We’ve built tools to help
6. Git Capture state of codebase Edit fi les without worrying about others When ready, discard or merge branches Deal with con fl icts at merge
7. Snapshots are Git for your variables Git for your variables Layout, event handlers are the programmers Capture state of program Edit values without worrying about others When ready, discard or apply snapshots
8. Composition is the release manager Composition needs to see a consistent state Next: Other similarities…
9. Git Snapshots branches snapshots main branch global snapshot commits state object writes merge apply snapshot resolve conflicts merge strategy hooks read, write, apply listeners Discuss comparisons There’s a word for this set of features, from DBs…
10. ACID “In-memory” ACID Acronym stands for…
11. ACID tomicity On-disk “a”, Red “b”, Red “b”, Blue “b”, Blue All changes seen at once
12. A CID onsistency On-disk “a” “b” “c” “c” “c” tomicity If one change can’t apply, none will
13. AC ID solation On-disk “a”, Red “a”, Blue “b”, Red “b”, Blue onsistency urability Don’t see other snapshots changes while you’re working, even across threads.
14. ACI D urability On-disk In-memory solation Saved to persistent storage {tap} Snapshots are in-memory only
15. ACID “In-memory” tomicity onsistency solation urability ACID without the D Resemble databases in other ways too
16. Database Snapshots ACID ACID Transactions snapshots commit/rollback apply/dispose views derived state Discuss comparisons
17. How do they work? That’s a lot of features How do they even work? Must be… {next: magic}
18. Magic?
19. No magic No, kidding
20. Compiler plugin? from A Hitchhiker’s Guide to Jetpack Compose Compose uses a compiler plugin Are they part of that?
21. No compiler plugin Nope
22. (but shipped with it) Snapshots ≠ Compose Library within compose Fundamental to compose: Composition needs a consistent view of state while it’s running Observe changes Decoupled Only a few fi les
23. (but shipped with it) Snapshots ≠ Compose snapshots the rest of Compose ThreadLocal integers linked lists Library within compose Fundamental to compose: Composition needs a consistent view of state while it’s running Observe changes Decoupled Only a few fi les Again, no magic
24. snapshots ThreadLocal integers linked lists Just built on standard programming stu ff How could we build it? Next: redux
25. Giant state container? (i.e. Redux) snapA “a” “foo” Range(0, 100) snapB “a” “bar” Range(0, 50) snapC “b” “foo” Range(25, 75) all state in app Giant state container? Redux, at least conceptually Immutable Lots of memory Lots of copying - bad for animation Awkward API - think every var
26. mutableStateOf mutableStateOf Range “a” “b” “foo” “bar” snapA snapB snapC Instead of state in snapshot, snapshot in state “Snapshots” are metadata Compare with previous slide Snapshots DO NOT contain pointers to state…
27. Snapshots State Objects records mutableStateOf mutableStateOf Range “a” “b” “foo” “bar” snapA snapB snapC The parts of a state are called “records” Snapshots know which record to look at Cool properties: Create & apply is cheap: just metadata Quickly capture/apply every piece of state in the world Change data is cheap: Only touch state object in question API is clean
28. reads: 96 snapshots records 128 167 181 64 75 111 209 52 53 87 many : state “foo” Many snapshots can select a single record New snapshots always select existing records No pointers - Inside a snapshot, which record you’ll “see”
29. writes: : “bar” 210 96 128 167 181 64 75 111 209 52 53 87 state “foo” A record may have no writers or exactly 1 First write: Copy record, reuse if possible. Subsequent writes: Write directly to record
30. Snapshots concepts State Objects low-level API concrete ID previous IDs invalid set primary API abstract map of IDs to values written by snapshot with ID i.e. “records” API: low vs high Concrete vs abstract All snapshots have unique ID State records have ID
31. Snapshots API State Objects takeNestedSnapshot takeNestedMutableSnapshot withMutableSnapshot registerApplyObserver …and more val state = mutableStateOf(“”) 
 mutableStateListOf mutableStateMapOf mutableIntStateOf …whatever! State objects: Library ships with some Can de fi ne custom New: mutableIntStateOf
32. Snapshots operations State Objects Create: choose new ID Enter: set ThreadLocal restore ThreadLocal Apply: commit ID notify listeners Read: find record read from record Write: find or copy record write to record discuss Next: example of relation
33. Selecting record for read message id value “he” “hello asdf” tombstoned “hello ” written by 72 “hello world” color id value Red Blue written by 80 snapshot ID invalid set Walk through every selection Next: this rule is…
34. newest valid record “mutableState.value” get() = findRecord(SnapshotThreadLocal.get()) highest ID not higher than snapshot ID AND not in snapshot invalid set AND not tombstoned The snapshot is a query against the record list of a state object. Instead of looking in snapshot for state object, snapshot looks in state object Next: snapshot IDs
35. Snapshot IDs Git: commit SHAs Back to the git metaphor, Git has SHAs, snapshots have IDs {tap} Every snapshot has a unique ID Each merge point also has an ID IDs not arbitrary Monotonically increasing Clock, order of creation new snapshot next highest ID Next: snapshot example
36. Walkthrough: create child, apply val message = mutableStateOf("") val snapshot = Snapshot.takeMutableSnapshot() snapshot.enter { message.value = "hello" } snapshot.apply() message Won’t show exactly as code works Trying to give high-level idea, context for reading code
37. Walkthrough: create child, apply message val message = mutableStateOf("") “” global snapshot Start: global snapshot {tap} Write initial record Next: create child
38. Walkthrough: create child, apply message val snapshot = Snapshot.takeMutableSnapshot() “” global snapshot snapshot Child sees same record Next: advance parent
39. Walkthrough: create child, apply message val snapshot = Snapshot.takeMutableSnapshot() “” global snapshot snapshot Advanced parent: child won’t see parent writes Add IDs between old and new (exclusive) to invalid set This is a superset of all open snapshots Next: update invalid
40. Walkthrough: create child, apply message val snapshot = Snapshot.takeMutableSnapshot() “” global snapshot snapshot Done creating child Didn’t touch state object Next: write
41. Walkthrough: create child, apply message message.value = "hello" “hello” “” global snapshot snapshot Create new record to write Parent won’t see it because invalid set Done: Didn’t touch snapshots Next: apply
42. Walkthrough: create child, apply message snapshot.apply() “” “hello” global snapshot snapshot First thing: Move ID to parent’s history Parent “becomes” child
43. Walkthrough: create child, apply message snapshot.apply() “” “hello” global snapshot snapshot Remove from invalid Next: parent now sees child record
44. Walkthrough: create child, apply message snapshot.apply() “” “hello” global snapshot Parent now sees new record Next: advance parent, and done
45. Walkthrough: create child, apply message snapshot.apply() “” “hello” global snapshot
46. Walkthrough: create child, apply message snapshot.apply() “hello” “” merged! global snapshot Next: rules
47. Snapshot operations: Create child Apply Advance We just combined a few operations
48. Snapshot operations: Create child: 1. Create new snapshot 2. Copy parent’s invalid list 3. Advance parent – child’s ID will be added to invalid set (see Advance rule 3 below) Apply: 1. Advance parent 2. Remove child ID from invalid set – parent sees child’s writes 3. Add child’s current and previous IDs to parent’s list of previous IDs – parent “absorbs” child Advance: 1. New ID is next highest ID 2. Add old ID to list of previous IDs 3. Add IDs between old and new (exclusive) to invalid set This is a superset of all open snapshots i.e. Unrelated snapshots created since old ID should be ignored Reference – will move on to next example Suggest taking a picture
49. Walkthrough: create 2 children, apply val message = mutableStateOf("") val color = mutableStateOf(Red) val snapshotA = Snapshot.takeMutableSnapshot() val snapshotB = Snapshot.takeMutableSnapshot() snapshotA.enter { message.value = "hello" } snapshotB.enter { color.value = Blue } snapshotA.apply() snapshotB.apply()
50. Walkthrough: create 2 children, apply val message = mutableStateOf("") val color = mutableStateOf(Red) message “” color Red global snapshot Global snapshot, initial writes
51. Walkthrough: create 2 children, apply val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot New child, same as before
52. Walkthrough: create 2 children, apply val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot
53. Walkthrough: create 2 children, apply val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot Next: Create 2nd child
54. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot val snapshotB = Snapshot.takeMutableSnapshot() snapshotB Follow same rules Also sees initial records Next: copy parent invalid set
55. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot val snapshotB = Snapshot.takeMutableSnapshot() snapshotB Children are isolated from each other Next: advance parent
56. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot val snapshotB = Snapshot.takeMutableSnapshot() snapshotB Next: add IDs between old & new to invalid set
57. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot val snapshotB = Snapshot.takeMutableSnapshot() snapshotB Next: snapshotA writes
58. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB snapshotA.enter { message.value = "hello" }
59. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB “hello” snapshotA.enter { message.value = "hello" } Next: snapshot B writes
60. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB “hello” snapshotB.enter { color.value = Blue }
61. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB “hello” Blue snapshotB.enter { color.value = Blue } Again, writes don’t touch snapshots Next: apply A
62. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB “hello” Blue snapshotA.apply() Next: move ID to parent history
63. Walkthrough: create 2 children, apply message “” color Red snapshotA global snapshot snapshotB “hello” Blue snapshotA.apply() Next: remove from invalid
64. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotB “hello” Blue snapshotA.apply() See A’s write Next: advance parent
65. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotA.apply() snapshotB “hello” Blue Next: apply B
66. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotB.apply() snapshotB “hello” Blue Next: move ID to parent’s history
67. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotB.apply() snapshotB “hello” Blue
68. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotB.apply() “hello” Blue See B’s write. Next: advance parent, and done
69. Walkthrough: create 2 children, apply message “” color Red global snapshot snapshotB.apply() “hello” Blue
70. Walkthrough: create 2 children, apply message “” color Red global snapshot “hello” Blue snapshotB.apply() merged! Next: induction/nesting
71. Walkthrough: created nested child, apply val message = mutableStateOf("") val color = mutableStateOf(Red) val snapshotA = Snapshot.takeMutableSnapshot() snapshotA.enter { message.value = "hello" val snapshotB = Snapshot.takeMutableSnapshot() snapshotB.enter { color.value = Blue } snapshotB.apply() } snapshotA.apply() Discuss: Induction! There is nothing special here
72. val message = mutableStateOf("") val color = mutableStateOf(Red) message “” color Red global snapshot Walkthrough: created nested child, apply
73. val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot Walkthrough: created nested child, apply
74. val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot Walkthrough: created nested child, apply
75. val snapshotA = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot Walkthrough: created nested child, apply Next: A writes
76. snapshotA.enter { message.value = "hello" message “” color Red snapshotA global snapshot Walkthrough: created nested child, apply
77. snapshotA.enter { message.value = "hello" message “” color Red snapshotA global snapshot “hello” Walkthrough: created nested child, apply Next: create nested snapshot
78. snapshotA.enter { val snapshotB = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot snapshotB “hello” Walkthrough: created nested child, apply B can see A’s write because it’s lower ID Next: advance parent
79. snapshotA.enter { val snapshotB = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot snapshotB “hello” Walkthrough: created nested child, apply Next: update invalid
80. snapshotA.enter { val snapshotB = Snapshot.takeMutableSnapshot() message “” color Red snapshotA global snapshot snapshotB “hello” Walkthrough: created nested child, apply This time we get parent AND child Discuss isolation Next: B writes
81. snapshotA.enter { snapshotB.enter { color.value = Blue } message “” color Red snapshotA global snapshot snapshotB “hello” Walkthrough: created nested child, apply
82. snapshotA.enter { snapshotB.enter { color.value = Blue } message “” color Red snapshotA global snapshot snapshotB “hello” Blue Walkthrough: created nested child, apply Next: apply B
83. snapshotA.enter { snapshotB.apply() } message “” color Red snapshotA global snapshot snapshotB “hello” Blue Walkthrough: created nested child, apply
84. snapshotA.enter { snapshotB.apply() } message “” color Red snapshotA global snapshot snapshotB “hello” Blue Walkthrough: created nested child, apply Next: remove invalid
85. snapshotA.enter { snapshotB.apply() } message “” color Red snapshotA global snapshot “hello” Blue Walkthrough: created nested child, apply Can see write Next: advance parent
86. snapshotA.enter { snapshotB.apply() } message “” color Red snapshotA global snapshot “hello” Blue Walkthrough: created nested child, apply Next: apply A
87. message “” color Red snapshotA global snapshot “hello” Blue snapshotA.apply() Walkthrough: created nested child, apply Next: move current AND previous IDs to parent
88. snapshotA.apply() message “” color Red snapshotA global snapshot “hello” Blue Walkthrough: created nested child, apply Next: remove invalid and see A’s write
89. snapshotA.apply() message “” color Red global snapshot “hello” Blue Walkthrough: created nested child, apply Next: advance
90. snapshotA.apply() message “” color Red global snapshot “hello” Blue Walkthrough: created nested child, apply No new invalids: all IDs in history Next: see B’s write
91. snapshotA.apply() message “” color Red global snapshot “hello” Blue Walkthrough: created nested child, apply
92. snapshotA.apply() message “” color Red global snapshot “hello” Blue merged! Walkthrough: created nested child, apply Done: Snapshots + state objects How are state objects implemented?
93. MutableState message “” “hello” interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } MutableState: an interface
94. MutableState message “” “hello” interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } Component funs are sugar, ignore
95. SnapshotMutableState MutableState message “” “hello” interface SnapshotMutableState<T> : MutableState<T> { val policy: SnapshotMutationPolicy<T> } interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } : Still not concrete Interface adds mutation policy
96. SnapshotMutableStateImpl SnapshotMutableState message “” “hello” internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } } interface SnapshotMutableState<T> : MutableState<T> { val policy: SnapshotMutationPolicy<T> } interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } : Now concrete Implements 1 other interface Next: StateObject
97. SnapshotMutableStateImpl StateObject message “” “hello” internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } } interface StateObject { val firstStateRecord: StateRecord fun prependStateRecord(value: StateRecord) fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? = null } interface SnapshotMutableState<T> : MutableState<T> { val policy: SnapshotMutationPolicy<T> } interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } : discuss members
98. message “” “hello” interface StateObject { val firstStateRecord: StateRecord fun prependStateRecord(value: StateRecord) fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? = null } interface SnapshotMutableState<T> : MutableState<T> { val policy: SnapshotMutationPolicy<T> } interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } } SnapshotMutableStateImpl StateObject : Implement required
99. message “” “hello” interface StateObject { val firstStateRecord: StateRecord fun prependStateRecord(value: StateRecord) fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? = null } interface SnapshotMutableState<T> : MutableState<T> { val policy: SnapshotMutationPolicy<T> } interface MutableState<T> : State<T> { override var value: T operator fun component1(): T operator fun component2(): (T) -> Unit } internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO("???") override fun prependStateRecord(value: StateRecord) { TODO("???") } } SnapshotMutableStateImpl StateObject : Got basic shape, Next: Need a record!
100. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO("???") override fun prependStateRecord(value: StateRecord) { TODO("???") } } Create private record class Subclass StateRecord Internal linked list
101. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO("???") override fun prependStateRecord(value: StateRecord) { TODO("???") } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = TODO("???") override fun assign(value: StateRecord) { TODO("???") } } } Create private record class Subclass StateRecord Internal linked list
102. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO("???") override fun prependStateRecord(value: StateRecord) { TODO("???") } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { TODO("???") } } } Discuss create
103. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO("???") override fun prependStateRecord(value: StateRecord) { TODO("???") } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Discuss assign Next: Need to store record somewhere
104. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = TODO(“???") override fun prependStateRecord(value: StateRecord) { TODO("???") } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Create private var Next: wire up StateObject linked list…
105. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { TODO("???") } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Getter for head of list
106. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = TODO("???") set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as StateStateRecord<T> } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Add to list That’s it - system links nodes together Next: impl value property
107. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = next.value set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as StateStateRecord<T> } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Get the latest record Read from it Not quite: Need to select the correct record for snapshot
108. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = next.readable(this).value set(value) { TODO("???") } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as StateStateRecord<T> } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Extension function on StateRecord Reads ThreadLocal, returns record Noti fi es read observers
109. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = next.readable(this).value set(value) { next.writable(this) { this.value = value } } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as StateStateRecord<T> } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } Write: similar function Passes to lambda instead (synchronization) Noti fi es write observers. For a basic impl, done. Next: mergeRecords
110. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { private var next: StateStateRecord<T> = StateStateRecord(value) override var value: T get() = next.readable(this).value set(value) { next.writable(this) { this.value = value } } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as StateStateRecord<T> } private class StateStateRecord<T>(myValue: T) : StateRecord() { var value: T = myValue override fun create(): StateRecord = StateStateRecord(value) override fun assign(value: StateRecord) { this.value = (value as StateStateRecord<T>).value } } } interface StateObject { val firstStateRecord: StateRecord fun prependStateRecord(value: StateRecord) fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? = null } StateObject has one optional method Called when con fl icting writes This is how MutableState impls mutation policy
111. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { } } Override
112. internal class SnapshotMutableStateImpl<T>( value: T, override val policy: SnapshotMutationPolicy<T> ) : StateObject, SnapshotMutableState<T> { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { val previousRecord = previous as StateStateRecord<T> val currentRecord = current as StateStateRecord<T> val appliedRecord = applied as StateStateRecord<T> return if (policy.equivalent(currentRecord.value, appliedRecord.value)) current else { val merged = policy.merge( previousRecord.value, currentRecord.value, appliedRecord.value ) if (merged != null) { appliedRecord.create().also { (it as StateStateRecord<T>).value = merged } } else { null } } } } Implement Equal vs equivalent Delegate merge Return null if can’t resolve
113. What can we do with them?
114. Custom state objects class Range { var start: Int = 0 var end: Int = 0 } Custom mutable int range Implement like MutableState Next: De fi ne Record class - GO FAST next 3 slides!!
115. Custom state objects class Range { private var next = Record() var start: Int = 0 var end: Int = 0 private class Record : StateRecord() { var start: Int = 0 var end: Int = 0 override fun create(): StateRecord = Record() override fun assign(value: StateRecord) { value as Record start = value.start end = value.end } } } Next: wire up start/end properties
116. Custom state objects class Range { private var next = Record() var start: Int get() = next.readable(this).start set(value) { next.writable(this) { start = value } } var end: Int get() = next.readable(this).end set(value) { next.writable(this) { end = value } } private class Record : StateRecord() { var start: Int = 0 var end: Int = 0 override fun create(): StateRecord = Record() override fun assign(value: StateRecord) { value as Record start = value.start end = value.end } } } Next: Implement StateObject
117. Custom state objects class Range : StateObject { private var next = Record() var start: Int get() = next.readable(this).start set(value) { next.writable(this) { start = value } } var end: Int get() = next.readable(this).end set(value) { next.writable(this) { end = value } } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as Record } private class Record : StateRecord() { var start: Int = 0 var end: Int = 0 override fun create(): StateRecord = Record() override fun assign(value: StateRecord) { value as Record start = value.start end = value.end } } } Done Now let’s validate start ≤ end {tap} In the setters Next: withCurrent
118. Custom state objects class Range : StateObject { private var next = Record() var start: Int get() = next.readable(this).start set(value) { require(value <= next.readable(this).end) next.writable(this) { start = value } } var end: Int get() = next.readable(this).end set(value) { require(value >= next.readable(this).start) next.writable(this) { end = value } } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as Record } private class Record : StateRecord() { var start: Int = 0 var end: Int = 0 override fun create(): StateRecord = Record() override fun assign(value: StateRecord) { value as Record start = value.start end = value.end } } } We need to get the current value Use readable? Discuss observer implications Instead, use withCurrent…
119. Custom state objects class Range : StateObject { private var next = Record() var start: Int get() = next.readable(this).start set(value) { next.withCurrent { require(value <= it.end) } next.writable(this) { start = value } } var end: Int get() = next.readable(this).end set(value) { next.withCurrent { require(value >= it.start) } next.writable(this) { end = value } } override val firstStateRecord: StateRecord get() = next override fun prependStateRecord(value: StateRecord) { next = value as Record } private class Record : StateRecord() { var start: Int = 0 var end: Int = 0 override fun create(): StateRecord = Record() override fun assign(value: StateRecord) { value as Record start = value.start end = value.end } } } withCurrent: like readable, but doesn’t track read
120. Custom state objects class Range : StateObject { }
121. Custom state objects class Range : StateObject { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { } }
122. Custom state objects class Range : StateObject { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { val previousRecord = previous as Record val currentRecord = current as Record val appliedRecord = applied as Record if (currentRecord.start == appliedRecord.start && currentRecord.end == appliedRecord.end ) { return current } } } No con fl icts: trivial
123. Custom state objects class Range : StateObject { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { val previousRecord = previous as Record val currentRecord = current as Record val appliedRecord = applied as Record if (currentRecord.start == appliedRecord.start && currentRecord.end == appliedRecord.end ) { return current } val currentChangedStart = previousRecord.start != currentRecord.start val currentChangedEnd = previousRecord.end != currentRecord.end val appliedChangedStart = previousRecord.start != appliedRecord.start val appliedChangedEnd = previousRecord.end != appliedRecord.end if ((currentChangedStart && appliedChangedStart) || (currentChangedEnd && appliedChangedEnd) ) { return null } } } Di ff erent snapshots wrote same properties: Can’t resolve
124. Custom state objects class Range : StateObject { override fun mergeRecords( previous: StateRecord, current: StateRecord, applied: StateRecord ): StateRecord? { val previousRecord = previous as Record val currentRecord = current as Record val appliedRecord = applied as Record if (currentRecord.start == appliedRecord.start && currentRecord.end == appliedRecord.end ) { return current } val currentChangedStart = previousRecord.start != currentRecord.start val currentChangedEnd = previousRecord.end != currentRecord.end val appliedChangedStart = previousRecord.start != appliedRecord.start val appliedChangedEnd = previousRecord.end != appliedRecord.end if ((currentChangedStart && appliedChangedStart) || (currentChangedEnd && appliedChangedEnd) ) { return null } return Record().apply { start = if (currentChangedStart) currentRecord.start else appliedRecord.start end = if (currentChangedEnd) currentRecord.end else appliedRecord.end } } } Actual con fl ict resolve: Di ff erent snapshots wrote di ff erent properties Next: State di ff i ng
125. State diffing github.com/zach-klippenstein/compose-autotransition Replicate SwiftUI API Change states inside special block Animates all changes
126. State diffing suspend fun withAnimation(changes: () -> Unit) { val statesToAnimate = mutableSetOf<Any>() val targetValues = mutableMapOf<Any, Any>() val snapshot = Snapshot.takeMutableSnapshot( writeObserver = { stateObject -> statesToAnimate += stateObject } ) snapshot.enter { changes() statesToAnimate.forEach { stateObject -> targetValues[stateObject] = stateObject.value } } snapshot.dispose() coroutineScope { statesToAnimate.forEach { stateObject -> launch { animate(stateObject.value, targetValues[stateObject]) } } } } suspend fun, because animations Next: takeMutableSnapshot
127. State diffing suspend fun withAnimation(changes: () -> Unit) { val statesToAnimate = mutableSetOf<Any>() val targetValues = mutableMapOf<Any, Any>() val snapshot = Snapshot.takeMutableSnapshot( writeObserver = { stateObject -> statesToAnimate += stateObject } ) snapshot.enter { changes() statesToAnimate.forEach { stateObject -> targetValues[stateObject] = stateObject.value } } snapshot.dispose() coroutineScope { statesToAnimate.forEach { stateObject -> launch { animate(stateObject.value, targetValues[stateObject]) } } } } Take child snapshot Record every state object written to
128. State diffing suspend fun withAnimation(changes: () -> Unit) { val statesToAnimate = mutableSetOf<Any>() val targetValues = mutableMapOf<Any, Any>() val snapshot = Snapshot.takeMutableSnapshot( writeObserver = { stateObject -> statesToAnimate += stateObject } ) snapshot.enter { changes() statesToAnimate.forEach { stateObject -> targetValues[stateObject] = stateObject.value } } snapshot.dispose() coroutineScope { statesToAnimate.forEach { stateObject -> launch { animate(stateObject.value, targetValues[stateObject]) } } } } Run change function in snapshot Isolation No other snapshots see state changes Record fi nal target values
129. State diffing suspend fun withAnimation(changes: () -> Unit) { val statesToAnimate = mutableSetOf<Any>() val targetValues = mutableMapOf<Any, Any>() val snapshot = Snapshot.takeMutableSnapshot( writeObserver = { stateObject -> statesToAnimate += stateObject } ) snapshot.enter { changes() statesToAnimate.forEach { stateObject -> targetValues[stateObject] = stateObject.value } } snapshot.dispose() coroutineScope { statesToAnimate.forEach { stateObject -> launch { animate(stateObject.value, targetValues[stateObject]) } } } } Don’t apply change immediately, animate later
130. State diffing suspend fun withAnimation(changes: () -> Unit) { val statesToAnimate = mutableSetOf<Any>() val targetValues = mutableMapOf<Any, Any>() val snapshot = Snapshot.takeMutableSnapshot( writeObserver = { stateObject -> statesToAnimate += stateObject } ) snapshot.enter { changes() statesToAnimate.forEach { stateObject -> targetValues[stateObject] = stateObject.value } } snapshot.dispose() coroutineScope { statesToAnimate.forEach { stateObject -> launch { animate(stateObject.value, targetValues[stateObject]) } } } } Launch animations for every object {tap} Key: Use snapshot to capture target values without actually changing anything
131. State diffing github.com/zach-klippenstein/compose-autotransition Usage again Next: Undo
132. Undo (state recording + playback) github.com/zach-klippenstein/compose-undo Save/restore state records - support any state type Next: Persistence
133. Persistence “In-memory” tomicity onsistency solation urability ACID ACID without the D {tap} Maybe we can implement durability Next: Wrap a Room database
134. Persistence fun observeUserAsState(name: String): MutableState<User?> { val cached = cachedStates.getOrPut(name) { val flow = users.findByName(name) val state = mutableStateOf<User?>(null) val job = scope.launch { flow.collect { state.value = it } } return@getOrPut UserState(state, job) } return cached.state } Read Skip details, just sketch Get a state for a key Next: getOrPut
135. Persistence Read fun observeUserAsState(name: String): MutableState<User?> { val cached = cachedStates.getOrPut(name) { val flow = users.findByName(name) val state = mutableStateOf<User?>(null) val job = scope.launch { flow.collect { state.value = it } } return@getOrPut UserState(state, job) } return cached.state }
136. Persistence Read fun observeUserAsState(name: String): MutableState<User?> { val cached = cachedStates.getOrPut(name) { val flow = users.findByName(name) val state = mutableStateOf<User?>(null) val job = scope.launch { flow.collect { state.value = it } } return@getOrPut UserState(state, job) } return cached.state } Get observable results from Room
137. Persistence Read fun observeUserAsState(name: String): MutableState<User?> { val cached = cachedStates.getOrPut(name) { val flow = users.findByName(name) val state = mutableStateOf<User?>(null) val job = scope.launch { flow.collect { state.value = it } } return@getOrPut UserState(state, job) } return cached.state }
138. Persistence Read fun observeUserAsState(name: String): MutableState<User?> { val cached = cachedStates.getOrPut(name) { val flow = users.findByName(name) val state = mutableStateOf<User?>(null) val job = scope.launch { flow.collect { state.value = it } } return@getOrPut UserState(state, job) } return cached.state } Add to cache
139. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Discuss registerApplyObserver Discuss arguments Global snapshot where those objects were applied
140. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Find objects vended from database
141. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Going to do blocking IO
142. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Can’t enter an applied snapshot, create a read-only child
143. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Dispose to avoid leaks
144. Persistence Update Snapshot.registerApplyObserver { changedStateObjects, snapshot -> val changedDbStates = changedStateObjects.mapNotNull { if (it in cachedStates) it as MutableState<User?> else null } if (changedDbStates.isNotEmpty()) { scope.launch(Dispatchers.IO) { val readSnapshot = snapshot.takeNestedSnapshot() try { readSnapshot.enter { changedDbStates.forEach { (user, _) -> user?.let { users.updateUser(user) } } } } finally { readSnapshot.dispose() } } } } Blocking calls
145. Persistence Usage @Composable fun UserNameEditor(database: SnapshotDatabase) { val userState = remember(database) { database.observeUserAsState("Rhaenyra") } userState.value?.let { user -> BasicTextField( value = user.name, onValueChange = { userState.value = user.copy(name = it) } ) } }
146. Persistence Usage @Composable fun UserNameEditor(database: SnapshotDatabase) { val userState = remember(database) { database.observeUserAsState("Rhaenyra") } userState.value?.let { user -> BasicTextField( value = user.name, onValueChange = { userState.value = user.copy(name = it) } ) } }
147. MutableState for Jetpack Datastore github.com/zach-klippenstein/statedatastore Save/restore state records - support any state type Next: Persistence
148. Snapshots are Git for your variables If you remember, nothing else, snapshots are git for your variables
149. Further reading: More info about implementing custom StateObjects: bit.ly/45NPxxH Whitepaper on multiversion concurrency control: bit.ly/43tHZyw Slides: bit.ly/45PDvnC
150. Questions? @zachklipp.com More info about implementing custom StateObjects: bit.ly/45NPxxH Whitepaper on multiversion concurrency control: bit.ly/43tHZyw Slides: bit.ly/45PDvnC androiddev.social/@zachklipp