Question 1

How do you approach a live-coding task? Describe your process step by step.

Accepted Answer

Sometimes this is asked outright, but really you answer it with your behaviour in every live-coding session. Describe six steps — and actually follow that order in the interview: 1. Clarify: input size, empty/null cases, whether order matters, the expected output type. One to two minutes. 2. Example and edge cases: agree the expected output on one simple input, then enumerate the boundaries (empty, single element, duplicates, ties). 3. Approach and complexity: before coding, one sentence with the plan and the O(...) cost. I also name one alternative and why I did not pick it. 4. Narrate while typing: every decision spoken — update or putIfAbsent, List or Iterable. 5. Dry-run: walk the example line by line, including the empty input. 6. Trade-offs and a test plan: what I would do differently and which tests I would write. Close with your stance: "What matters to me is that the interviewer can see my reasoning — because at work I don't write code alone either, I explain it and discuss it."

Question 2

You are stuck on a task and cannot see a way forward. What do you do?

Accepted Answer

Answer as a sequence of behaviours, because the question is really about how you work under pressure. 1. Break the silence: "Let me think out loud for a moment." Silence gives the interviewer nothing to grade. 2. Restate the problem: I turn the requirement into a mechanism in my own words — "so every new input must cancel the previously pending operation". Often the solution falls out of that sentence. 3. Simplify: shrink the problem — "let me solve it for one element first" — or write the brute-force version. A simple working solution beats an unfinished perfect one. 4. Voice the options and choose: two approaches, their costs, and why I pick one. 5. Ask for a hint: "I'm stuck here, could you point me in a direction?" That is not a penalty — asking for help in time is valued at work too. Finish with a line about calibration: "I think it matters to say clearly what I don't know — for example I don't recall the exact fake_async API, but I know the idea is advancing a virtual clock. That kind of honesty helps in a team as well."

Question 3

How do you defend the solution you wrote? What do you say when the interviewer says "this could be done differently"?

Accepted Answer

This is a hidden test: the interviewer may say it precisely to probe you — not because the code is wrong, but to see your reaction. Two wrong reactions: (1) instantly agreeing and rewriting everything — it shows you did not understand the basis of your own solution; (2) getting defensive and digging in — a bad signal about working in a team. The right reaction has three steps: 1. Understand the alternative: "Just to check — you mean a sorted list instead of a Map?" Clarify first. 2. Compare both against criteria: time/memory, readability, testability, team familiarity. "Yours saves memory, mine keeps lookup at O(1)." 3. State the deciding criterion: "At a few thousand elements the difference is not practical, so I'd take readability. At millions, your version is the right one." If the alternative genuinely is better, say so plainly: "Agreed, that's better — mine makes an extra pass." Changing your mind with a reason is a strong signal; never changing it is a weak one.

Question 4

How do you prepare, in terms of Dart knowledge, for an interview?

Accepted Answer

This is not a "what do you read?" question — it probes whether you have a learning system. Answer concretely and personally. My approach has three layers: Mechanisms: the event loop, the microtask and event queues, the isolate model, null safety, const canonicalisation. These are not memorised — once understood, the answers to most other questions fall out of them. So I invest in knowing the "why". A reflex list: the classic pitfalls (a forgotten await, !, collection equality, lazy Iterable). I keep these as a code-review habit. Three or four stories from my own work: a real bug, a real decision, a real trade-off. Being able to attach one concrete example to any technical question makes answers instantly credible. Practical preparation: I answer rapid-fire questions out loud (not in writing — speaking is a separate skill), and I solve small problems against a timer while narrating. The honesty part: I note my weak areas in advance so I can admit them calmly in the interview. Trying to hide a gap always costs more than owning it.

Question 5

You are shown badly written Dart code and asked to review it. How do you proceed?

Accepted Answer

This format tells an interviewer the most, because it exposes technical knowledge and team behaviour at the same time. Give it structure — do not list random remarks. I split it into three levels and announce that up front: 1. Correctness (the code is wrong): a forgotten await, mutation while iterating, comparing collections with ==, null hidden behind !, a subscription never disposed. These are blocking. 2. Design (it works but is hard to live with): a class doing too much, dependencies constructed inside (untestable), business logic mixed with I/O, swallowed exceptions. 3. Style (naming, formatting, small cleanups): I mention these last and briefly — and add that this level is really the linter's job, not a human's. Scan out loud: "First the async... then the nulls... then the collections..." Even if you miss one defect, the systematic reading shows. Tone matters (a senior signal): address the code, not the author, and give the reason for each point: "There's no await here, so the function returns before the work is done and the error bypasses the try/catch." Note one or two good things if they exist. Finish with priorities: "Two of these are blocking for me, the rest can wait for the next PR" — showing you know how real code review is run.

Question	Model answer (20-30 seconds)
Difference between `const` and `final`?	`final` is assigned once and its value may be computed at runtime (`final now = DateTime.now()`). `const` must be fully known at compile time and is deeply immutable; `const` objects with equal arguments are canonicalised, so `identical` returns `true` for them.
Difference between `?.` and `!`?	`?.` skips the call and yields `null` when the receiver is null. `!` is a promise to the compiler that the value is non-null; if you are wrong it throws at runtime. `?.` is safe, `!` needs proof.
What is `late` for?	Two things: initialising a non-nullable field after the constructor, and lazy computation (`late final x = expensive()` runs on first access, then caches). The price: a compile-time check becomes the risk of a runtime `LateInitializationError`.
Difference between a `sealed` class and an `enum`?	An `enum` is a fixed set of values; a `sealed` class is a fixed set of subtypes, each with its own fields. Both make `switch` exhaustive, but `sealed` can carry data: `Loading`, `Success(data)`, `Failure(error)` — impossible with an enum.
Difference between a `mixin` and an interface?	A `mixin` provides implementation — you attach it with `with` and get the methods. `implements` only imposes a contract: you write every member yourself. Every Dart class also defines an implicit interface, so `implements SomeClass` is legal. Inheritance stays single: `extends` from one class only.
When `abstract class`, when `interface class`?	`abstract class` when you want to share code and state (it cannot be instantiated directly). Dart 3's `interface class` modifier forbids `extends` outside the library — only `implements` is allowed. That protects an API against future changes.
Difference between a record and a class?	A record is an anonymous, lightweight value bundle: `(String, int)` or `({String name, int age})`. Structural equality comes for free — no `==`/`hashCode` to write. A class gives you a name, behaviour (methods) and invariants (validation). My rule: a record to return two values from a function, a class for a domain concept.
What must you not forget when overriding `==`?	`hashCode`. The rule: equal objects must have equal hashes, otherwise the object appears as a duplicate in a `Set` and cannot be found again as a `Map` key. I use `Object.hash(a, b)`, or `Object.hashAll(...)` for a collection, and keep the fields `final`.
How is an extension method resolved?	Statically, from the variable's static type, at compile time. That is why extensions do not work on `dynamic` and cannot be overridden — the key difference from ordinary method dispatch. If two extensions collide, you disambiguate with `MyExt(obj).method()`.
Difference between `dynamic` and `Object?`?	Both hold anything, but `Object?` keeps type checking — you may call only `Object` members and need a cast or a pattern for the rest. `dynamic` switches checking off: every call compiles and may blow up at runtime. The default choice is `Object?`.
How do Dart generics behave with regard to variance?	They are covariant: a `List<int>` is also a `List<num>`. Convenient for reading, dangerous for writing — add `1.5` to a `List<int>` you are holding as a `List<num>` and you get a runtime `TypeError`. That is why I accept read-only parameters as `Iterable<T>` in shared APIs.

Question	Model answer (20-30 seconds)
Difference between a `Future` and a `Stream`?	A `Future` is one result (or one error) later, consumed with `await`. A `Stream` is zero or more events over time, consumed with `listen` or `await for`. Simple rule: an HTTP request is a Future; a WebSocket or the changes of a search field are a Stream.
Difference between the microtask queue and the event queue?	The event loop first drains the microtask queue completely, then takes one item from the event queue. Future callbacks go to microtasks; `Timer`s, I/O and user events go to the event queue. Practical consequence: schedule microtasks endlessly and the event queue never gets its turn — the app freezes.
Difference between an isolate and async?	`async` is not parallelism: everything runs on one thread and one event loop — it uses waiting time well but does not distribute CPU work. An isolate is a separate thread with separate memory; no shared state, only messages. For heavy JSON parsing or image processing, `Isolate.run(() => ...)` keeps a five-second computation off the main isolate.
What does the `async` keyword do to a function?	It wraps the result in a `Future` automatically and allows `await` inside. Key detail: the body runs synchronously up to the first `await` — calling an `async` function does not by itself defer anything.
Difference between `sync` and `async`?	`sync` returns a lazy `Iterable` — values are produced on demand. `async` returns a `Stream` — values are emitted asynchronously. In both, `yield` emits one element and `yield*` delegates a whole sequence.
Difference between a single-subscription and a broadcast stream?	A single-subscription stream can be listened to once — a second `listen` throws; events are buffered until a listener arrives. A broadcast stream accepts many listeners but buffers nothing: a late subscriber misses earlier events. Reading a file is single-subscription; UI events are broadcast.
What do `??`, `??=` and `?.` do?	`a ?? b` yields `b` when `a` is null. `a ??= b` assigns `b` to `a` only when `a` is null. `a?.m()` calls the method unless `a` is null, in which case the result is `null`. They chain: `user?.address?.city ?? 'Baku'`.
What is a `factory` constructor for?	Unlike a generative constructor it is not obliged to create a new object: it can return a cached instance, a subtype, or a different object after validation. It has no access to `this`. Typical uses: `factory User.fromJson(...)` and cache-backed instances.
What does a `const` constructor give you?	The ability to build the object at compile time: all fields must be `final`. `const` objects built with equal arguments are canonicalised — one instance in memory, and `identical` returns `true`. On the Flutter side this is valuable because it prevents needless rebuilds.
Why are immutable models and `copyWith` the norm?	An immutable object can be shared safely, never mutates behind your back, has trustworthy `==`/`hashCode` and can be cached. When something must change you create a new copy: `user.copyWith(email: newEmail)`. In state management this removes the question "who mutated this object?" entirely.
Difference between `identical(a, b)` and `a == b`?	`==` is content equality (defined by the class), `identical` asks whether it is the same object. Example: `StringBuffer('dart').toString() == 'dart'` is `true` while `identical(...)` is `false`. In everyday code always `==`; `identical` only for canonicalisation and cache questions.

Rapid-fire questions and live coding