DEV Community: rahul mishra

Why Writing Efficient Code Still Matters (Even in the Age of AI) ?

rahul mishra — Wed, 03 Sep 2025 02:41:16 +0000

We live in a time where you can ask an AI to write you code But If you aren’t comfortable reading and understanding that code, you can easily get stuck in the loop of:

“What’s wrong with my code? It looks fine…”

The truth is, it’s often not about whether the code runs, but how efficiently it runs. That’s where space and time complexity and a basic understanding of algorithms comes into play.

Let's take an example from building an App : Imagine building a feature where users can search through a large product catalog.

If you naively loop through every item (O(n)), the app feels slow as data grows.
If you use the right data structure (like a hash map or binary search on a sorted list → O(log n)), the same search feels instant.

That’s the difference between a cumbersome app and one users love.

If you are from AI background, you must have experienced there too. Training a deep learning model with millions of parameters is already resource heavy.

If you store and process data inefficiently (say, dense matrices instead of sparse), you could need 10x more GPU memory.
If you choose the right algorithm (say, an optimized gradient descent variant or caching strategy), training can finish in days instead of weeks.

That’s the difference between research that scales and one that stalls.

You don’t need to memorize every algorithm, that’s not the point.

What you do need is the habit of thinking in terms of efficiency. AI can write code for you, but if you don’t know how to analyze or optimize it, you’ll struggle to debug and improve it.

Looking to Connect with Devs/Builders to Start Something Together

rahul mishra — Wed, 06 Aug 2025 14:12:04 +0000

I’m a solo builder who's been thinking seriously about starting up. I’m looking to connect with like-minded devs who want to explore startup ideas together — maybe even apply to Y Combinator if it feels right.

Not pitching any fixed idea right now — just open chats, bouncing thoughts, and seeing if there’s a good vibe to build with someone. If you’re curious, motivated, and want to work on something meaningful, let’s connect!

Drop a comment or DM me here. I’d love to talk.

Query Smarter, Not Harder

rahul mishra — Sat, 26 Jul 2025 08:58:17 +0000

If you're building a music app with on_audio_query, it’s tempting to call querySongs() everywhere—home screen, playlists, search, etc. But this means repeated storage scans → slower UI, battery drain, and unnecessary complexity.

The Wrong Way – Querying Every Time

final OnAudioQuery audioQuery = OnAudioQuery();

Future<List<SongModel>> getSongs() async {
  return await audioQuery.querySongs(); // Called in every screen
}

In each screen:

final songs = await getSongs(); // Repeats scan again

The Better Way – Query Once, Share via Provider

Fetch once in a service (e.g., MusicPlaybackService):

class MusicPlaybackService extends ChangeNotifier {
  List<SongModel> _allSongs = [];

  Future<void> loadSongs() async {
    final OnAudioQuery query = OnAudioQuery();
    _allSongs = await query.querySongs();
    notifyListeners();
  }

  List<SongModel> get allSongs => _allSongs;
}

Provide it globally:

runApp(
  ChangeNotifierProvider(
    create: (_) {
      final service = MusicPlaybackService();
      service.loadSongs(); // Fetch once
      return service;
    },
    child: MyApp(),
  ),
);

Reuse anywhere without re-querying:

final allSongs = context.watch<MusicPlaybackService>().allSongs;

Benefits

No repeated disk access.
Faster UI transitions (playlist, search, player use the same list).
Centralized state → easier maintenance.

The AI Effect on Coding

rahul mishra — Fri, 18 Jul 2025 16:41:04 +0000

Before AI, learning to code meant starting with the basics, following tutorials, and gradually building projects.

Now? It’s flipped.

I often start by asking an AI to write the code. Then, when it breaks (or doesn’t work exactly how I want), I go step by step, debugging and understanding the logic.

It feels like reverse learning—build first, understand later. And honestly, it works surprisingly well for rapid problem-solving.

AI hasn’t just changed what we learn, but how we learn.

Does anyone else learn this way? Or do you prefer the old-school approach of mastering concepts first?