Fail fast - debug fast

Catching Errors Sooner in Flutter

Have you ever faced a situation where your app's API calls fail silently? You end up spending a lot of time digging through files or reading endless logs to figure out what went wrong. It can be really frustrating! But what if your debugger could stop right when an error happens, even if you've already handled it? This is where the "fail fast - debug fast" approach comes in handy for Flutter developers.

The Problem with Hidden API Failures

Sometimes, an API call might return an error code, and your app handles it gracefully. While handling errors is good, it can hide the actual problem during development. You might not realize something is broken until much later, making debugging a longer process.

A Smart Debugging Solution

Flutter provides a neat trick to make your debugger stop whenever an exception occurs in a specific method, even if you've wrapped it in a try-catch or checked for error codes. This means you'll know about the issue immediately, allowing you to fix it faster.

How to Implement This Tip

You can use the @pragma('vm:notify-debugger-on-exception') annotation above your method. Let's look at an example:

@pragma('vm:notify-debugger-on-exception')
void getUser() {
  final response = await http.get(Uri.parse('...'));
  if (response.statusCode == 200) {
    return ...;
  }
  throw Exception('Failed to load post2');
}

What This Code Does

In this example, if the response.statusCode is not 200, an Exception is thrown. Because of the @pragma annotation, your debugger will pause at this line in getUser() during debug mode. You'll instantly see the error and can inspect the state of your app.

Why This Helps You Debug Faster

This simple line of code, @pragma('vm:notify-debugger-on-exception'), is a game-changer for debugging. It tells the Dart Virtual Machine to notify the debugger whenever an exception happens within that method. The best part? This only affects your debug builds. In your production app, nothing will change, and your error handling will work as usual. It's a powerful way to ensure you're always aware of potential issues right when they occur, embracing the "fail fast" philosophy to "debug fast."