Dart
199 bites tagged Dart — interview questions with model answers, and 60-second explainers.
Finding Widgets with Flutter's Finder Class
Finder is your magnifying glass for widget tests, letting you locate specific widgets in the tree. It describes what to find, while the WidgetTester does the actual finding. The footgun is assuming a finder returns only one widget when it might match several.
Dart's `expect` and Matchers: Writing Better Tests
Dart's `expect` and Matchers are a grammar for your tests, letting you define complex rules beyond simple equality. Use them to verify values, check for exceptions, and test async Futures/Streams.
Unit Testing in Dart: Verify Your Logic in Isolation
A unit test is a microscope for your code. It checks a single function or class in isolation, ensuring it behaves correctly without worrying about the UI or network. Use it for business logic, not for testing rendered widgets or API calls.
Background Execution and Services in Flutter
Think of background execution as a helper doing heavy lifting off-screen. It keeps your app's UI smooth by running tasks like data processing on a separate thread (Isolate). The footgun is that isolates don't share memory; you must pass data explicitly.
BasicMessageChannel: A Coded Pipe to Native
A BasicMessageChannel is a raw data pipe between Dart and native code that uses a "codec" to translate objects into binary. Use it for streaming data or custom types not handled by MethodChannel. The footgun is a codec mismatch, which causes runtime crashes.
Dart FFI: Calling C Code from Dart
Dart FFI is a bridge to the C world, letting you call native C libraries directly from Dart. Use it to access OS APIs or high-performance C/C++ code. The footgun: you must manually manage native memory, risking crashes or leaks if you forget to `free`.
Pigeon: Type-Safe Platform Channels in Flutter
Pigeon acts like a contract for your app's native code, generating type-safe platform channels from a single definition. This replaces manual, error-prone MethodChannel code. The footgun: Swift types default to structs; use `@SwiftClass` for class features.
Platform Views: Embedding Native UI in Flutter
Platform Views cut a hole in your Flutter UI to show a native component. Use them to embed UI that can't be rebuilt in Dart, like Google Maps or a native WebView. Be warned: they are resource-heavy and can hurt performance if overused.
Flutter Platform Channels: Talking to Native Code
Platform Channels are a telephone line between your Dart code and native device APIs. Use them to access features like battery level or integrate a native SDK not available in Dart.
Dart's Platform Class: Querying the Host Environment
Think of Dart's `Platform` class as a runtime detective for your app. It answers "where am I running?" by checking the OS, environment variables, and more. Use it to show different UI on iOS vs. Android.
Flutter Packages: Bridging Dart to Native Features
Think of packages as pre-built bridges to native device features. They let your Dart code access the camera or GPS without you writing the complex, platform-specific code.
Canvas Transformations: Moving the Paper, Not the Pen
Think of Flutter's Canvas transformations not as moving your drawing, but as moving the coordinate system itself. This is key for custom painters, like rotating the canvas to draw tick marks on a dial.
Flutter's Physics Simulations: The Simulation Class
Flutter's `Simulation` class is the engine for physics-based animations, modeling a 1D object's position and velocity over time. It powers realistic scrolling, springs, and gravity effects.
Flutter's Path Class: Drawing Custom Shapes
Flutter's Path is a digital pen for drawing any custom shape. Use it for complex icons, charts, or clipping widgets into non-rectangular forms. The footgun: forgetting `moveTo` will connect separate parts of your drawing with an unwanted line.
Staggered Animations: Choreographing UI Changes
A staggered animation is a domino effect for your UI. Instead of animating everything at once, you sequence animations with slight delays for a more fluid, polished feel. Use it for list items appearing one by one. The footgun is timing: too long feels slow.
CustomPaint: Drawing Your Own Widgets in Flutter
CustomPaint is your blank canvas widget; CustomPainter is the artist that draws on it. Use them for custom charts or unique UI. The footgun: shared canvases can cause blend modes to erase other widgets, so use `saveLayer` sparingly.
Flutter's Tween: The Recipe for Animation
A Tween is a recipe for animation, not the animation itself. It maps a 0.0-1.0 progress value to a concrete value, like a color or position. Use it with an AnimationController to smoothly transition a widget's properties.
AnimationController: The Conductor of Your Animation
An AnimationController is the conductor for your animation's timing. It produces values from 0.0 to 1.0 over a duration, letting you play, reverse, or stop animations. Use it to drive widgets like `SlideTransition`.
CurvedAnimation: Animate with Easing and Personality
CurvedAnimation makes animations feel natural by applying a timing curve to another animation. Instead of linear motion, widgets can ease-in or bounce. Footgun: Elastic curves can overshoot the standard 0.0-1.0 range, causing unexpected UI behavior.
TweenAnimationBuilder: Animate Anything Implicitly
TweenAnimationBuilder animates any widget property without a complex AnimationController. Just give it a target value, duration, and curve. Use it for one-off animations where a full controller is overkill.
Isar: A Modern NoSQL Database for Flutter Apps
Isar is a fast, local NoSQL database for Flutter, offering static typing and ACID guarantees. Use it for on-device persistence in iOS, Android, and desktop apps. Don't mistake it for a remote database; Isar is for local storage, not cloud sync.
Drift: Type-Safe SQL in Dart & Flutter
Drift gives your raw SQL queries compile-time safety. Instead of parsing maps, its build-time analyzer validates your SQL and generates typed Dart objects for results. Use it to write complex queries without risking runtime errors from typos or schema changes.
Drift Schema Migrations: Evolving Your Database Safely
Think of schema migrations as a recipe for upgrading your app's database from an old version to a new one. You'll use them whenever you add a table or column in Drift. The footgun is forgetting to bump `schemaVersion`; your migration won't run.
Hive: A Fast, Local Key-Value Store for Dart
Hive is a lightweight key-value database for Dart, acting like a persistent, super-fast Map. Use it to store simple data like user settings or cache API responses locally.
Get Dart bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.