Q: What are the differences between `List`, `Set`, and `Map` in Dart?

`List ` is an ordered, indexable collection — Dart's equivalent of an array. By default it's growable, but `List.unmodifiable` and `const []` give you immutable versions. `Set ` is an unordered collection of unique elements; uniqueness is determined by `==` and `hashCode`. `Map ` is a key-value collection where keys are unique (again by `==`/`hashCode`). All three have literal syntax: `[1, 2, 3]`, `{1, 2, 3}`, and `{'a': 1, 'b': 2}`. A subtle gotcha: `{}` is an empty Map, not an empty Set — to get an empty Set you write ` {}` or `Set ()`. All three support spread (`...`), if-elements, and for-elements in their literals, which is unusually expressive compared to other languages.

Question 1

Is Dart only for Flutter in 2026?

Accepted Answer

Almost. There is a small server-side Dart ecosystem (shelf, dart_frog) and Google uses Dart internally for some backend services, but in the open job market, ~95% of Dart roles are Flutter mobile or Flutter web. If you're investing in Dart, plan to learn it in tandem with Flutter — the Dart-only roles are rare.

Question 2

How much does a Flutter/Dart developer earn in India?

Accepted Answer

₹6-20 LPA in 2026 for mid-to-senior Flutter developers, with juniors at ₹4-7 LPA and leads/principals at ₹25-40 LPA. Top payers: Razorpay (mobile team), Swiggy, NyKaa, Tata Digital, Cred, PhonePe, and Flutter consultancies (Nevercode, Somnio Software). Specialised areas (FinTech mobile, fintech KYC apps with FFI, real-time apps) sit at the upper end.

Question 3

Should I learn Dart 3 features or stick with Dart 2 patterns?

Accepted Answer

Learn Dart 3 — records, patterns, switch expressions, and sealed classes are not optional in 2026. Most active Flutter codebases are on Dart 3.3+ and use these features pervasively. The minimum Dart version supported by current Flutter releases is well past 3.0, so legacy-only patterns are increasingly a flag in code review.

Question 4

How does Dart compare to Kotlin or Swift for mobile development?

Accepted Answer

Dart is the language of Flutter, so it competes with Kotlin+Jetpack Compose (Android) and Swift+SwiftUI (iOS) at the platform level. Single-platform native apps still get a slight edge on platform-specific polish and performance ceiling. Flutter wins on cross-platform code-sharing — one codebase covering iOS, Android, web, and desktop — and on UI consistency across platforms. For startups optimising for engineer time, Flutter usually wins; for platform-flagship apps (banking apps with deep native SDK integration), native still wins.

Question 5

What's the best way to learn Dart for a Flutter interview?

Accepted Answer

Build a non-trivial app — a real one, not a counter demo. Pick something with auth, list-with-pagination, a form, and offline state, and ship it end-to-end. Then read `effective Dart` (the official style guide), do the official 'Dart language tour', and practise patterns + records + sealed classes specifically since they trip up candidates who learned Dart 2 first. For the interview itself: be ready to explain null safety in depth, walk through async/await + Streams + Isolates, and discuss state management trade-offs.

Question 6

What is Dart and why was it created?

Accepted Answer

Dart is a client-optimised, statically-typed, object-oriented programming language developed by Google. Originally announced in 2011 as a JavaScript alternative for the browser, it pivoted in 2018 when Flutter shipped and became the language's killer app. Dart was designed to feel familiar to anyone who knows Java, C#, or JavaScript while solving problems specific to building UI: hot-reload friendly compilation, a garbage collector tuned for short-lived UI objects, sound static types that catch bugs at compile time, and the ability to compile to native ARM/x64 (for mobile), JavaScript (for web), and self-contained executables (for desktop). It has two compilation modes — JIT for development hot-reload and AOT for production builds — which is core to why Flutter feels so fast both to develop in and to ship.

Question 7

What is sound null safety in Dart and why does it matter?

Accepted Answer

Sound null safety, added in Dart 2.12 (2021), means the type system distinguishes between types that can be null and types that cannot. A variable of type `String` can never be null; only `String?` can. The compiler enforces this — you cannot pass a nullable to a non-nullable position without explicit handling. 'Sound' means the guarantee holds at runtime too: there is no escape hatch where a `String` could secretly be null at execution time (unlike Kotlin's platform types or TypeScript's `strict: false`). The payoff is huge in practice: the entire class of `NullPointerException` bugs that haunt Java and pre-2021 Dart code mostly disappears, and the compiler can optimise away null checks for non-nullable types.

Question 8

What's the difference between `final`, `const`, and `var` in Dart?

Accepted Answer

All three relate to variable mutability and timing. `var` declares a mutable variable whose type is inferred from the initializer. `final` declares a variable that can only be assigned once, but its value is computed at runtime — useful for things like `final timestamp = DateTime.now();`. `const` declares a compile-time constant — the value must be knowable at compile time (literals, const constructors). The crucial distinction in Flutter: `const` widgets are cached and reused across rebuilds, which is a major performance optimization. `final` widgets get rebuilt every time. The Flutter linter literally warns you to use `const` constructors where possible because of this.

Question 9

What are the differences between `List`, `Set`, and `Map` in Dart?

Accepted Answer

`List` is an ordered, indexable collection — Dart's equivalent of an array. By default it's growable, but `List.unmodifiable` and `const []` give you immutable versions. `Set` is an unordered collection of unique elements; uniqueness is determined by `==` and `hashCode`. `Map` is a key-value collection where keys are unique (again by `==`/`hashCode`). All three have literal syntax: `[1, 2, 3]`, `{1, 2, 3}`, and `{'a': 1, 'b': 2}`. A subtle gotcha: `{}` is an empty Map, not an empty Set — to get an empty Set you write `{}` or `Set()`. All three support spread (`...`), if-elements, and for-elements in their literals, which is unusually expressive compared to other languages.

Question 10

How does string interpolation work in Dart?

Accepted Answer

Dart uses `$variable` for simple interpolation and `${expression}` for arbitrary expressions inside double-quoted strings. The expression form runs `toString()` on the result. Multi-line strings use triple-quotes. Raw strings (prefix `r`) disable interpolation — useful for regex patterns. Strings are immutable and the `+` operator works, but for performance-critical hot paths (like building large JSON), prefer `StringBuffer` to avoid allocating intermediate strings.

Question 11

What is the difference between named and positional parameters?

Accepted Answer

Positional parameters come in order: `greet('Asha', 27)`. Named parameters are passed by name: `greet(name: 'Asha', age: 27)`. In Dart you mark parameters as named by wrapping them in `{}` in the signature. Named parameters can be required (with the `required` keyword) or optional (with a default value). This is the convention all over Flutter — `Container(width: 100, height: 50, color: Colors.red)` reads as a configuration object rather than guessing-the-order. Optional positional parameters use `[]` and are mostly legacy; new APIs almost always use named parameters because they're far more readable at call sites with three or more arguments.

Question 12

What are arrow functions in Dart?

Accepted Answer

Arrow syntax (`=>`) is a shorthand for a function whose body is a single expression. `int double(int x) => x * 2;` is exactly equivalent to `int double(int x) { return x * 2; }`. The arrow form cannot contain statements — only an expression. It is heavily used in Flutter callbacks (`onPressed: () => print('tapped')`) and in `map`/`where`/`reduce` style iterator chains where multi-line lambdas would be visually noisy.

Question 13

How do you handle errors in Dart with try/catch?

Accepted Answer

Dart's `try/catch/finally` is similar to Java's. You can catch by type (`on FormatException catch (e)`) or generically (`catch (e, stackTrace)`). `rethrow` preserves the original stack trace, which is critical for debugging — never use `throw e` to re-raise. `finally` always runs, even on `return` or `throw`. Dart distinguishes between `Error` (programmer bugs — assertion failures, type errors, you shouldn't catch them) and `Exception` (recoverable conditions like network failures — you should catch them). In async code, errors propagate through Futures and are caught by `try/catch` around `await` or `.catchError()` on the Future.

Question 14

What are getters and setters in Dart?

Accepted Answer

Getters and setters are special methods that look like field access at the call site. `class Circle { double radius; double get area => pi * radius * radius; }` lets callers write `circle.area` (no parentheses) even though `area` is computed. Setters use `set name(value)` syntax. All fields in Dart actually get implicit getters and setters generated — that's why you can override field access by adding an explicit getter without changing the API. This is heavily used in immutable models (only getters, no setters) and in reactive frameworks where the setter triggers a notification.

Question 15

What is the difference between `==` and `identical()` in Dart?

Accepted Answer

`==` calls the operator overload — by default it's identity-based (same as `identical()`), but most classes override it for value equality. `identical(a, b)` checks reference identity — are these literally the same object in memory. For primitive types (int, double, String, bool), Dart canonicalises literals, so `identical('foo', 'foo')` is `true` and `identical(1, 1)` is `true`. When you override `==`, you MUST also override `hashCode` — otherwise objects equal by `==` get different hashes, breaking Sets and Maps. Dart 3.0+ records auto-implement structural equality so you usually don't need to override these for simple data classes anymore.

Dart Interview Questions

What is Dart and why was it created?

What is sound null safety in Dart and why does it matter?

What's the difference between `final`, `const`, and `var` in Dart?

What are the differences between `List`, `Set`, and `Map` in Dart?

How does string interpolation work in Dart?

What is the difference between named and positional parameters?

What are arrow functions in Dart?

How do you handle errors in Dart with try/catch?

What are getters and setters in Dart?

What is the difference between `==` and `identical()` in Dart?

What is the `dynamic` type and when should you use it?

What is the Dart event loop and microtask queue?

Explain Futures and how async/await works in Dart.

What are Streams in Dart and how do they differ from Futures?

What are isolates and when should you use them?

What are mixins in Dart and how are they different from inheritance?

What are extension methods in Dart?

Explain the `late` keyword and its gotchas.

What are records in Dart 3 and when should you use them?

Explain pattern matching and switch expressions in Dart 3.

What are sealed classes and class modifiers in Dart 3?

How does state management work in Flutter, and what are the trade-offs of Provider, Riverpod, and Bloc?

Explain the Flutter widget lifecycle and where Dart code runs.

What is `FutureOr<T>` and when do you encounter it?

How do you handle JSON serialization in Dart?

How would you architect a Flutter app for performance at scale, and what Dart-level optimisations matter most?

Explain Dart FFI and when you would call into C/Rust code.

How does code generation with build_runner work, and when should you reach for it?

How does Dart's tree-shaking work, and what code patterns defeat it?

How would you design an offline-first Flutter app with conflict resolution?

Companies Hiring Dart

Salary Insights

Frequently Asked Questions

Is Dart only for Flutter in 2026?

How much does a Flutter/Dart developer earn in India?

Should I learn Dart 3 features or stick with Dart 2 patterns?

How does Dart compare to Kotlin or Swift for mobile development?

What's the best way to learn Dart for a Flutter interview?

Introduction