DEV Community: Yash Fadadu

🚀 What Really Happens When You Call .add() Twice? Classic BLoC vs BlocSignal

Yash Fadadu — Thu, 06 Aug 2026 17:57:52 +0000

We've all been there.

You're building a Flutter app with BLoC, and somewhere in your business logic you write:

myBloc.add(LoadUserData());
myBloc.add(FetchUserPreferences());

Immediately, a thought pops into your head...

🤔 "Wait... did I just overwrite the first event before the UI even had a chance to rebuild?"

Or maybe:

Will EventB execute before EventA finishes?
Will the UI skip StateA?
If I read bloc.state immediately after .add(), what state do I get?
What happens if I call .add() 10,000 times?

Let's lift the hood and compare Classic BLoC and BlocSignal.

🤯 The Common Misconception

Many developers imagine something like this:

EventA
   ↓
StateA

EventB
   ↓
StateB

↓

UI only sees StateB 😱

The fear is that rapid-fire .add() calls somehow overwrite each other before Flutter can render.

Fortunately...

That's not how either implementation works.

The difference lies in how state propagates, not whether events get lost.

🐢 Classic BLoC (Streams)

Traditional flutter_bloc is built on top of Dart Streams.

A simplified flow looks like this:

.add(Event)

        ↓

 StreamController

        ↓

 Event Handler

        ↓

 emit(State)

        ↓

 State Stream

        ↓

 BlocBuilder Listener

        ↓

 markNeedsBuild()

        ↓

 Flutter Frame

Notice something important:

Flutter does not rebuild immediately.

It simply marks the widget as dirty and rebuilds during the next rendering frame.

So what happens?

Imagine:

bloc.add(EventA());
bloc.add(EventB());

Internally it behaves more like:

EventA

↓

Handler runs

↓

emit(StateA)

↓

Widget marked dirty

↓

EventB

↓

Handler runs

↓

emit(StateB)

↓

Widget marked dirty again

↓

Flutter renders

↓

Latest state displayed

No event is lost.

Both handlers execute.

The UI simply paints the latest settled state when Flutter decides to render the next frame.

⚡ BlocSignal (Signals)

BlocSignal keeps the familiar BLoC programming model...

bloc.add(...)
emit(...)

...but replaces Streams with Signals.

Its propagation path is much shorter.

.add(Event)

      ↓

Handler

      ↓

emit(State)

      ↓

Signal

      ↓

BlocSignalBuilder

      ↓

markNeedsBuild()

      ↓

Flutter Frame

The biggest difference is:

The handler executes synchronously.

Meaning this:

bloc.add(EventA());

print(bloc.state);

already prints

StateA

because the state has already been updated before .add() returns.

Then...

bloc.add(EventB());

starts.

So EventB always sees the latest state.

🤔 Doesn't that rebuild the UI every time?

This is probably the most interesting question.

Suppose you do something completely unreasonable 😂

for (int i = 0; i < 10000; i++) {
  bloc.add(IncrementEvent());
}

Many people imagine:

markNeedsBuild()

↓

Build

↓

markNeedsBuild()

↓

Build

↓

markNeedsBuild()

↓

Build

10,000 times.

Fortunately...

Flutter is much smarter than that.

🎨 What `markNeedsBuild()` Actually Does

Calling

markNeedsBuild();

does not immediately rebuild the widget.

It simply tells Flutter:

"This widget is dirty."

Internally it's roughly equivalent to:

_dirty = true;

If it's already dirty...

Setting

_dirty = true;

again changes nothing.

markNeedsBuild()

markNeedsBuild()

markNeedsBuild()

markNeedsBuild()

still results in

_dirty == true

Once Flutter reaches the next frame...

it performs one build using the latest state.

📊 Classic BLoC vs BlocSignal

Feature	Classic BLoC 🐢	BlocSignal ⚡
State Propagation	Stream-based	Signal-based
Handler Execution	Stream/event pipeline	Direct synchronous execution
`bloc.state` immediately after `.add()`	Depends on propagation timing	Updated immediately
Internal Dispatch	Stream subscriptions	Signal dependency graph
UI Rendering	Flutter frame pipeline	Flutter frame pipeline
Widget Rebuild	Deferred to Flutter	Deferred to Flutter
Developer Experience	Mature & battle-tested	Familiar API with Signals underneath

🎯 So... what does BlocSignal actually optimize?

The optimization isn't that Flutter suddenly rebuilds faster.

Flutter's rendering pipeline is exactly the same.

Instead, BlocSignal removes much of the reactive plumbing:

❌ StreamController

❌ Stream subscriptions

❌ Stream dispatch

❌ Async propagation through streams

Replacing it with:

✅ Direct synchronous state updates

✅ Signal dependency propagation

✅ Immediate state availability

This makes the execution path shorter and more predictable.

💙 Final Thoughts

Calling:

bloc.add(EventA());
bloc.add(EventB());

is perfectly safe.

Neither Classic BLoC nor BlocSignal loses events.

The key difference is how the new state travels from your business logic to the UI.

🐢 Classic BLoC uses a Stream-based propagation pipeline.
⚡ BlocSignal replaces that pipeline with synchronous Signal propagation.

Both still rely on Flutter's rendering engine, which intelligently batches widget rebuilds into the next frame.

So no matter how many times you call .add(), Flutter only paints what actually matters—the latest settled state.

🔥 Solved 1000 LeetCode Questions — Here's What I Learned (and Didn't)

Yash Fadadu — Fri, 30 May 2025 06:25:58 +0000

✅ 1000 LeetCode Questions — Done!

Just hit a huge milestone:

Hello I'm Yash Fadadu, I’ve completed 1000 questions on LeetCode ✌️

And no — I’m not at Google. Not yet at Microsoft either.

But that’s not what this post is about.

✨ Was it worth it?

Short answer: Yes. But not for the reasons you might think.

❓ Did I become a DSA expert? – Not yet

💼 Got an offer from FAANG? – No

🧠 Learned something deeper? – 100%

💡 What I Actually Learned

Solving LeetCode isn’t about flexing IQ.

It’s about consistency, discipline, and learning to think like a developer.

You can study all the patterns and still get stuck. That’s normal.
You won’t love every part of it — but that’s the point.
It teaches you to show up even when it’s tough.
It’s about building mental endurance as much as technical skill.

I often felt like ditching LeetCode to focus on building real-world things — AI tools, beautiful UIs, full-stack apps.

But this journey reminded me:

🔁 “You grow most when you don’t feel like it.”

📝 Tips If You're Just Starting

Here’s what helped me — and might help you:

📚 Master the basics: Arrays, Strings, Linked Lists, Trees
🎯 Learn core patterns: Two Pointers, Sliding Window, Binary Search, Recursion
🤏 Start with easy problems — they build confidence
⏱️ Stuck for more than an hour? Read the solution
🧠 Study a topic before attempting questions on it
🔁 Make it a daily habit, not a sprint
🔍 Get good at time & space complexity — it’ll make your intuition stronger

✅ Real Benefits I’ve Seen

🧩 Understanding DSA helped me in blockchain, AI/ML, game dev, and full-stack work.
💡 I write cleaner, more optimized code.
🔐 Most of all, it changed my mindset: I now look at problems with more clarity and confidence.

🛠️ Let's Connect

🚀 What’s Next?

1000 done.

Now chasing 2000 🧠⚡

Because the goal is never just a number — it’s to become better than yesterday.

If you're on the same journey, let’s connect.

Drop your milestones, tips, or struggles in the comments! 🙌

🧠 The S-400 and Smart Defense: How AI Algorithms Could Revolutionize Automated Air Defense

Yash Fadadu — Fri, 23 May 2025 10:06:25 +0000

The S-400 Triumf air defense system is a marvel of military engineering. With the ability to track and destroy aircraft, drones, and missiles over 400 km away, it’s one of the most feared SAM systems in the world.

But here’s the reality: while the S-400 uses advanced automation, it doesn't yet use true AI—as in learning algorithms that improve over time.

So, what if we applied real machine learning? Let’s explore the algorithms that could bring the next level of intelligence to air defense systems like the S-400.

**🔄 Current Automation in the S-400
The S-400 currently uses:

Rule-based threat prioritization: if X is moving fast at Y altitude, treat it as a missile.

Predefined radar tracking filters: such as Kalman filters to estimate object trajectories.

Hard-coded decision trees for assigning missiles to targets.

These systems are fast and reliable, but they’re not adaptive. They can’t learn from new types of threats or behavior.

🤖 What AI Can Add: The Algorithms That Matter
Let’s go over specific AI/ML algorithms that could supercharge an air defense system:

1. 🧮 Convolutional Neural Networks (CNNs) for Visual Target Identification

If integrated with optical or infrared sensors:

Purpose: Classify aircraft, drones, or decoys visually.

How it works: CNNs learn patterns in images (like turbine shapes, wing profiles) and can outperform traditional object detection in noisy environments.

Example use: Detect if a low-flying object is a real UAV or a decoy balloon.

2. 📈 Reinforcement Learning (RL) for Engagement Decision-Making

Purpose: Learn optimal defense strategies through simulation and feedback.

How it works: RL agents (like Deep Q-Networks or PPO) try different missile-target strategies in a simulated battlefield. Over time, they learn what decisions lead to success.

Example use: Learn the best firing sequence when faced with a saturation drone swarm attack.

3. 🧠 LSTM (Long Short-Term Memory) Networks for Trajectory Prediction

Purpose: Predict where a target will go based on past movement.

How it works: LSTMs are a type of Recurrent Neural Network (RNN) that can learn temporal patterns—perfect for motion prediction in noisy environments.

Example use: Predict where a hypersonic missile will be 3 seconds from now, even if it suddenly changes direction.

4. 🔍 Anomaly Detection with Autoencoders

Purpose: Spot spoofed or jammed radar signals.

How it works: An autoencoder learns the "normal" signal patterns. When it sees a signal that doesn’t fit, it flags it as a potential threat or decoy.

Example use: Detect radar jamming or stealth aircraft signature anomalies.

5. 🧾 Decision Trees + XGBoost for Threat Classification

Purpose: Classify threats based on structured data (speed, altitude, radar cross-section).

How it works: These models excel at classifying tabular input—like sensor values—into risk levels.

Example use: Score each target in real-time with a “threat score” from 0 to 100.

🔐 Why This Matters

The future battlefield will be filled with:

Swarm drones
Hypersonic missiles
AI-driven stealth aircraft
ECM (Electronic Counter Measures)

To survive, air defense systems need to be just as smart as they are fast.

🧑‍💻 Developers: Your Skills Matter

If you're a developer working in:

AI/ML
Embedded systems
Edge computing
Signal processing

...you can help build the brains behind these next-gen defense systems. It's not just about writing software—it's about writing code that makes life-and-death decisions smarter, safer, and more accountable.

🧠 Final Thoughts

The S-400’s automation is solid—but static. By integrating real AI algorithms, we could enable defense systems to learn from experience, adapt to new threats, and respond faster than any human could.

💬 What’s your take on using machine learning in defense systems? Exciting? Risky? Both? Drop your thoughts below.

Ghibli Art Generation AI — The Fusion of Machine Learning and Animated Aesthetics

Yash Fadadu — Wed, 14 May 2025 14:10:08 +0000

🧠 Overview

Ghibli-style art generation through AI represents a fascinating application of generative deep learning models, particularly those based on diffusion architectures. These systems are capable of producing high-quality, stylized illustrations that resemble the iconic aesthetics of Studio Ghibli’s animation—characterized by soft color palettes, emotional atmospheres, and richly detailed environments.

🔍 How It Works

Ghibli art generation is typically powered by text-to-image and image-to-image models, such as Stable Diffusion, DreamBooth, or LoRA-tuned variants. These models are trained or fine-tuned on large datasets of artwork that resemble or replicate the Ghibli aesthetic.

Key components include:

Diffusion Models: Probabilistic generative models that iteratively denoise random noise into meaningful images. When trained on Ghibli-style datasets, these models learn to reproduce similar artistic features.

DreamBooth / LoRA Fine-Tuning: Techniques used to customize a base model to learn specific art styles. DreamBooth helps the model internalize unique visual characteristics by overfitting on a small curated dataset (e.g., 100–500 images of Ghibli-style frames or fan art).

Text Prompt Engineering: Users describe scenes in natural language (e.g., “a magical forest with floating lanterns”), and the model interprets this to generate corresponding imagery, integrating the learned Ghibli-like features.

Image-to-Image Translation: Users can input photos or sketches, and the model reinterprets them in Ghibli style, preserving structure while applying the aesthetic transformation.

📊 Dataset Considerations

Due to copyright constraints, training typically avoids using original Studio Ghibli frames directly. Instead, fine-tuning datasets often consist of:

High-quality fan art

Open-source anime-style illustrations

Stylized concept art that reflects similar themes and color schemes

Data augmentation (color jittering, cropping, flipping) is used to improve generalization while preserving artistic coherence.

🧠 Technical Stack

While implementations vary, a standard Ghibli-style art generation stack might include:

Model Backbone: Stable Diffusion 1.5 or SDXL

Fine-Tuning Framework: DreamBooth, LoRA, or Textual Inversion

Inference Backend: Python + PyTorch with Hugging Face Transformers & diffusers

Frontend Interface: Web apps built with React or Gradio for demo interactions

Deployment: GPU-accelerated platforms like Hugging Face Spaces, Replicate, or custom servers using NVIDIA GPUs

✨ Applications

Creative Art Generation: Allowing users to visualize fantasy scenes or original characters in a beloved animated style.

Concept Design: Useful for illustrators and indie animators needing quick prototyping in an established aesthetic.

Education: Demonstrating how AI can learn and replicate complex visual styles from limited data.