Pros of flutter-tutorials

• More comprehensive, covering a wide range of Flutter topics and concepts
• Regularly updated with new tutorials and examples
• Includes video tutorials alongside code samples for better learning experience

Cons of flutter-tutorials

• Less focused on specific architecture patterns
• May be overwhelming for beginners due to the large number of tutorials
• Lacks a unified example app to demonstrate concepts cohesively

Code Comparison

flutter-tutorials:

class HomeViewModel extends BaseViewModel {
  final _api = locator<Api>();
  List<Post> posts;

  Future fetchPosts() async {
    setBusy(true);
    posts = await _api.getPosts();
    setBusy(false);
  }
}

flutter_architecture_samples:

class TodosBloc extends Bloc<TodosEvent, TodosState> {
  TodosBloc({@required this.todosRepository})
      : assert(todosRepository != null),
        super(TodosLoading());

  final TodosRepository todosRepository;
}

The flutter-tutorials example showcases a ViewModel approach using a BaseViewModel, while flutter_architecture_samples demonstrates a BLoC pattern implementation. The former focuses on simplicity, while the latter emphasizes separation of concerns and state management.

Pros of FlutterExampleApps

• Wider variety of examples covering different Flutter features and use cases
• More beginner-friendly with simpler, standalone examples
• Regularly updated with new examples and Flutter features

Cons of FlutterExampleApps

• Less focus on architectural patterns and best practices
• Examples may not always follow consistent coding standards
• Some examples might be too simplistic for advanced developers

Code Comparison

FlutterExampleApps (Simple Counter App):

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;
  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }
}

flutter_architecture_samples (Counter App with Redux):

class CounterViewModel {
  final int count;
  final Function() onIncrement;
  CounterViewModel({required this.count, required this.onIncrement});
}

class CounterContainer extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StoreConnector<AppState, CounterViewModel>(
      converter: (store) => CounterViewModel(
        count: store.state.count,
        onIncrement: () => store.dispatch(IncrementAction()),
      ),
      builder: (context, vm) => CounterWidget(
        count: vm.count,
        onIncrement: vm.onIncrement,
      ),
    );
  }
}

The code comparison shows that FlutterExampleApps focuses on simpler implementations, while flutter_architecture_samples demonstrates more complex architectural patterns like Redux for state management.

Pros of awesome-flutter

• Comprehensive collection of Flutter resources, libraries, and tools
• Regularly updated with community contributions
• Covers a wide range of topics beyond architecture patterns

Cons of awesome-flutter

• Lacks in-depth code examples for specific architecture implementations
• May be overwhelming for beginners due to the sheer volume of information
• Does not provide direct comparisons between different architectural approaches

Code comparison

flutter_architecture_samples provides specific implementations of various architectures. For example, the BLoC pattern:

class TodosBloc extends Bloc<TodosEvent, TodosState> {
  TodosBloc({required this.todosRepository}) : super(TodosLoadInProgress()) {
    on<TodosLoaded>(_onTodosLoaded);
    on<TodoAdded>(_onTodoAdded);
    // ...
  }
  // ...
}

awesome-flutter, on the other hand, primarily links to external resources rather than providing code examples directly. It might include a link to a BLoC library:

- [flutter_bloc](https://github.com/felangel/bloc) - A predictable state management library that helps implement the BLoC design pattern by [Felix Angelov](https://github.com/felangel)

Summary

flutter_architecture_samples focuses on providing concrete implementations of various architecture patterns in Flutter, making it ideal for developers looking to compare and understand different approaches. awesome-flutter serves as a comprehensive resource hub for Flutter development, covering a broader range of topics but with less depth in specific architectural implementations.

Pros of flutter/samples

• Officially maintained by the Flutter team, ensuring up-to-date and best practice examples
• Covers a wide range of Flutter features and use cases
• Includes more complex and production-ready examples

Cons of flutter/samples

• Less focused on specific architectural patterns
• May be overwhelming for beginners due to the large number of samples
• Some examples might be too complex for learning basic concepts

Code Comparison

flutter/samples:

class MyHomePage extends StatefulWidget {
  const MyHomePage({Key? key, required this.title}) : super(key: key);
  final String title;
  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

flutter_architecture_samples:

class HomePage extends StatelessWidget {
  HomePage({Key key, @required this.viewModel}) : super(key: key);
  final HomeViewModel viewModel;
  @override
  Widget build(BuildContext context) {
    // Implementation
  }
}

The flutter/samples code shows a more traditional StatefulWidget approach, while flutter_architecture_samples demonstrates a ViewModel pattern, emphasizing separation of concerns and testability.

Pros of bloc

• More comprehensive and focused on a single architecture pattern (BLoC)
• Extensive documentation and examples for various use cases
• Active community and regular updates

Cons of bloc

• Steeper learning curve for beginners due to its specific architecture
• May be overkill for simple applications
• Less flexibility in exploring alternative architecture patterns

Code Comparison

flutter_architecture_samples (Redux implementation):

class VisibilityFilter extends ReduxCompatible<VisibilityFilter> {
  final VisibilityFilterType activeFilter;

  VisibilityFilter(this.activeFilter);

  @override
  VisibilityFilter copyWith({VisibilityFilterType activeFilter}) {
    return VisibilityFilter(activeFilter ?? this.activeFilter);
  }
}

bloc:

class FilterBloc extends Bloc<FilterEvent, FilterState> {
  FilterBloc() : super(FilterInitial());

  @override
  Stream<FilterState> mapEventToState(FilterEvent event) async* {
    if (event is UpdateFilter) {
      yield FilterUpdated(event.filter);
    }
  }
}

The code comparison shows that bloc uses a more event-driven approach, while flutter_architecture_samples (in this case, using Redux) focuses on immutable state updates. The bloc pattern separates concerns into events, states, and the bloc itself, which can lead to more organized code in complex applications.