Question 1

What is the difference between final and const?

Accepted Answer

Build the answer on two axes. Axis one — when the value is known: final stores a runtime-computed value once (final now = DateTime.now();), while a const must be fully known at compile time. Axis two — what is frozen: final freezes only the reference, const freezes the whole object (deeply immutable). Give a concrete example: final list = [1,2]; list.add(3); works, whereas const list = [1,2]; list.add(3); throws UnsupportedError at runtime. Finish with canonicalisation — the same const expression is a single object and identical() returns true — and tie that in one sentence to how it helps Flutter rebuilds.

Question 2

What is the difference between var and dynamic, and when would you use dynamic?

Accepted Answer

The core idea: var is type inference, dynamic is turning type checking off. var name = 'Ayan'; then name = 42; is a compile error because the type is fixed to String. But dynamic d = 'Ayan'; d = 42; d.fly(); compiles and throws NoSuchMethodError at runtime — the bug surfaces on a user's phone. Where to use it: only at untyped boundaries — the result of jsonDecode, platform channel replies, reflection-like code. In practice I keep dynamic at the boundary and immediately convert into a model class (User.fromJson). If I need a parameter that accepts anything, I pick Object? rather than dynamic: it accepts everything but forces an is check before calling a method, so I keep static safety.

Question 3

Explain the relationship between num, int and double in Dart. What is the trap?

Accepted Answer

num is the abstract base; int and double both extend it but are not subtypes of each other. The trap: double x = 5; works (the compiler reads the literal as 5.0), but int n = 5; double x = n; is a compile error — you need n.toDouble(). A second trap is in the operators: / always returns a double, and truncating division is ~/. A third is the platform: on the VM int is 64-bit, while dart2js maps it to a JS number on the web, so exact integers above 2^53 are not safe — for money I use int (minor units) or a Decimal package, never double. Adding why double is wrong for money (0.1 + 0.2 != 0.3) makes the answer strong.

Question 4

Why does const matter in a Flutter application?

Accepted Answer

Answer at two levels. Allocation level: a const object is created at compile time and canonicalised — the same const expression is a single instance for the whole program, so it is not re-allocated and GC pressure drops. Comparison level: when the framework compares the old and new object with identical(), const means it sees the same reference and can skip work for that subtree entirely. The practical consequence: marking stable, parameter-independent parts as const is a real saving across rebuilds. Mention that you automate this by enabling the prefer_const_constructors lint and running dart analyze in CI. One important nuance: const is only possible when every argument is a compile-time constant; an object that depends on a runtime value (say text from an API) cannot be const — that is a design constraint, not a bug.

Question 5

Do you prefer var or explicit types in code? What should the team rule be?

Accepted Answer

This is not a question with one right answer — the interviewer is testing your judgement, so propose a rule and justify it. My approach: in public APIs (method signatures, fields, return types) always write the type — it is documentation for the reader and can be enforced with the always_declare_return_types lint. For locals, if the type is obvious from the right-hand side (final user = User.fromJson(json);), final plus inference reads better; if it is not obvious (final result = repo.fetch();), I spell the type out. General default: if a variable is never reassigned, use final rather than var — that is the prefer_final_locals rule and it signals "this value never changes again" to the reader. Close by saying the decision belongs in analysis_options.yaml as a lint rule, otherwise it gets re-argued in every code review.

Property	`var`	`final`	`const`
Reassignable	Yes	No	No
When value is known	Runtime	Runtime	Compile time
Object contents mutable?	Yes	Yes	No — deeply immutable
Canonicalisation	No	No	Yes
Can be an instance field?	Yes	Yes	Only as `static const`

Variables and types

📚 Sources and documentation