Question 1

Rapid-fire: watch, read, listen — one sentence each.

Accepted Answer

watch — subscribes and triggers a rebuild/recompute on change; it belongs in build and provider bodies. read — returns the current value without subscribing; it belongs in callbacks. listen — subscribes without rebuilding; it is for side effects (snackbars, dialogs, navigation). Reinforce with one extra sentence: "Using read to avoid watch is called out in the official docs as making code brittle."

Question 2

Rapid-fire: the three bugs you see most often in state management?

Accepted Answer

1. Mutable state → the UI doesn't update: a list is mutated in place and == sees no difference (bloc's duplicate-state rule, the select filter in Provider/Riverpod). 2. A side effect in build → navigating twice or two snackbars: when the rebuild repeats, so does the effect. 3. Touching state after disposal → a crash: async work returns while the notifier/bloc is already closed; you need a mounted/ref.mounted check or request cancellation. Add a one-sentence fix for each — it makes the answer sound experienced.

Question 3

Rapid-fire: what is ProviderScope and why is it needed?

Accepted Answer

ProviderScope is the container that holds the state of Riverpod providers, placed at the app's root. The providers themselves are global final variables, but their values live inside that scope. Add one sentence to make the significance clear: "That is why global providers do not mean global state — each ProviderScope (and each ProviderContainer in tests) holds its own state."

Question 4

Rapid-fire: difference between BlocSelector and buildWhen?

Accepted Answer

BlocSelector selects one value from the state and runs the builder only when that value changes; per the docs the selected value must be immutable. buildWhen is a predicate: it compares the previous and current state and returns whether to rebuild. State the practical difference in one sentence: "BlocSelector makes the intent visible in code — the value you depend on is written in the selector; buildWhen is a condition that can be forgotten when a new field is added."

Question	Short answer
What does `setState` do?	It changes state and marks the widget dirty; all descendants of that `State` rebuild.
Difference between `context.watch` and `context.read`?	`watch` subscribes and triggers rebuilds; `read` only reads and belongs in callbacks.
What is `InheritedWidget` for?	Passing data down the tree and notifying dependents via `updateShouldNotify`; Provider wraps it.
When does a `ValueNotifier` notify?	When the new value is not equal to the old one under `==`.
Where is `ref.watch` used in Riverpod?	In `build` and in a provider's body; the docs call it the go-to choice.
What is `AsyncValue`?	A Riverpod type unifying loading/error/data in one sealed type.
What does `autoDispose` do?	Clears a provider's state when no listener remains; on by default with codegen.
What is `family` for?	Passing an argument to a provider; state is kept separately per argument.
Difference between Cubit and Bloc?	Cubit changes state through methods, Bloc through events; Bloc adds traceability and event transformations.
How does bloc handle duplicate states?	When `state == nextState`, no change occurs.
Why is `BlocListener` needed?	For side effects without a rebuild: snackbars, dialogs, navigation.
Why use `Equatable`?	To give state value semantics; without `==` the rebuild filters cannot work.

Question	Short answer
"The UI doesn't update" — the first three suspects?	A non-subscribing read (`read`), no notification sent, and `==` seeing no difference because the state is mutable.
Cause of `ProviderNotFoundException`?	No such provider above the `context` used for the read (a dialog, a new route, its own context).
How do you replace a dependency in a Riverpod test?	`ProviderContainer.test(overrides: [...])` or `ProviderScope(overrides: [...])`.
What is `blocTest`'s `seed` parameter?	It seeds an initial state so the test starts from a given situation.
What does the `droppable` transformer do?	Drops events added while one is being processed (preventing double payments).
Using `context` after an `await`?	You need a `mounted` check; the `use_build_context_synchronously` lint catches it.
Where should state live — the official answer?	UI state in the view model, shared/session state in a repository; services hold none.
What does a `const` constructor give performance?	It lets Flutter short-circuit most of the rebuild work — an official recommendation.
How do you measure rebuilds?	DevTools → Performance → Track Widget Builds.
`valueOrNull` in Riverpod 3?	Renamed to `value`; and `AsyncValue` became sealed.
Where is `mapEventToState`?	Removed in bloc v8.0.0 in favour of `on<Event>`.
Which library performs best?	All three share the same mechanism; performance is set by subscription scope and immutability.

Rapid-fire questions

📚 Sources and documentation