Dart
199 bites tagged Dart — interview questions with model answers, and 60-second explainers.
sqflite: Local SQL Databases in Flutter
sqflite gives your Flutter app a private, on-device SQL database by wrapping the native SQLite engine. Use it for storing structured local data, like to-do lists or settings. The footgun: all database operations are async, so you must `await` every call.
Reading and Writing Files in Dart
Treat files as either a single string for simple cases or a stream of data for large ones. Use `dart:io` for saving user settings or processing logs. The main footgun is using synchronous methods like `readAsStringSync`, which can freeze your app.
path_provider: Find Platform-Specific File Paths
path_provider asks the OS for standard file paths instead of you guessing. Use it to find the correct documents, temp, or cache directories on any platform. The footgun: not all paths exist on all systems, so always check for null returns.
shared_preferences for Simple On-Device Storage
shared_preferences is Flutter's go-to for simple on-device key-value storage, like a persistent dictionary for user settings. Use it to save a dark mode toggle or high score. Crucially, writes are not guaranteed, so don't use it for critical data.
Cross-Platform WebSockets with `web_socket_channel`
The `web_socket_channel` package abstracts away platform differences for WebSockets, giving you a single API for web, mobile, and server. Use it for real-time features like chat or live data feeds. The footgun: always `await channel.ready` before sending data.
graphql_flutter: Client Setup and Querying
graphql_flutter connects your app to a GraphQL API via a client-provider-widget pattern. You provide a configured GraphQLClient to a GraphQLProvider, then use Query widgets to fetch data declaratively.
dio Interceptors: Middleware for Network Requests
dio Interceptors are middleware for network requests, letting you inspect and modify them before they're sent or after a response is received. Use them to globally add auth tokens, log activity, or handle token refreshes.
json_serializable: Automating JSON in Dart
json_serializable is a boilerplate-writing robot for Dart, automatically generating code to convert classes to and from JSON. It's essential for data models in network requests or local storage.
FutureBuilder: Handling Async UI in Flutter
FutureBuilder rebuilds UI based on an async operation's state, showing loading, error, or data. Use it for network requests or slow computations. Footgun: Never create the Future inside `build`; it will restart on every rebuild, causing an infinite loading…
Manual JSON Serialization with fromJson/toJson
Manually map your Dart objects to JSON by writing your own `fromJson` and `toJson` methods. This is ideal for simple data models or quick prototypes where code generation is overkill.
JSON in Dart: Using `dart:convert`
`dart:convert` is Dart's built-in translator for JSON. It turns Dart Maps into JSON strings (`jsonEncode`) for APIs and file storage, and parses JSON strings back into Maps (`jsonDecode`). The footgun: `jsonDecode` returns a generic Map, not your custom class.
Dart's `http` Package: Simple Requests vs. Composable Clients
Dart's `http` package simplifies web requests. Use top-level functions like `http.get()` for one-off calls, or a `Client` for persistent connections. Forgetting to call `client.close()` is a common footgun that leaks resources.
Freezed: Immutable State Without Boilerplate
Freezed is a Dart code generator that writes your immutable data classes for you. You define the shape, and it generates constructors, `copyWith`, and equality checks. Use it for model classes and to represent distinct states.
MobX: Automatic UI Updates with Reactive State
MobX automatically wires your reactive data to your Flutter UI, so widgets update when data changes. It's used for state management from simple counters to complex forms. The main footgun is forgetting to wrap all state mutations inside an `Action`.
GetX State Management: Simplicity Over Boilerplate
GetX simplifies Flutter state management by removing boilerplate and avoiding code generators. It offers both simple manual updates and a reactive style. Use it for rapid development where minimal setup is key.
Riverpod: Compile-Safe, Reactive State Management
Riverpod treats app state like a reactive formula. Define a piece of data once, and Riverpod automatically updates any UI that depends on it. It's ideal for network requests and shared state. Footgun: Watching a provider rebuilds the UI on every change.
Cubit: Simple State Management in Flutter
A Cubit is a simple state manager that exposes functions to directly trigger state changes. It's ideal for managing local UI state, like a counter or form data, without the complexity of events. The footgun is expecting state to update synchronously.
ValueNotifier: Notifies on Replacement, Not Mutation
ValueNotifier is a simple state holder that tells widgets to rebuild when its single value is replaced. It's great for immutable data like a boolean toggle or counter.
Provider: Pass Data Down Your Widget Tree
Think of Provider as a delivery service for your app's data, passing it down the widget tree without sending it through every widget's constructor. It's a lightweight way to manage state. The footgun: never use `.value` to create a new object.
PopScope: Guarding Your Flutter Routes
PopScope acts as a gatekeeper for back navigation in Flutter, letting you intercept and block attempts to leave a screen. Use it to show a confirmation dialog for unsaved changes. Its behavior differs on iOS; the swipe-back gesture won't trigger its callback.
PageRouteBuilder: Custom Routes Without the Boilerplate
PageRouteBuilder creates a custom page route on the fly, skipping the boilerplate of a full subclass. Just provide a `pageBuilder` for the screen's content and a `transitionsBuilder` for a unique animation.
Flutter's Router API: Declarative Navigation
The Router API treats navigation as state. You declare the page stack based on app state, giving you full control over URLs and the back button. This is vital for web/desktop apps but introduces significant boilerplate compared to simple push/pop navigation.
Flutter Named Routes: Navigate with Strings, Not Widgets
Think of named routes as URL paths for your app's screens. Instead of building a screen widget on the spot, you just tell Flutter "go to '/profile'". This is ideal for centralizing navigation in large apps and for enabling deep linking.
Imperative Navigation: Pushing and Popping Screens
Think of app screens as a stack of cards. You `push` a new screen onto the top to show it and `pop` it off to go back. It's ideal for linear flows like list-to-detail. The footgun: popping the last screen closes the app.
Get Dart bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.