DEV Community: mandalverse

First 7 months as a remote Flutter app developer in a startup

mandalverse — Fri, 03 Apr 2026 07:37:45 +0000

Last year I got my first job as a fresher flutter app developer in a health & fitness startup, BTW this is a remote job. I walked in with a basic understanding of widgets & pet projects, but I was immediately met with a codebase that felt like a mountain. The imposter syndrome kicks in the moment you see hundreds of files and thousands of lines of logic, but I realized early on that this was my greatest opportunity to grow.

I managed mostly by connecting with the tech team, asking as many questions as possible to get clarity. I started reading the code line by line to understand exactly which part of the logic resulted in which feature on the app. This deep dive sometimes got me into frustration and also helped me unravel the "magic" behind a large-scale application, finally it gave me the confidence to start contributing my own code.

Got to know more about flutter and the use of different packages. All the files should be in a proper structure which is the folder structure. Got to know and implement clean code as much I could along with getting used to git, the state management and all. To change one code I have to go through a chain of files, tracing the call stack and then we get to see the original implementation and the dependency injection still fascinates me. Reading debug log and the skill to debug is a very important part it really helps me resolves bug as soon as possible. I occasionally use AI due to my laziness of searching manually on the internet (70% manual search & 30% AI for me now). This drops a bit confidence in me so until I learn whatever code the AI gives and those syntax I don't git commit, otherwise its hard for me to sleep at night.

Communication is also a crucial aspect in an organization. Connecting with technical and non technical teams helped me to know the overall flow of the organization and how the work impacts the business. Getting insights given by users is very rewarding , the feedback directly shapes the features I build. From Monday to Friday, it's war for me in a good way, we have deadlines, fix bugs and need to implement rapid changes. Its intense but because of my genuine love for programming the pressure actually makes the wins feel better. For resetting my brain I use Saturday and Sunday. Playing games and consuming internet media mostly, but still I do some pet projects and create some content as well. This clears my mental cache so I can return on Monday morning ready to climb the next peak of the mountain.

Thank you for reading my journey so far :)

C++ Through the Years : From Classic to Modern

mandalverse — Sun, 23 Nov 2025 20:08:14 +0000

C++98 and C++03 : The Beginning of Standardized C++

C++98 was the first international standard for the language.
C++03 was a maintenance update, fixing defects and inconsistencies.

Key Features

Object-oriented programming (classes, inheritance, polymorphism)
Templates (generic programming)
Exceptions
Namespaces
STL (Standard Template Library) including:
- vector, map, set, list
- algorithms (sort, find)
- iterators

Issues

No move semantics → heavy copying, lower performance
No type inference → verbose code
Limited compile-time programming
Early template errors were difficult to understand

C++11 (C++0x) : The Modern C++ Revolution

C++11 is considered the largest update in the history of the language.

Major Features

Performance + Memory

Move semantics
Rvalue references
std::unique_ptr, std::shared_ptr (smart pointers)

Syntax Improvements

auto type deduction
Range-based for loops
Lambda expressions
nullptr

Compile-Time & Safety

constexpr
static_assert

Concurrency

std::thread, mutex, lock_guard, atomic types

Issues

New features increased language complexity
Early compilers lacked full support
Required developers to relearn modern idioms

C++14 : Polishing the C++11 Era

A small but helpful update, improving usability and removing friction from C++11 features.

Key Features

Generic lambdas
Lambda capture initializers
Auto return type deduction
std::make_unique
Binary literals (0b1010)
Relaxed constexpr rules
[[deprecated]] attribute

Issues

Incremental update; many compilers were slow to adopt complete support
Did not solve deeper issues like module complexity or header bloat

C++17 : Practical Improvements and Powerful New Tools

C++17 continued the modernization of C++, adding tools that made code cleaner, safer, and faster.

Major Features

New Standard Types

std::optional (optional values)
std::variant (type-safe unions)
std::any (type-erased containers)
std::string_view (non-owning string references)

Filesystem

std::filesystem library for paths, directories, file operations

Language Enhancements

if constexpr for compile-time branching
Structured bindings
Fold expressions for templates

Parallel Algorithms

Many STL algorithms now support parallel execution policies

Issues

Some older codebases couldn’t compile without modifications
Too many ways to express the same idea → style inconsistency
Still suffered from header-based compilation overhead

C++20 : One of the Biggest Updates After C++11

C++20 dramatically expanded the language, adding features that change how we write code.

Major Features

Concepts

Type constraints for templates
Improved readability and error messages

Ranges

Lazy evaluation pipelines like functional languages

Coroutines

Enables async/await-like programming
Foundation for high-performance I/O systems

Modules

Replaces header files (faster compilation, better encapsulation)

Other Additions

calendar & timezone
Improved constexpr
Spaceship operator <=> for automatic comparisons

Issues

Compiler + tooling support lagged behind
Modules required major build-system changes (CMake, IDEs)
Ranges + Coroutines brought significant complexity

C++23 : Quality-of-Life Upgrade and Standard Refinement

C++23 is not as huge as C++20 but adds many useful improvements.

Key Features

More range adaptors & algorithms
Expanded constexpr usage
Refinements to modules, coroutines, and concepts
Network improvements (though full networking TS was deferred)
Better error handling primitives
UTF-8 support improvements

Issues

Some platforms still lack full support
Feature bloat concerns for new learners
Reflection still planned for future versions, not in C++23

C++26 and Beyond (Expected / In Development)

(yet to be published)

Year of Standardization.

Before 1998, C++ had no official international standard. The first official ISO/IEC standard for C++ was completed and published in 1998.So the version was informally called C++98.Official name:ISO/IEC 14882:1998

This version became the foundation for the language and is therefore referred to as C++98.Later updates followed the same naming pattern:
C++03 → published in 2003
C++11 → published in 2011
C++14, C++17, C++20, C++23 → based on the year they were standardized

Flow by keystroke (the way of keyboard)

mandalverse — Fri, 17 Oct 2025 18:06:46 +0000

Keyboard shortcuts are one of the most underrated skills you can learn. They might seem small, but once mastered, they completely transform the way you work. This is my journey from simple desktop navigation to mastering Vim keybindings and beyond.

It all started with learning basic shortcuts to navigate my desktop efficiently. Soon after, I began using shortcuts in VS Code, which made me realize how much time I was wasting reaching for the mouse.

Then came Vim a game changer. Learning Vim bindings wasn’t easy at first, but once I got the hang of them, I felt completely in control. Every movement, every edit all from the keyboard. It keeps me focused, fast, and deeply engaged in my work.After mastering Vim, I wanted to take things further. That’s when I discovered Neovim, a modern fork of Vim packed with colors, themes, and powerful plugins. I decided to set up LazyVim, a minimal yet extensible Neovim configuration setup.

At first, I was confused with the Lua files, directory structure, and plugin management it was a lot to take in. But I didn’t give up. I went through the LazyVim documentation, explored articles, and watched tutorials on YouTube. Slowly, everything started making sense.

The Neovim setup feels truly fast, functional, and beautiful. And the best part? I’m hooked on shortcuts. Every software I use, the first thing I do is learn its keyboard shortcuts. Even installed vimium extension in firefox browser so now I can navigate in the browser using keyboard. It’s not just about speed anymore it’s about staying in flow, keeping my hands on the keyboard, and working with intention.

Isar: A Super Fast NoSQL Database for Flutter & Dart

mandalverse — Thu, 28 Aug 2025 18:23:02 +0000

Recently I came accross this nice database you can give it a quick read.

What is Isar?

Isar is a fast, fully asynchronous NoSQL database optimized for Flutter and Dart. It runs locally on mobile, desktop, and web platforms with a native Dart API. Isar is designed to be simple, scalable, performant, and developer-friendly, with built-in support for reactive queries and complex filtering.

Features of Isar:

• NoSQL document database designed for embedded use (runs inside your app with zero external dependencies).
• Supports schema definition using Dart classes with annotations.
• Provides full reactive queries, UI updates automatically on data changes.
• Compact, high-performance transactions for fast and safe reads/writes.
• Full text search with token based indexing for searching text fields.
• Composite and multi-entry indexes for structured queries.
• Supports JSON serialization and deserialization.
• Comes with a visual inspector for debugging database contents in debug mode.
• Cross-platform support for Android, iOS, Web, Desktop platforms.

Transactions in Isar

Isar enforces safe and atomic transactions.

Writes must be wrapped in a writeTxn transaction.
Reads are async and safe by default.

This ensures data integrity and prevents inconsistent states.

Example:

final isar = await Isar.open([UserSchema]);

await isar.writeTxn(() async {
  final user = User()..name = 'Alice'..age = 25;
  await isar.users.put(user); // insert or update
});

final users = await isar.users.filter().ageGreaterThan(20).findAll();
print(users);

Getting Started

Step 1 : Add Isar to your project:

dependencies:
  isar: any
  isar_flutter_libs: any
  path_provider: any
dev_dependencies:
  isar_generator: any
  build_runner: any

Step 2 : Define your model with annotations:

import 'package:isar/isar.dart';

part 'user.g.dart';

@collection
class User {
  Id id = Isar.autoIncrement;
  late String name;
  late int age;
}

Step 3 : Run build:

flutter pub run build_runner build

That’s it! You now have a fully working local NoSQL database integrated into your Flutter app.

Learn from the official documentation: https://isar.dev/tutorials/quickstart.html

Three Months with Flutter: Journey from Frustration to Confidence

mandalverse — Sun, 03 Aug 2025 11:21:18 +0000

May 2025 was a turning point for me. Just weeks before my final exams in the last semester of my Computer Science Engineering degree, frustration had reached its peak I felt like a “CSE engineer” in name only, with barely any real software development to show for all those 4 years. My journey so far had revolved around DSA and programming basics, but not actual development. That’s when I turned to Perplexity (yes, AI really does change lives!) and started searching for the best and quick ways to truly break into development.

Why Flutter?

From the very beginning of my degree, app development had always fascinated me, but I kept stumbling after the basics. My research on the internet showed how rapidly Flutter was being adopted in the market, and I was initially torn between Java and Flutter. Java felt intimidating, especially for fast learning, while Flutter’s cross-platform nature, growing ecosystem, and gentle learning curve kept drawing me in.

How I Started Learning

Following recommendations on the official Dart website, I picked up:

I soaked in the theory, and being familiar with C++ and OOP helped, so I sped through the Dart books in a month. I didn’t understand everything at first—many concepts eluded me despite watching explainer videos and tutorials on specific topics. Also started with the Flutter Cookbook. Sometimes, doubt crept in and I wondered if development just wasn’t for me. But seeing others build and share their progress pushed me forward (started following people alike in X, linkedin and joined discord servers).To understand how real apps come together, I watched a full app building video on YouTube to understand how its done.

Balancing Exams, Projects, and Learning

Final year project presentations and semester exams in May-June meant pausing my Flutter journey. But as soon as exams wrapped up, around the second week of June I picked Flutter back up and went all-in with projects, although I lost a little bit of confidence, I decided to revisit and revise the book material to refresh key concepts.
I built several apps to put theory into practice:

To-Do App (classic starter)
Photo Gallery App
Weather Forecasting App
Real-Time Chat App with Firebase as the backend
Ecommerce App (used Supabase for backend, Razorpay for payments)

Each project uncovered gaps in my understanding, so I keept returning to those topics and reopening the book PDFs. Async programming really took a toll on me, especially figuring out which widget to use and what parameters were available for each widget. To fill in the blanks, I leaned heavily on Medium articles and sometimes Dev.to posts, Stack Overflow and official Flutter documentation.I also used LLM explanations, and worked through Johan Jurrius’s YouTube playlists.

Where I Am Now

Right now, I’m working through the book Flutter In Action by Eric Windmill to fill in any gaps and deepen my understanding of Flutter. I’m also revisiting the code for the apps I’ve built recently, taking time to fix issues, refactor, and make everything more modular and maintainable. For state management, I’m actively using the Provider package, which has made managing state across widgets so much cleaner and more scalable. For navigation, I’m leveraging a route manager to organize routes, making my codebase more structured especially as my apps grow in complexity.

My three months (may to july) with Flutter have taught me:

You don’t have to learn it all at once.
Watching experienced devs code is as important as books or tutorials.
Online articles, AI, and community plays a massive role in learning
Every time you feel stuck, remember: every developer feels this way sometimes!

If you’re on the fence about starting with Flutter (or any stack), just start building you’ll learn faster from your own mistakes and projects than from any course or book alone.

Free Thought Free World