Let’s explore the pros and cons of using component methods in Flutter, and whether it has any real impact on performance.

Short Answer

No, splitting widgets into methods does not improve performance directly. However, it does offer significant benefits in terms of readability, maintainability, and developer productivity.

To improve performance, you’ll want to break widgets into independent widget classes, not just internal methods.

How Flutter Handles Build Methods

In Flutter, the build() method gets called every time the widget needs to be redrawn. This means any method you call inside build() is executed every time the parent widget rebuilds.

Example:

Widget build(BuildContext context) {
  return Column(
    children: [
      _buildHeader(),
      _buildContent(),
      _buildFooter(),
    ],
  );
}

Widget _buildHeader() => Text("Header");
Widget _buildContent() => Text("Main Content");
Widget _buildFooter() => Text("Footer");

All three methods are re-invoked every time build() is triggered. There is no performance optimization involved in splitting them this way.

Why Developers Use Helper Methods

Even without performance benefits, helper methods offer:

•  Cleaner code: Shorter build() methods are easier to scan and understand.
•  Better organization: Logical separation of UI parts improves clarity.
•  Simplified debugging: Isolating UI chunks makes bugs easier to track.

But again, these benefits are developer-centric, not performance-focused.

Methods vs. Widgets: A Real Comparison

Feature	Helper Methods	Component Widgets
Improves readability	Yes	Yes
Reduces rebuilds	No	Yes (if const)
Can be reused elsewhere	No	Yes
Allows isolated testing	Difficult	Easy
Benefits from const	No	Yes

When to Use Each Approach

Use methods when:

• You’re aiming for cleaner and shorter build() methods
• The section of UI is small or unlikely to be reused
• Performance is not an immediate concern

Use widgets when:

• You want to reuse the component across screens or widgets
• You want to reduce unnecessary rebuilds
• You want to make parts of the UI const or testable

Example Using Widgets:

Widget build(BuildContext context) {
  return Column(
    children: const [
      UserAvatar(),
      UserNameDisplay(),
      LogoutButton(),
    ],
  );
}

class UserAvatar extends StatelessWidget { ... }
class UserNameDisplay extends StatelessWidget { ... }
class LogoutButton extends StatelessWidget { ... }

If each of these components doesn’t depend on changing state, marking them as const means they won’t rebuild unless necessary.

Monitoring Rebuilds

If you’re concerned about rebuild performance, use Flutter’s developer tools:

• Flutter DevTools: See which widgets rebuild in real-time.
• Performance overlay: Visual indicator for rendering performance.
• debugPrintRebuildDirtyWidgets: Console output of rebuilt widgets.

These tools help you identify which widgets are causing rebuilds and let you fine-tune your architecture accordingly.

Key Takeaways

• Splitting widget trees into methods helps make your code more maintainable — but has zero performance impact.
• Use independent widgets for actual performance gains, especially when paired with the const constructor.
• Choose the right balance: structure your UI for clarity, but extract widgets when performance or reusability becomes important.

Final Thoughts

Optimizing a Flutter app is about smart rebuild management and clear code structure. Component methods are a great tool for clean architecture — but they won’t make your app faster. Save performance tuning for when you break into dedicated widgets.

If you learned something useful, please support this article with a clap and share it with your Flutter team or community!

Here’s a fully updated, concise guide covering all essential Flutter and Dart CLI commands.

Flutter CLI Essentials

Flutter CLI helps you manage your app lifecycle from project creation to release builds. Here’s your cheat sheet:

flutter create <project_name>         # Start a new Flutter project
flutter run                           # Launch the app on a connected device
flutter run -d <device_id>            # Run app on a specified device
flutter build <platform>              # Compile app for production (apk, ios, web, etc.)
flutter build ipa                     # Build iOS IPA file (macOS only)
flutter build web                     # Build web version of your app
flutter doctor                        # Diagnose environment setup issues
flutter pub get                       # Install dependencies listed in pubspec.yaml
flutter pub upgrade                   # Update to latest compatible packages
flutter pub outdated                  # Show outdated packages
flutter pub add <package>             # Add a new package dependency
flutter pub remove <package>          # Remove a package
flutter clean                         # Clear temporary build files
flutter analyze                       # Perform static code analysis
flutter test                          # Run unit tests
flutter test --coverage               # Run tests with coverage report
flutter format .                      # Format all Dart files
flutter gen-l10n                      # Generate localization code
flutter downgrade                     # Revert to previous Flutter version
flutter upgrade                       # Update Flutter to latest version
flutter channel                       # Switch between stable, beta, and dev channels
flutter config                        # Enable or disable features like web or desktop
flutter devices                       # List all connected devices
flutter logs                          # Stream real-time logs
flutter symbolize                     # Decode crash stack traces

Dart CLI Essentials

Dart CLI lets you build tools, scripts, and servers. Here are the commands you need to know:

dart create <project_name>            # Generate a new Dart project
dart run                              # Execute a Dart file or app
dart run <package>:<command>          # Execute a command from a dependency package
dart compile <format>                 # Compile Dart code to native or JS
  dart compile exe file.dart          # To native executable
  dart compile js file.dart           # To JavaScript

dart pub get                          # Fetch project dependencies
dart pub upgrade                      # Upgrade packages
dart pub outdated                     # View dependency status
dart pub add <package>                # Add a package
dart pub remove <package>             # Remove a package
dart pub cache repair                 # Fix the pub cache
dart pub global activate <package>    # Install a global CLI tool
dart pub global deactivate <package>  # Remove global package
dart pub global run <package>         # Run a globally installed command
dart analyze                          # Analyze code for errors or style issues
dart test                             # Run tests (requires test package)
dart test --coverage                  # Get test coverage results
dart format .                         # Format Dart files
dart fix --apply                      # Automatically fix code issues
dart doc                              # Generate project documentation

Pro Tips

• Add CLI shortcuts to scripts or Makefiles for repeatable workflows.
• Use aliases in your shell for frequent commands.
• Always run flutter doctor if you face issues after an upgrade.

Final Thoughts

CLI commands are more than shortcuts—they’re a developer’s toolkit. Mastering these will boost your speed, improve quality, and help you build better apps faster.

If you found this helpful, please support the article with a few claps and share it with your developer friends!

In Swift, an escaping closure is a closure that outlives the function it’s passed to. The term “escaping” means the closure can “escape” the scope of the function it was passed to and be executed later.

Why Escaping Closures are Important

When you pass a closure to a function:

• By default, Swift assumes the closure is non-escaping, meaning it will be executed within the function’s body and won’t persist after the function returns
• If the closure needs to be stored for later execution (after the function returns), you must mark it as @escaping

When to Use @escaping

You need to mark a closure parameter as @escaping when the closure:

1. Is stored in a property, variable, or constant outside the function
2. Is passed as an argument to another function that stores it
3. Will be executed after the function returns

Common Use Cases

Escaping closures are commonly used for:

• Asynchronous operations (like network calls)
• Completion handlers
• Delegation patterns
• Storage of callback functions

Syntax Example

// Non-escaping closure (default)
func performOperation(completion: () -> Void) {
    // The closure must be called before this function returns
    completion()
}

// Escaping closure
func performAsyncOperation(completion: @escaping () -> Void) {
    // Store the closure for later execution
    DispatchQueue.main.async {
        completion() // Called after the function returns
    }
}

Memory Management Implications

Escaping closures require special attention to memory management:

• They can create reference cycles (strong reference cycles or retain cycles)
• Within an escaping closure, you need to explicitly use self (instead of implicit self)
• Often you’ll use [weak self] or [unowned self] to avoid memory leaks

Thanks for reading!

The Stack Refresher

The Stack widget allows you to layer widgets on top of one another. You can think of it like a pile of cards where each widget stacks above the previous one. By default, children inside a Stack align in the top-left corner, but we can change this behavior using widgets like Align and Positioned.

Align Widget — Relative Positioning

The Align widget allows you to place a widget relative to the parent Stack’s dimensions. It uses Alignment values, like Alignment.center, Alignment.topRight, etc.

Example: Centering an Icon

Stack(
  children: [
    Container(
      width: 200,
      height: 200,
      color: Colors.blue[100],
    ),
    Align(
      alignment: Alignment.center,
      child: Icon(Icons.star, size: 40, color: Colors.orange),
    ),
  ],
)

 This centers the star icon inside the 200×200 container.

Positioned Widget — Absolute Positioning

The Positioned widget lets you place a child based on distance from the Stack’s sides — top, right, bottom, and left.

Example: Place a button 20px from the bottom-right corner

Stack(
  children: [
    Container(
      width: 250,
      height: 250,
      color: Colors.green[100],
    ),
    Positioned(
      bottom: 20,
      right: 20,
      child: ElevatedButton(
        onPressed: () {},
        child: Text('Click'),
      ),
    ),
  ],
)

 This button always stays 20 pixels from the bottom and right edges.

Key Differences Recap

Common Mistakes and How to Avoid Them

Using Positioned without Stack

Positioned(
  top: 10,
  child: Text("Oops")
)

 Fix: Always wrap Positioned in a Stack.

Misaligning with Align

Using wrong alignment values can confuse layouts.

Align(
  alignment: Alignment(3, 3),
  child: Text('Misplaced'),
)

 Fix: Stick to standard values like Alignment.center, or use Alignment(x, y) within the range of -1.0 to 1.0.

Overlapping multiple children with no clarity

Stack(
  children: [
    Text('One'),
    Text('Two'),
  ],
)

 Fix: Use Align or Positioned to place them clearly.

Bonus Example — Combining Both

Stack(
  children: [
    Align(
      alignment: Alignment.topCenter,
      child: Text('Header'),
    ),
    Positioned(
      bottom: 10,
      right: 10,
      child: Text('Footer'),
    ),
  ],
)

 This gives a clean top and bottom layout inside a Stack.

When to Use What?

• Use Align when your layout needs to be responsive and relative to parent.
• Use Positioned when you need precise pixel control over placement.

Thanks for Reading!

If you found this article helpful, consider sharing it or leaving a comment! Your support helps keep the Flutter love flowing.

Happy Fluttering!

First, let’s organize this into several parts:

// 1. First, let's define a Country data class
data class Country(val name: String, val code: String)

// 2. Create an adapter for the RecyclerView
class CountriesAdapter(private val countries: List<Country>) : 
    RecyclerView.Adapter<CountriesAdapter.CountryViewHolder>() {
    
    class CountryViewHolder(val binding: ItemCountryBinding) : RecyclerView.ViewHolder(binding.root)
    
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): CountryViewHolder {
        val binding = ItemCountryBinding.inflate(
            LayoutInflater.from(parent.context), 
            parent, 
            false
        )
        return CountryViewHolder(binding)
    }
    
    override fun onBindViewHolder(holder: CountryViewHolder, position: Int) {
        val country = countries[position]
        holder.binding.apply {
            tvCountryName.text = country.name
            tvCountryCode.text = country.code
        }
    }
    
    override fun getItemCount(): Int = countries.size
}

// 3. MainActivity implementation
class MainActivity : AppCompatActivity() {
    
    private lateinit var binding: ActivityMainBinding
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        
        setupRecyclerView()
    }
    
    private fun setupRecyclerView() {
        val countries = getCountriesList()
        val adapter = CountriesAdapter(countries)
        
        binding.recyclerViewCountries.apply {
            this.adapter = adapter
            layoutManager = LinearLayoutManager(this@MainActivity)
            addItemDecoration(DividerItemDecoration(this@MainActivity, DividerItemDecoration.VERTICAL))
        }
    }
    
    private fun getCountriesList(): List<Country> {
        return listOf(
            Country("Afghanistan", "AF"),
            Country("Albania", "AL"),
            Country("Algeria", "DZ"),
            Country("Andorra", "AD"),
            Country("Angola", "AO"),
            Country("Antigua and Barbuda", "AG"),
            Country("Argentina", "AR"),
            Country("Armenia", "AM"),
            Country("Australia", "AU"),
            Country("Austria", "AT"),
            Country("Azerbaijan", "AZ"),
            Country("Bahamas", "BS"),
            Country("Bahrain", "BH"),
            Country("Bangladesh", "BD"),
            Country("Barbados", "BB"),
            Country("Belarus", "BY"),
            Country("Belgium", "BE"),
            Country("Belize", "BZ"),
            Country("Benin", "BJ"),
            Country("Bhutan", "BT"),
            Country("Bolivia", "BO"),
            Country("Bosnia and Herzegovina", "BA"),
            Country("Botswana", "BW"),
            Country("Brazil", "BR"),
            Country("Brunei", "BN"),
            Country("Bulgaria", "BG"),
            Country("Burkina Faso", "BF"),
            Country("Burundi", "BI"),
            Country("Cabo Verde", "CV"),
            Country("Cambodia", "KH"),
            Country("Cameroon", "CM"),
            Country("Canada", "CA"),
            Country("Central African Republic", "CF"),
            Country("Chad", "TD"),
            Country("Chile", "CL"),
            Country("China", "CN"),
            Country("Colombia", "CO"),
            Country("Comoros", "KM"),
            Country("Congo", "CG"),
            Country("Costa Rica", "CR"),
            Country("Croatia", "HR"),
            Country("Cuba", "CU"),
            Country("Cyprus", "CY"),
            Country("Czech Republic", "CZ"),
            Country("Democratic Republic of the Congo", "CD"),
            Country("Denmark", "DK"),
            Country("Djibouti", "DJ"),
            Country("Dominica", "DM"),
            Country("Dominican Republic", "DO"),
            Country("Ecuador", "EC"),
            Country("Egypt", "EG"),
            Country("El Salvador", "SV"),
            Country("Equatorial Guinea", "GQ"),
            Country("Eritrea", "ER"),
            Country("Estonia", "EE"),
            Country("Eswatini", "SZ"),
            Country("Ethiopia", "ET"),
            Country("Fiji", "FJ"),
            Country("Finland", "FI"),
            Country("France", "FR"),
            Country("Gabon", "GA"),
            Country("Gambia", "GM"),
            Country("Georgia", "GE"),
            Country("Germany", "DE"),
            Country("Ghana", "GH"),
            Country("Greece", "GR"),
            Country("Grenada", "GD"),
            Country("Guatemala", "GT"),
            Country("Guinea", "GN"),
            Country("Guinea-Bissau", "GW"),
            Country("Guyana", "GY"),
            Country("Haiti", "HT"),
            Country("Honduras", "HN"),
            Country("Hungary", "HU"),
            Country("Iceland", "IS"),
            Country("India", "IN"),
            Country("Indonesia", "ID"),
            Country("Iran", "IR"),
            Country("Iraq", "IQ"),
            Country("Ireland", "IE"),
            Country("Israel", "IL"),
            Country("Italy", "IT"),
            Country("Jamaica", "JM"),
            Country("Japan", "JP"),
            Country("Jordan", "JO"),
            Country("Kazakhstan", "KZ"),
            Country("Kenya", "KE"),
            Country("Kiribati", "KI"),
            Country("Kuwait", "KW"),
            Country("Kyrgyzstan", "KG"),
            Country("Laos", "LA"),
            Country("Latvia", "LV"),
            Country("Lebanon", "LB"),
            Country("Lesotho", "LS"),
            Country("Liberia", "LR"),
            Country("Libya", "LY"),
            Country("Liechtenstein", "LI"),
            Country("Lithuania", "LT"),
            Country("Luxembourg", "LU"),
            Country("Madagascar", "MG"),
            Country("Malawi", "MW"),
            Country("Malaysia", "MY"),
            Country("Maldives", "MV"),
            Country("Mali", "ML"),
            Country("Malta", "MT"),
            Country("Marshall Islands", "MH"),
            Country("Mauritania", "MR"),
            Country("Mauritius", "MU"),
            Country("Mexico", "MX"),
            Country("Micronesia", "FM"),
            Country("Moldova", "MD"),
            Country("Monaco", "MC"),
            Country("Mongolia", "MN"),
            Country("Montenegro", "ME"),
            Country("Morocco", "MA"),
            Country("Mozambique", "MZ"),
            Country("Myanmar", "MM"),
            Country("Namibia", "NA"),
            Country("Nauru", "NR"),
            Country("Nepal", "NP"),
            Country("Netherlands", "NL"),
            Country("New Zealand", "NZ"),
            Country("Nicaragua", "NI"),
            Country("Niger", "NE"),
            Country("Nigeria", "NG"),
            Country("North Korea", "KP"),
            Country("North Macedonia", "MK"),
            Country("Norway", "NO"),
            Country("Oman", "OM"),
            Country("Pakistan", "PK"),
            Country("Palau", "PW"),
            Country("Palestine", "PS"),
            Country("Panama", "PA"),
            Country("Papua New Guinea", "PG"),
            Country("Paraguay", "PY"),
            Country("Peru", "PE"),
            Country("Philippines", "PH"),
            Country("Poland", "PL"),
            Country("Portugal", "PT"),
            Country("Qatar", "QA"),
            Country("Romania", "RO"),
            Country("Russia", "RU"),
            Country("Rwanda", "RW"),
            Country("Saint Kitts and Nevis", "KN"),
            Country("Saint Lucia", "LC"),
            Country("Saint Vincent and the Grenadines", "VC"),
            Country("Samoa", "WS"),
            Country("San Marino", "SM"),
            Country("Sao Tome and Principe", "ST"),
            Country("Saudi Arabia", "SA"),
            Country("Senegal", "SN"),
            Country("Serbia", "RS"),
            Country("Seychelles", "SC"),
            Country("Sierra Leone", "SL"),
            Country("Singapore", "SG"),
            Country("Slovakia", "SK"),
            Country("Slovenia", "SI"),
            Country("Solomon Islands", "SB"),
            Country("Somalia", "SO"),
            Country("South Africa", "ZA"),
            Country("South Korea", "KR"),
            Country("South Sudan", "SS"),
            Country("Spain", "ES"),
            Country("Sri Lanka", "LK"),
            Country("Sudan", "SD"),
            Country("Suriname", "SR"),
            Country("Sweden", "SE"),
            Country("Switzerland", "CH"),
            Country("Syria", "SY"),
            Country("Taiwan", "TW"),
            Country("Tajikistan", "TJ"),
            Country("Tanzania", "TZ"),
            Country("Thailand", "TH"),
            Country("Timor-Leste", "TL"),
            Country("Togo", "TG"),
            Country("Tonga", "TO"),
            Country("Trinidad and Tobago", "TT"),
            Country("Tunisia", "TN"),
            Country("Turkey", "TR"),
            Country("Turkmenistan", "TM"),
            Country("Tuvalu", "TV"),
            Country("Uganda", "UG"),
            Country("Ukraine", "UA"),
            Country("United Arab Emirates", "AE"),
            Country("United Kingdom", "GB"),
            Country("United States", "US"),
            Country("Uruguay", "UY"),
            Country("Uzbekistan", "UZ"),
            Country("Vanuatu", "VU"),
            Country("Vatican City", "VA"),
            Country("Venezuela", "VE"),
            Country("Vietnam", "VN"),
            Country("Yemen", "YE"),
            Country("Zambia", "ZM"),
            Country("Zimbabwe", "ZW")
        )
    }
}

// 4. Layout files below:

// layout/activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recyclerViewCountries"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:listitem="@layout/item_country" />

</androidx.constraintlayout.widget.ConstraintLayout>

// layout/item_country.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="16dp">

    <TextView
        android:id="@+id/tvCountryName"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:textSize="16sp"
        android:textStyle="bold"
        app:layout_constraintEnd_toStartOf="@+id/tvCountryCode"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="United States" />

    <TextView
        android:id="@+id/tvCountryCode"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textColor="@android:color/darker_gray"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        tools:text="US" />

</androidx.constraintlayout.widget.ConstraintLayout>

// 5. Don't forget to add the necessary dependencies in build.gradle (app level)
/*
dependencies {
    implementation 'androidx.core:core-ktx:1.10.1'
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.9.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    implementation 'androidx.recyclerview:recyclerview:1.3.0'
    // For View Binding
    buildFeatures {
        viewBinding true
    }
}
*/

To set up this project, you’ll need to:

1. Create a new Android project with Kotlin support
2. Set up View Binding in your app-level build.gradle file
3. Create the layout files as shown above
4. Implement the Kotlin code

The implementation includes:

• A Country data class to hold country information (name and country code)
• A CountriesAdapter class that extends RecyclerView.Adapter to display the countries
• The MainActivity that sets up the RecyclerView with a complete list of countries
• XML layouts for both the main activity and individual country list items

This approach displays each country with its name and two-letter country code. The RecyclerView is configured with a LinearLayoutManager and includes dividers between items for better readability.

You can extend this implementation by:

• Adding country flags using a library like Flagkit
• Implementing search functionality to filter countries
• Adding click listeners to show more details about each country
• Using a more sophisticated data source like a remote API or database

Thank you for reading!

What Are Abstract Classes?

An abstract class is a class that cannot be instantiated on its own. It acts as a template for other classes, defining method signatures (but not implementations) that must be implemented by its subclasses.

Why Abstract Classes Matter

• They enforce a consistent interface across multiple related classes.
• They help implement polymorphism, allowing interchangeable object behavior.
• They’re useful for building scalable and testable architecture.

Example: Transport Modes App

Let’s build an example that simulates different types of transport like Car, Bicycle, and Train. Each transport method will implement a shared interface defined in an abstract class.

Step 1: Define the Abstract Class

abstract class TransportMode {
  void start();
  void stop();
  double estimatedTime(double distance); // in hours
}

This defines a contract for all transport modes — they must define start(), stop(), and a way to calculate time based on distance.

Step 2: Create Subclasses

class Car extends TransportMode {
  @override
  void start() => print("Car engine started");

  @override
  void stop() => print("Car parked");

  @override
  double estimatedTime(double distance) => distance / 60; // avg 60 km/h
}

class Bicycle extends TransportMode {
  @override
  void start() => print("Pedaling started");

  @override
  void stop() => print("Bike stopped");

  @override
  double estimatedTime(double distance) => distance / 15; // avg 15 km/h
}

class Train extends TransportMode {
  @override
  void start() => print("Train departed");

  @override
  void stop() => print("Train arrived at station");

  @override
  double estimatedTime(double distance) => distance / 100; // avg 100 km/h
}

Step 3: Use in a Flutter App

import 'package:flutter/material.dart';

class TransportApp extends StatelessWidget {
  final List<TransportMode> transports = [Car(), Bicycle(), Train()];

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text("Transport Modes")),
        body: ListView.builder(
          itemCount: transports.length,
          itemBuilder: (context, index) {
            final mode = transports[index];
            final distance = 120.0; // km

            return ListTile(
              title: Text(mode.runtimeType.toString()),
              subtitle: Text(
                "Time for \$distance km: \${mode.estimatedTime(distance).toStringAsFixed(2)} hrs",
              ),
              trailing: IconButton(
                icon: Icon(Icons.directions),
                onPressed: () {
                  mode.start();
                  Future.delayed(Duration(seconds: 1), () => mode.stop());
                },
              ),
            );
          },
        ),
      ),
    );
  }
}

void main() => runApp(TransportApp());

Real-World Use Cases

Abstract classes shine in larger projects:

• Creating base services or repositories for APIs
• Defining widgets contracts for custom UI components
• Structuring state management logic

For example:

abstract class AuthService {
  Future<void> login(String email, String password);
  Future<void> logout();
}

Then you can implement this with Firebase, Supabase, or mock versions for testing.

Summary

Abstract classes in Dart allow you to define clean, reusable interfaces and promote consistency across your Flutter app’s codebase. In this transport example, we saw how three different modes of transport could share the same interface and behave polymorphically.

Use abstract classes when you want to:

• Enforce method structure
• Create flexible yet structured class hierarchies
• Build architecture-ready code

Thanks for reading and happy Fluttering! Let me know if you’d like a diagram or banner to go with this post.

What is the Dismissible Widget?

The Dismissible widget in Flutter is a highly versatile widget that allows users to swipe away an item from a list or container, typically for actions like deletion or archiving. It enables swipe gestures to perform actions, making the UI more interactive and engaging.

Why Use the Dismissible Widget?

Dismissible widgets are especially useful in situations where you want to provide users with a convenient way to perform actions with a swipe. Common examples of this pattern include:

• Deleting an item from a list.

• Archiving messages or emails.

• Marking items as complete in to-do lists.

By integrating a Dismissible widget, you can achieve more intuitive and faster interactions.

How to Use the Dismissible Widget in Flutter?

Let’s walk through the basics of using the Dismissible widget in Flutter.

Step 1: Setting Up Your Flutter Environment

Make sure you have Flutter set up on your machine. If not, follow the official Flutter installation guide.

Step 2: Importing the Necessary Packages

To use the Dismissible widget, you need to import the Flutter material package:

import 'package:flutter/material.dart';

Step 3: Basic Structure of Dismissible

The basic structure of the Dismissible widget requires a key, an onDismissed callback, and the child widget.

Dismissible(
  key: Key(item.id), // Unique key for each item in the list.
  onDismissed: (direction) {
    // Handle dismissal, such as removing the item.
    setState(() {
      items.removeAt(index);
    });
    ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Item dismissed')));
  },
  child: ListTile(
    title: Text(item.name),
  ),
)

• key: Each Dismissible widget needs a unique key to identify it. This is essential for ensuring proper management and animation of the swipe action.

• onDismissed: This callback is triggered when the item is dismissed. Inside this function, you can specify what happens when the item is swiped, such as removing the item from the list.

• child: This is the widget inside the Dismissible widget, which is usually a ListTile or other types of widgets. It’s the content that gets swiped away.

Step 4: Putting It All Together

Let’s create a simple app where we build a swipeable list of items using the Dismissible widget.

import 'package:flutter/material.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(
          title: Text('Dismissible Widget Example'),
        ),
        body: ItemList(),
      ),
    );
  }
}

class ItemList extends StatefulWidget {
  @override
  _ItemListState createState() => _ItemListState();
}

class _ItemListState extends State<ItemList> {
  List<String> items = ['Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5'];

  @override
  Widget build(BuildContext context) {
    return ListView.builder(
      itemCount: items.length,
      itemBuilder: (context, index) {
        return Dismissible(
          key: Key(items[index]),
          direction: DismissDirection.endToStart, // Customize swipe direction.
          onDismissed: (direction) {
            setState(() {
              items.removeAt(index);
            });
            ScaffoldMessenger.of(context).showSnackBar(
              SnackBar(content: Text('${items[index]} dismissed')),
            );
          },
          child: ListTile(
            title: Text(items[index]),
            tileColor: Colors.grey[200],
            leading: Icon(Icons.delete, color: Colors.red),
          ),
        );
      },
    );
  }
}

In this example:

• We create a simple list of items.

• Each item is wrapped inside a Dismissible widget.

• When an item is swiped, the onDismissed callback is triggered, removing the item from the list.

Step 5: Customizing the Dismissible Widget

You can customize the Dismissible widget to add more interactive features, such as showing a background during the swipe or providing different actions on swipe.

For example, you can add a custom background color or icon that appears as the user swipes the item.

Dismissible(
  key: Key(items[index]),
  background: Container(
    color: Colors.red,
    child: Icon(Icons.delete, color: Colors.white),
  ),
  direction: DismissDirection.endToStart,
  onDismissed: (direction) {
    setState(() {
      items.removeAt(index);
    });
    ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('${items[index]} dismissed')));
  },
  child: ListTile(
    title: Text(items[index]),
    tileColor: Colors.grey[200],
  ),
)

In this case, when you swipe an item, a red container with a delete icon will appear behind the item. This helps enhance the UX and gives the user a visual cue that they are performing a delete action.

Step 6: Handling Multiple Swipe Directions

By default, the Dismissible widget allows only one direction for swipe (horizontal or vertical), but you can specify the direction of swipe using the direction property. You can set it to DismissDirection.horizontal, DismissDirection.endToStart, or DismissDirection.startToEnd.

Dismissible(
  key: Key(items[index]),
  direction: DismissDirection.horizontal, // Allows swiping in both directions
  onDismissed: (direction) {
    setState(() {
      items.removeAt(index);
    });
    ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('${items[index]} dismissed')));
  },
  child: ListTile(
    title: Text(items[index]),
  ),
)

Best Practices When Using Dismissible

1. Use Unique Keys: Always assign unique keys to your Dismissible widgets. This ensures that Flutter properly manages the state when items are swiped.

2. Keep the List Dynamic: When the item is dismissed, update the list accordingly by calling setState to ensure the UI reflects the changes.

3. Provide Feedback to the User: Use feedback mechanisms like SnackBars, toasts, or animations to notify the user that an item has been successfully dismissed.

4. Limit the Swipe Actions: If there are multiple swipe actions, be clear about what each swipe direction does. Avoid overwhelming users with too many actions.

Conclusion

The Dismissible widget is a powerful tool in Flutter for building interactive, swipeable UIs. By using the widget effectively, you can provide smooth user experiences and enhance the interactivity of your app. Whether you’re deleting items, archiving them, or performing other actions, the Dismissible widget helps simplify these tasks and makes your Flutter app more user-friendly.

Experiment with different customizations, gestures, and actions to find the best implementation for your app. Happy coding!

Key principles of responsive web design include:

1. Fluid grid layouts that use relative units like percentages instead of fixed pixel widths
2. Flexible images and media that scale appropriately
3. Media queries that apply different styling based on device characteristics

Here’s a simple example of responsive design using CSS:

/* Base styles for all screen sizes */
.container {
  width: 100%;
  max-width: 1200px;
  margin: 0 auto;
}

/* Media query for tablet devices */
@media (max-width: 768px) {
  .container {
    padding: 0 20px;
  }
  
  .navigation {
    flex-direction: column;
  }
}

/* Media query for mobile devices */
@media (max-width: 480px) {
  .header {
    font-size: 24px;
  }
  
  .column {
    width: 100%;
    float: none;
  }
}

In this example:

• The container is always 100% wide but has a maximum width on larger screens
• On tablets (768px or less), we add padding and change the navigation layout
• On mobile devices (480px or less), we reduce the header font size and make columns full-width

This approach ensures that the same website provides a good user experience whether viewed on a large desktop monitor, a tablet, or a small smartphone screen. Elements resize, reposition, or even hide/show depending on the available space, maintaining usability across devices.

To create a responsive website, you must use the following Key Components of RWD:

• Viewport Meta Tag
• Flexible layout
• Media queries
• Flexible media
• Flexible Typography

Add Viewport meta tag for optimal display

The Viewport Meta Tag instructs the browser to adjust the webpage width and scale to the size and resolution of the screen, resulting in a responsive layout. You must include this meta tag in the HTML <head> section to ensure your website resizes and displays content correctly on different devices. Here’s a typical viewport meta tag:

<meta name="viewport" content="width=device-width, initial-scale=1">

Create a flexible layout

Flexible layouts use relative units, such as percentages or ems, to adjust element size and position according to screen size. Here’s how to set up a simple two-column layout using CSS:

.container {
  width: 80%;
  margin: 0 auto;
}

.column {
  width: 50%;
  float: left;
}

The above CSS code creates an 80% width container with two columns, each taking up 50% of the container’s width. The container is centered with margin: 0 auto, and the columns are aligned using float: left. However, this layout isn’t suitable for smaller screens and requires media queries to fix.

Implement Media Query

Media queries allow you to apply styles based on the device’s screen size. You can use media queries to adjust font sizes, margins, padding, and other CSS properties. Here’s an example of how to use media queries:

@media (max-width: 600px) {
  .column {
    width: 100%;
    float: none;
  }
}

The above CSS code applies a single-column layout to small screens by removing the floating property and making the columns take up 100% of the container width when the screen width is less than or equal to 600 pixels.

Make media elements flexible

Flexible media allows you to adjust images and videos according to screen size. You can use CSS properties like max-width or height to make media elements responsive. Here’s an example of how to make an image responsive:

img {
  max-width: 100%;
  height: auto;
}

The above CSS code will cause the image to take up the maximum width of its column container without exceeding it. It will also adjust its height automatically according to its aspect ratio.

Implement flexible typography for readability

body {
  font-size: 16px;
}
h1 {
  font-size: 2em;  /* 32px */
}
p {
  font-size: 1em;  /* 16px */
}

By combining this technique with media queries, you can adjust the font size for specific devices or screen widths. For example, you can increase the base font size on smaller screens:

@media (max-width: 480px) {
  body {
    font-size: 18px;
  }
}

Benefits of responsive web design

Here are some compelling reasons why you should use responsive design:

Thanks for reading!

import 'package:flutter/material.dart';
import 'dart:async';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: FutureBuilderExamples(),
    );
  }
}

class FutureBuilderExamples extends StatelessWidget {
  Future<String> fetchData() async {
    await Future.delayed(Duration(seconds: 2));
    return "API Data Loaded";
  }

  Future<bool> checkUserAuth() async {
    await Future.delayed(Duration(seconds: 2));
    return true; // Simulating user is logged in
  }

  Future<String> loadSettings() async {
    await Future.delayed(Duration(seconds: 2));
    return "Dark Mode Enabled";
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("FutureBuilder Examples")),
      body: Column(
        children: [
          // Fetching API Data
          FutureBuilder<String>(
            future: fetchData(),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.waiting) {
                return CircularProgressIndicator();
              } else if (snapshot.hasError) {
                return Text("Error: ${snapshot.error}");
              } else {
                return Text(snapshot.data ?? "");
              }
            },
          ),
          
          // Authentication Check
          FutureBuilder<bool>(
            future: checkUserAuth(),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.waiting) {
                return CircularProgressIndicator();
              } else if (snapshot.hasData && snapshot.data == true) {
                return Text("User is Logged In");
              } else {
                return Text("User is Not Logged In");
              }
            },
          ),
          
          // Loading Configuration Settings
          FutureBuilder<String>(
            future: loadSettings(),
            builder: (context, snapshot) {
              if (snapshot.connectionState == ConnectionState.waiting) {
                return CircularProgressIndicator();
              } else {
                return Text("Settings: ${snapshot.data}");
              }
            },
          ),
        ],
      ),
    );
  }
}

import Foundation

class TimerExample {
    // Timer instance
    private var timer: Timer?
    
    // Start the timer
    func startTimer() {
        // Invalidate any existing timer first
        stopTimer()
        
        // Create a new timer that fires every 120 seconds
        timer = Timer.scheduledTimer(
            timeInterval: 120.0,
            target: self,
            selector: #selector(timerFired),
            userInfo: nil,
            repeats: true
        )
        
        // If you want the timer to continue running while scrolling in a UI
        RunLoop.current.add(timer!, forMode: .common)
        
        print("Timer started - will fire every 120 seconds")
    }
    
    // Stop the timer
    func stopTimer() {
        timer?.invalidate()
        timer = nil
        print("Timer stopped")
    }
    
    // The method that will be called when the timer fires
    @objc private func timerFired() {
        print("Timer fired at: \(Date())")
        
        // Your code to execute every 120 seconds goes here
        performTask()
    }
    
    // Example task to perform when timer fires
    private func performTask() {
        print("Performing scheduled task")
    }
}

// Usage example
let timerExample = TimerExample()
timerExample.startTimer()

// To stop the timer later
// timerExample.stopTimer()

// Keep the program running to see the timer in action
RunLoop.main.run(until: Date(timeIntervalSinceNow: 300))

This code:

1. Creates a TimerExample class that encapsulates timer functionality
2. Sets up a timer to fire every 120 seconds (2 minutes)
3. Includes methods to start and stop the timer
4. Provides a callback method (timerFired) that executes when the timer fires
5. Runs the timer for 300 seconds as an example

If you’re working in a SwiftUI context, you might prefer using this alternative approach:

import SwiftUI

struct ContentView: View {
    @State private var timerCount = 0
    @State private var timer: Timer? = nil
    
    var body: some View {
        VStack {
            Text("Timer count: \(timerCount)")
                .font(.largeTitle)
            
            Button("Start Timer") {
                startTimer()
            }
            .padding()
            
            Button("Stop Timer") {
                stopTimer()
            }
            .padding()
        }
        .onDisappear {
            stopTimer()
        }
    }
    
    func startTimer() {
        stopTimer() // Clear any existing timer
        
        timer = Timer.scheduledTimer(withTimeInterval: 120, repeats: true) { _ in
            timerCount += 1
            print("Timer fired at: \(Date())")
            // Perform your task here
        }
    }
    
    func stopTimer() {
        timer?.invalidate()
        timer = nil
    }
}

Thanks for reading!