DEV Community: Ali Çimen

Facing State Management: "Truly" Understanding Provider in Flutter

Ali Çimen — Tue, 25 Aug 2026 14:07:02 +0000

The Beginning: Why This Project?

You somehow learn to build UIs in Flutter, but when it comes to state management, it's a wall you inevitably hit. To truly understand Provider instead of just memorizing code by copying and pasting, I built a cart management app called "Sneaker Shop." My goal was to focus purely on the data's journey between screens and the logic behind Provider. Because of this, I intentionally kept the UI minimal and used basic widget structures rather than complex designs.

The Fundamentals of Provider: The "Radio Station" Analogy

At its core, Provider is like a radio station you set up in the middle of your app. Instead of passing data through complex paths between your pages (widgets), they just put on their headphones and listen directly to this central station.

The brain of this station is the ChangeNotifier class. You store your data inside this class, and when a change occurs (like a new item being added to the cart), you grab the microphone and make an announcement using the notifyListeners() function. The pages listening to this announcement instantly update themselves with the new data.

How I Set Up Provider in the Project

I built the core cart logic—the heart of the e-commerce app—in two main steps:

Setting Up the Broadcast Tower: First, at the very top of my app in the main.dart file, I defined a MultiProvider (to keep it scalable for the future). This allowed all the pages inside the app to access this state.
Writing the Brain (Provider Class): I created a CartProvider class and defined a private cart list inside it. I wrote functions to add, remove, and completely clear the cart. To notify the UI after each action, I added notifyListeners() to the end of these functions. I also used a sleek .fold() method to calculate the total price of the items in the cart dynamically.

My Learning Strategy: Pair Programming with AI

While building this project, I set a strict rule for myself: use AI not as an assistant, but as a "pair programmer."

Whenever I moved to a new structure, I first let the AI write the skeleton code and analyzed how it worked. Then, I closed the screen and rewrote the exact same code entirely by hand without looking anywhere. It was an amazing method to build muscle memory after understanding the logic.

My Badges of Honor: 69 Errors and the Power of a Single Letter

Of course, writing everything from scratch by hand comes with a funny cost. When I reached the end of the project and tried to compile it, I suddenly faced 69 errors on the screen! I panicked briefly before realizing there were zero logic flaws; it was entirely a "domino effect" caused by:

Forgetting to add the import path of a page in main.dart.
Typing lengt instead of length, swallowing a single "h".
Writing the Colors.red class with a lowercase letter as colors.red.
And those innocent missing commas that wreaked havoc on the widget tree...

They were all sweet mistakes born from touching the code with my own hands.

The Biggest Lesson Learned: Read vs. Watch

The most valuable skill this simple project taught me was moving the context.read vs. context.watch distinction out of memorization and into logical understanding.

If I just needed to click a button to add an item to the cart without needing to listen to an instant change on the screen, I used the triggering read method to boost performance:

// We only trigger the action; we don't unnecessarily rebuild the UI.
context.read<CartProvider>().addToCart(product);

However, on the cart page, where I needed to calculate and display the items and the total price instantly, I used watch to listen to the radio live and keep the data synchronized with the UI:

// This page updates instantly every time notifyListeners() runs in the Provider.
final cart = context.watch<CartProvider>();

In the end, by making mistakes and fixing them, I completely grasped the Provider lifecycle. You can find all the source code and the folder architecture of the app on my GitHub repo: [https://github.com/allicimen/Flutter-Labs/tree/main/sneaker_shop_provider]

Why I Built a Simple App to Understand Isar in Flutter (And the Challenges I Faced)

Ali Çimen — Fri, 21 Aug 2026 17:56:37 +0000

When learning a new tool or technology, everyone usually tries to build massive projects like e-commerce apps or social media clones. Instead, I turned to a much more focused and simple project to wrap my head around a new local database solution: a Minimalist Habit Tracker.

My goal was to focus directly on database operations and state management integration without getting lost in complex UI designs or API integrations.

So, why Isar?

For Those Who Don't Know: What is Isar?

When Flutter developers think of local storage, SQLite, Shared Preferences, or Hive usually come to mind. Isar is a next-generation, blazing-fast NoSQL database developed by Simon Leier, the creator of the legendary Hive package.

What makes Isar so special:

Blazing Fast: Thanks to its C-based engine under the hood, read/write speeds are massive.
Fully Type-Safe: It prevents string-based errors when querying. You can write your queries safely with auto-completion.
Advanced Queries: It offers out-of-the-box capabilities like full-text search, filtering, and multi-indexing.
Visual Inspector: While your app is running, you can view the inside of your database live on your browser, just like an Excel spreadsheet.

How I Structured the Architecture

To prevent the code from turning into "spaghetti," I applied the classic "divide and conquer" approach:

Models: Collection schemas leveraging Isar's power (Habit class).
Services: An isolated layer handling database CRUD operations and date updates (IsarService).
Providers: The HabitProvider that acts as a bridge between the UI and the Isar service.
Screens: A clean, minimalist interface for user interaction.

The Real Deal: Where Did I Struggle and How Did I Solve It?

Everything looked great on paper, but I hit some walls in practice. Here are those issues and my practical solutions:

Wall 1: The Gradle and "Namespace" Rebellion
When I installed the Isar package and tried to build the project for the first time, the Android Gradle engine threw an error. I realized that the isar_flutter_libs package didn't comply with the "namespace" rule and the minimum SDK 34 requirement demanded by modern Flutter projects.

** Solution:** Instead of spending hours searching for a fix online, I went straight to the heart of the package inside the pub cache. I manually added the namespace 'dev.isar.isar_flutter_libs' line to the package's android/build.gradle file and updated the compileSdkVersion to 34, solving the problem at its root.

Wall 2: Provider's Silent Scream: `T != dynamicWhen I tried to save a new habit from the UI, the app suddenly crashed with aTried to call Provider.of` error.

Solution: I realized the issue stemmed from a very simple typing omission. Dart was essentially telling me, "I don't know who you are talking to." By writing context.read<HabitProvider>().addNewHabit() instead of context.read().addNewHabit(), I experienced firsthand how critical it is to strictly specify the <HabitProvider> type.

Wall 3: GitHub Thinking My Project was an "HTML Project"
I proudly pushed the project to GitHub, only to check my repository's language stats and see 7% Dart and 90% HTML!

Solution: I immediately created a .gitattributes file in the root directory of the project. I told GitHub's language parser to ignore certain autogenerated folders by adding this code:

*.html linguist-generated=true
web/** linguist-generated=true
build/** linguist-generated=true

The result? My Dart percentage went right back up to its well-deserved 100% level!

Conclusion and Takeaways

This small project showed me this: The best way to learn a technology (especially a powerful database like Isar) is to abstract it from complex app structures and use it in its most fundamental form.

If you'd like to check out my project or take a look at the code, I'm leaving my repo link below. I'm looking forward to your comments and code critiques!

My GitHub Repo Link

Hello, DEV Community

Ali Çimen — Mon, 17 Aug 2026 17:58:33 +0000

I'm a newly graduated developer currently focusing on Flutter and mobile app development.

I've been spending a lot of time building projects with Flutter, experimenting with different approaches, and—like many developers today—using AI as part of my development workflow.

But I don't want AI to simply write my code for me.

I want to understand the code, question the solutions it gives me, fix the mistakes, and learn from the process.

So I decided to start sharing that journey here on DEV.

I'll be writing about:

Flutter projects I'm building
Things I'm learning along the way
Bugs and problems I encounter
How I use AI while developing
Architecture and development decisions
Lessons I learn from building real projects

I'm still at the beginning of my professional journey, but I'm building, learning, and improving every day.

Hopefully, some of the things I share will be useful to other developers as well.

This is the beginning. Let's build. 🚀

flutter #dart #mobiledevelopment #ai #devjourney