DEV Community: Abdullah Yasir

Flutter Development Setup for WSL2 + Windows Android Studio (Complete Guide)

Abdullah Yasir — Sun, 02 Nov 2025 12:07:49 +0000

If you love using WSL2 for development but also need Android Studio on Windows — this guide is for you.

This setup runs Flutter (via FVM) natively inside WSL2, while all Android tools (SDK, Studio, emulators) stay on Windows.

After a lot of trial and error, I documented this configuration that works perfectly — Flutter builds, devices connect, and Gradle behaves nicely.

🧠 Overview

We’ll be combining the best of both worlds:

WSL2 (Ubuntu) → Flutter, FVM, Java, Gradle
Windows → Android Studio, Android SDK, emulators
Wrapper scripts → To bridge WSL2 and Windows SDK tools seamlessly

⚙️ Environment Configuration (`~/.bashrc`)

Android SDK (on Windows)

Your Android SDK lives here:


/mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk

Set the following environment variables:

ANDROID_HOME and ANDROID_SDK_ROOT → point to that SDK path
Add Android tools (cmdline-tools, emulator) to your PATH

Java (WSL2 native)

We’ll use OpenJDK 17 installed inside WSL2:


JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64

Add its bin folder to your PATH.

Flutter (via FVM)

Add your FVM-managed Flutter to PATH and set the Dart PUB_CACHE:


~/fvm/default/bin

🧩 Wrapper Scripts (`~/bin/`)

Since WSL2 can’t directly execute .exe files from Linux PATH, we’ll create small bash wrapper scripts to call the Windows versions transparently.


~/bin/adb       → wraps adb.exe
~/bin/aapt      → wraps aapt.exe
~/bin/aapt2     → wraps aapt2.exe
~/bin/zipalign  → wraps zipalign.exe

💡 Java wrappers are not needed — we’re using native WSL2 Java.

🛠️ Android SDK Build Tools

We’ll make Windows executables appear Linux-friendly.

Go to:


/mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/build-tools/36.1.0/

Then copy and symlink the essential build tools as shown below.

🪄 Flutter Configuration

Tell Flutter to use WSL2’s Java:

flutter config --jdk-dir "/usr/lib/jvm/java-17-openjdk-amd64"

Project files will still reference the Windows SDK path (which is fine).

🧰 Step-by-Step Setup Guide

Step 1 — Install Prerequisites

sudo apt update
sudo apt install -y openjdk-17-jdk openjdk-17-jre
java -version

Step 2 — Install FVM and Flutter

Install FVM (see docs):

fvm install stable
fvm global stable

Step 3 — Configure `~/.bashrc`

Append the following block:

# --- Android SDK + Flutter Development (WSL2 with Windows Android Studio)

# User bin (for wrappers like adb)
export PATH="$HOME/bin:$PATH"

# Android SDK (Windows)
export ANDROID_HOME=/mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk
export ANDROID_SDK_ROOT=$ANDROID_HOME

# WSL2 native Java (OpenJDK 17)
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH

# Add Android tools
export PATH="$PATH:$ANDROID_HOME/cmdline-tools/latest/bin"
export PATH="$PATH:$ANDROID_HOME/emulator"

# Flutter (FVM)
export PATH="$HOME/fvm/default/bin:$PATH"
export PUB_CACHE="$HOME/.pub-cache"
export PATH="$PATH:$PUB_CACHE/bin"

Step 4 — Create Wrapper Scripts

mkdir -p ~/bin

cat > ~/bin/adb << 'EOF'
#!/bin/bash
exec /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/platform-tools/adb.exe "$@"
EOF

cat > ~/bin/aapt << 'EOF'
#!/bin/bash
exec /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/build-tools/36.1.0/aapt.exe "$@"
EOF

cat > ~/bin/aapt2 << 'EOF'
#!/bin/bash
exec /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/build-tools/36.1.0/aapt2.exe "$@"
EOF

cat > ~/bin/zipalign << 'EOF'
#!/bin/bash
exec /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/build-tools/36.1.0/zipalign.exe "$@"
EOF

chmod +x ~/bin/adb ~/bin/aapt ~/bin/aapt2 ~/bin/zipalign

Step 5 — Copy Android Build Tools

cd /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/build-tools/36.1.0/
cmd.exe /c "copy aapt.exe aapt"
cmd.exe /c "copy aapt2.exe aapt2"
cmd.exe /c "copy zipalign.exe zipalign"
cmd.exe /c "copy aidl.exe aidl"

Step 6 — Create ADB Symlink

ln -s ~/bin/adb /mnt/c/Users/<your_windows_username>/AppData/Local/Android/Sdk/platform-tools/adb

Step 7 — Configure Flutter

flutter config --jdk-dir "/usr/lib/jvm/java-17-openjdk-amd64"

Step 8 — Reload and Verify

source ~/.bashrc
flutter doctor -v

🧱 Project Configuration

`android/local.properties`

Make sure it uses Windows path format:

sdk.dir=C:\\Users\\<your_windows_username>\\AppData\\Local\\Android\\Sdk

✅ Expected `flutter doctor` Output

Component	Status	Notes
Flutter	✅	Fully functional
Android toolchain	⚠️	Minor warnings are fine
Chrome	❌	Optional (for web)
Linux toolchain	❌	Optional (for desktop)
Android Studio	⚠️	“Not installed” — totally normal (it’s on Windows)
Connected devices	✅	Works fine
Network resources	✅	All good

🏗️ Architecture Overview

┌─────────────────────────────────────┐
│         WSL2 (Ubuntu)               │
│  ┌───────────────────────────┐      │
│  │ Flutter (FVM)             │      │
│  │ Java (OpenJDK 17)         │      │
│  │ Gradle                    │      │
│  └───────────────────────────┘      │
│            ↓                        │
│  ┌───────────────────────────┐      │
│  │ Wrappers (~/bin/)         │      │
│  │ - adb, aapt, aapt2, etc   │      │
│  └───────────────────────────┘      │
│            ↓                        │
└────────────┼────────────────────────┘
             ↓
┌────────────┼────────────────────────┐
│    Windows Host                     │
│  ┌───────────────────────────┐      │
│  │ Android SDK               │      │
│  │ Android Studio            │      │
│  │ Emulators/Devices         │      │
│  └───────────────────────────┘      │
└─────────────────────────────────────┘

📂 Files Modified or Created

File	Purpose
`~/.bashrc`	Environment config
`~/bin/adb`, `~/bin/aapt`, etc.	Wrapper scripts
`android/local.properties`	Windows SDK path

🧩 Troubleshooting

Problem: JAVA_HOME invalid
✅ Solution:

java -version
flutter config --jdk-dir "/usr/lib/jvm/java-17-openjdk-amd64"

Problem: ADB not finding devices
✅ Solution:

adb kill-server && adb start-server

Problem: Gradle build fails
✅ Solution:

flutter clean
rm -rf android/.gradle

✅ That’s it!

Your Flutter + WSL2 setup is now fully functional.
No more Gradle confusion or path issues — just smooth, native Flutter builds in WSL2 with Android Studio staying comfortably on Windows.

A Complete Roadmap for Software Engineers to Learn AI/ML in 2025

Abdullah Yasir — Sat, 18 Jan 2025 12:08:15 +0000

Are you a software engineer eager to jump into the world of Artificial Intelligence (AI) and Machine Learning (ML) in 2025? Great news! With the rapid growth of online resources and powerful tools, getting started is easier than ever. In this post, I'll share a simple, step-by-step roadmap to help you transition into this exciting field, no matter your starting point.

Why Learn AI/ML?

AI and ML are transforming industries—from healthcare and finance to entertainment and autonomous vehicles. With AI/ML skills, you can:

Work on cutting-edge technologies.
Solve complex, real-world problems.
Boost your career prospects (AI/ML jobs are among the highest-paying in tech).

Let’s break it down into a clear, actionable roadmap.

Phase 1: Build Your Foundations (1-3 Months)

Step 1: Brush Up on Math Basics

You don’t need a PhD, but some math concepts are essential for understanding AI/ML:

Linear Algebra: Matrices, eigenvalues, eigenvectors.
Calculus: Gradients, derivatives.
Probability & Statistics: Bayes' theorem, distributions.
Optimization: Gradient descent.

Goal: Get comfortable with math concepts used in ML.

Resources:

3Blue1Brown YouTube Channel (Visual math tutorials for beginners)
Khan Academy: Linear Algebra (Beginner-friendly and interactive)
StatQuest with Josh Starmer (Simple explanations of statistics and ML concepts)

Step 2: Learn Python

Python is the go-to language for AI/ML due to its simplicity and vast ecosystem. Focus on:

Basics: Loops, functions, conditionals.
Libraries: NumPy, Pandas (data manipulation), Matplotlib, and Seaborn (visualization).

Goal: Be proficient in Python programming.

Resources:

Automate the Boring Stuff with Python (Free book for complete beginners)
Python Basics: Real Python (Step-by-step tutorials for beginners)
freeCodeCamp’s Python Course (Comprehensive video for absolute beginners)

Step 3: Understand Data Science Basics

Learn how to clean, process, and visualize data.

Goal: Be able to explore datasets and extract insights.

Resources:

Kaggle Learn (Beginner-friendly modules on data analysis and ML)
Data Science for Beginners (Microsoft) (Free, easy-to-follow curriculum)
freeCodeCamp Data Analysis with Python (Complete course for beginners)

Phase 2: Dive into Machine Learning (3-6 Months)

Step 4: Learn Core Machine Learning

Understand key ML concepts and algorithms:

Supervised Learning: Linear regression, decision trees.
Unsupervised Learning: Clustering, dimensionality reduction.
Model Evaluation: Metrics like accuracy, precision, recall.

Goal: Be able to build, train, and evaluate ML models.

Resources:

Machine Learning Crash Course (Google) (Interactive and beginner-friendly)
Introduction to Machine Learning by Kaggle (Perfect for new learners)
Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (Beginner-accessible book with practical examples)

Step 5: Explore Deep Learning

Learn about neural networks and advanced topics like:

Convolutional Neural Networks (CNNs) for image data.
Recurrent Neural Networks (RNNs) for sequential data.
Pretrained models and transfer learning.

Goal: Build deep learning models using TensorFlow or PyTorch.

Resources:

Deep Learning for Beginners (freeCodeCamp) (Friendly introduction to neural networks)
Deep Learning Specialization by Andrew Ng (Coursera) (Great for beginners; start free!)
TensorFlow for Beginners (Official) (Step-by-step guides)

Phase 3: Build Projects and Get Hands-On (6-12 Months)

Step 6: Work on Real-World Projects

The best way to learn is by doing! Start with beginner-friendly projects:

Predict house prices (regression).
Classify handwritten digits (MNIST dataset).

Move on to intermediate and advanced projects:

Image classification with CNNs.
Sentiment analysis with NLP models.
Time-series forecasting.

Goal: Complete 3-5 projects and showcase them in your portfolio.

Resources:

Kaggle Datasets and Competitions (Beginner-friendly challenges)
Google Dataset Search (Find datasets for practice)
fast.ai’s Practical Deep Learning Course (Hands-on projects for beginners)

Step 7: Participate in Competitions

Compete in Kaggle or other platforms to learn from others and build your reputation.

Goal: Participate in 1-2 Kaggle competitions.

Phase 4: Specialize and Deepen Knowledge (12-24 Months)

Step 8: Explore Advanced Topics

Once you’ve mastered the basics, dive deeper:

Reinforcement Learning: Used in robotics and gaming.
Natural Language Processing (NLP): For chatbots and text analysis.
Computer Vision: Object detection, image segmentation.

Goal: Gain expertise in 1-2 specialized areas.

Resources:

Reinforcement Learning Specialization (Coursera) (Beginner-friendly course)
Hugging Face’s NLP Course (Free and accessible)
Deep Learning for Computer Vision by PyImageSearch (Step-by-step tutorials for beginners)

Phase 5: Learn Deployment and MLOps

Step 9: Deploy AI Models

Learn to integrate AI/ML models into real-world applications:

Use Flask or FastAPI for APIs.
Deploy models on AWS, GCP, or Azure.

Goal: Deploy at least one project.

Resources:

Deploying Machine Learning Models (YouTube) (Beginner’s guide)
AWS AI/ML Services (Simple tools for deploying models)
fullstackopen’s ML Deployment Guide (For beginners)

Step 10: Learn MLOps

Understand how to manage, monitor, and optimize ML pipelines.

Goal: Automate and monitor ML workflows.

Resources:

MLOps for Beginners by Microsoft (Free and beginner-friendly)
MLflow for Beginners (Manage ML experiments easily)

Phase 6: Build Your Portfolio and Network

Step 11: Showcase Your Work

Create a portfolio to highlight your projects:

Use GitHub for code.
Write blog posts explaining your work (use platforms like Dev.to or Medium).
Create a personal website using GitHub Pages.

Step 12: Network and Stay Updated

Join AI/ML communities on Discord, Reddit, or LinkedIn.
Attend conferences like NeurIPS, ICML, or local meetups.
Follow AI thought leaders like Andrew Ng and Lex Fridman.

Suggested Timeline

Here’s a rough timeline to keep you on track:

0-3 Months: Learn math, Python, and data science basics.
3-6 Months: Dive into ML and DL concepts.
6-12 Months: Build projects, join competitions.
12-24 Months: Specialize, deploy models, and learn MLOps.

Final Thoughts

Learning AI/ML is a journey, not a sprint. Start small, build consistently, and keep learning. Remember, even small progress daily adds up to significant expertise over time.

Note: The resources linked in this post are not affiliated or sponsored. They are chosen based on their quality and accessibility for beginners.

If you’re ready to get started, bookmark this roadmap and begin today. Good luck, and welcome to the future of technology!

Have questions or need guidance? Drop a comment below!

Understanding LRU Cache: Efficient Data Storage and Retrieval

Abdullah Yasir — Sat, 18 Jan 2025 10:20:15 +0000

In the world of software engineering, one of the most common problems developers face is how to store data efficiently for quick retrieval. This becomes particularly challenging when dealing with large amounts of data or limited memory resources. This is where an LRU (Least Recently Used) Cache comes in.

In this blog post, we'll take a closer look at what an LRU cache is, why it’s important, and how it can be implemented.

What is an LRU Cache?

An LRU cache is a data structure used to store a fixed number of items, with the goal of evicting the least recently used item when the cache reaches its capacity. The idea is simple: when a new item needs to be added, the cache will evict the least recently accessed item to make room for the new one.

In simple terms:

LRU stands for Least Recently Used.
The cache stores a limited number of items, and when it’s full, the item that hasn’t been used for the longest period is removed to make space for new data.

This kind of caching mechanism is particularly useful for scenarios like memory caching, web browsers, and database management, where you want to keep frequently accessed data available for quick retrieval but don’t have unlimited memory to store everything.

Why Use an LRU Cache?

When building systems that require efficient data retrieval, an LRU cache can help you:

Improve Performance: By storing only the most recently accessed data, you can significantly speed up access times for repeated requests.
Optimize Memory Usage: It ensures that only the most important or frequently used data stays in memory, preventing unnecessary memory bloat.
Handle Large Datasets: When working with large datasets, an LRU cache ensures that the system only keeps relevant items in memory, preventing the need to fetch data from slower storage (e.g., a database or API) repeatedly.
Reduce Latency: By reducing the need to fetch data from slower sources, you reduce the overall system latency, resulting in faster response times.

How Does an LRU Cache Work?

An LRU cache is typically implemented using a combination of two data structures:

Doubly Linked List: To maintain the order of access (most recent to least recent).
Hash Map (or Dictionary): To allow for constant time O(1) access to cache items.

Here’s how the mechanism works:

When a new item is accessed: The item is moved to the front of the doubly linked list (marking it as the most recently used).
When the cache reaches its limit: The item at the end of the list (the least recently used item) is evicted to make room for new data.
Inserting new items: If the cache is not full, the item is added to the front of the list and placed in the hash map for O(1) access.

By combining the hash map (for fast access) and the doubly linked list (for efficient item removal), an LRU cache can operate in constant time for both get and put operations.

LRU Cache in Action: Example Implementation

Let's now look at a simple implementation of an LRU Cache in JavaScript. We'll use a Map object (which preserves insertion order) for storing the cache and a fixed limit for the cache size.

Example Code (JavaScript):

class LRUCache {
    constructor(capacity) {
        this.cache = new Map();
        this.capacity = capacity;
    }

    // Get value from cache
    get(key) {
        if (!this.cache.has(key)) {
            return -1; // Key not found
        }

        // Move the accessed key to the front (most recently used)
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, value);

        return value;
    }

    // Set value in cache
    put(key, value) {
        if (this.cache.has(key)) {
            // Remove the old value (if exists)
            this.cache.delete(key);
        } else if (this.cache.size >= this.capacity) {
            // Cache is full, remove the least recently used item
            this.cache.delete(this.cache.keys().next().value);
        }

        // Insert the new key-value pair at the front
        this.cache.set(key, value);
    }
}

// Example usage:
const cache = new LRUCache(3);

cache.put(1, "A");
cache.put(2, "B");
cache.put(3, "C");

console.log(cache.get(1));  // Returns "A"
cache.put(4, "D");         // Removes key 2 (least recently used)

console.log(cache.get(2));  // Returns -1 (not found)
console.log(cache.get(3));  // Returns "C"
console.log(cache.get(4));  // Returns "D"

Explanation:

get(key): If the key exists, it’s moved to the front of the cache and its value is returned. If the key doesn’t exist, -1 is returned.
put(key, value): If the key already exists, the old value is removed and the new one is inserted. If the cache is full, the least recently used item (the one at the beginning of the list) is removed to make space for the new key-value pair.

Example Flow:

After inserting key-value pairs (1, "A"), (2, "B"), and (3, "C"), the cache looks like this: {1: "A", 2: "B", 3: "C"}.
When you access key 1, the cache becomes {2: "B", 3: "C", 1: "A"}.
When you insert key 4, the cache evicts key 2 (the least recently used) and becomes {3: "C", 1: "A", 4: "D"}.

LRU Cache: Use Cases

Here are some scenarios where LRU caches are particularly beneficial:

Web Caching: Caching HTTP responses, images, or API results for faster retrieval.
Database Query Caching: Storing frequently accessed database query results to reduce load and latency.
Session Management: Storing user session data in memory, where the most recently used session remains active.
Memory Management: Optimizing memory usage by ensuring that only the most important or frequently used objects stay in memory.

Advantages and Limitations

Advantages:

O(1) Time Complexity: Both get and put operations have constant time complexity, making it highly efficient.
Space Efficiency: Ensures that only the most frequently used data is stored in memory, optimizing cache size.

Limitations:

Limited Cache Size: The cache is limited by the specified capacity, meaning less frequently accessed data will be evicted.
Cache Misses: When the cache is full, any new access will result in a cache miss, requiring data to be fetched from the original source (e.g., database or API).

Conclusion

An LRU Cache is an essential data structure that allows you to manage memory efficiently by storing and retrieving the most recently used data while evicting the least recently used. It’s widely applicable in caching scenarios where you need to optimize for both performance and memory usage.

Whether you're building an API that requires fast access to frequently used data, developing a memory management system, or improving the responsiveness of a web application, understanding and implementing an LRU cache can help your system scale effectively.

Understanding Worker Threads in Node.js: A Deep Dive

Abdullah Yasir — Sat, 18 Jan 2025 09:56:23 +0000

Node.js is renowned for its non-blocking, event-driven architecture, making it an excellent choice for handling high concurrency, especially for I/O-bound operations. But what happens when you need to perform heavy computations? How do you ensure that CPU-intensive tasks don’t block the main event loop and degrade the performance of your Node.js application? This is where worker threads come into play.

In this blog post, we will explore what worker threads are in Node.js, how they work, and how they differ from threads in other languages like C++ or Java. Additionally, we’ll simulate heavy computational tasks to see how worker threads can help handle these efficiently.

What Are Worker Threads in Node.js?

By default, Node.js operates in a single-threaded environment, meaning that JavaScript code runs in a single execution thread (the event loop). While this is efficient for handling I/O operations asynchronously, it can be a bottleneck when it comes to CPU-bound tasks, such as processing large datasets, performing complex calculations, or handling intensive image or video processing.

To address this, Node.js introduced the worker threads module, which allows you to run JavaScript code in parallel threads. These threads can offload heavy computations and prevent them from blocking the main event loop, thereby improving overall performance.

How Do Worker Threads Work in Node.js?

Worker threads in Node.js are native OS threads, meaning they are managed by the operating system just like threads in traditional multi-threaded applications. However, unlike traditional threads in some languages, worker threads in Node.js are designed to work within the constraints of the single-threaded JavaScript model, which means they have isolated memory and communicate via message passing.

Here’s a simple example demonstrating how to use worker threads in Node.js:

const { Worker, isMainThread, parentPort } = require('worker_threads');

if (isMainThread) {
  // Main thread: Create a worker
  const worker = new Worker(__filename); // Running the same file in the worker
  worker.on('message', (message) => {
    console.log('Message from worker:', message); // Receiving result from worker
  });
  worker.postMessage('Start the work');
} else {
  // Worker thread: Handling the task
  parentPort.on('message', (message) => {
    console.log('Received in worker:', message);
    const result = heavyComputation(40); // Some CPU-bound task
    parentPort.postMessage(result); // Sending result back to the main thread
  });
}

function heavyComputation(n) {
  // A naive recursive Fibonacci function to simulate heavy computation
  if (n <= 1) {
    return n;
  }
  return heavyComputation(n - 1) + heavyComputation(n - 2);
}

In this example, the main thread creates a worker thread using the same script. The worker performs a heavy computation (in this case, calculating Fibonacci numbers) and sends the result back to the main thread via postMessage().

Key Characteristics of Worker Threads:

Real Operating System Threads: Worker threads are actual OS threads, and they run independently of the main thread, making them suitable for computationally expensive tasks.
Isolated Memory: Unlike traditional threads that can share memory, worker threads have their own isolated memory. Communication between threads is done via message passing, ensuring data integrity and reducing the risk of race conditions.
Concurrency Without Blocking: Worker threads allow for concurrent execution of code, ensuring that the main thread remains responsive while the worker threads handle CPU-intensive tasks.

When to Use Worker Threads?

You should use worker threads in Node.js when:

CPU-intensive tasks: Tasks such as heavy calculations, image/video processing, or complex data manipulation that can block the event loop.
Non-blocking concurrency: When you need to perform computations without disrupting the main event loop’s ability to handle other asynchronous I/O operations, such as handling HTTP requests.
Avoiding single-threaded performance bottlenecks: If you are running Node.js on a multi-core machine, worker threads can make use of multiple cores to improve performance by distributing the computational load.

For example, processing large sets of data, like parsing a huge CSV file or running deep learning models, can significantly benefit from being offloaded to worker threads.

Simulating Heavy Computation with Worker Threads

Let’s take a look at how we can simulate CPU-heavy tasks and see how worker threads can offload such operations to keep the event loop responsive.

Example 1: Simulating Heavy Computation with Fibonacci Numbers

In this example, we use a naive recursive algorithm to calculate Fibonacci numbers, which has exponential complexity and is ideal for simulating heavy computation.

function heavyComputation(n) {
  // A naive recursive Fibonacci function to simulate heavy computation
  if (n <= 1) {
    return n;
  }
  return heavyComputation(n - 1) + heavyComputation(n - 2);
}

console.log("Starting heavy computation...");

// Simulate heavy computation with Fibonacci
const result = heavyComputation(40); // Using a high value to simulate delay
console.log("Computation result:", result);

This function calculates Fibonacci numbers and can be very slow for large n, making it an ideal task for worker threads. You can now use the previous example where a worker thread calculates the Fibonacci sequence while the main thread stays responsive.

Example 2: Simulating Heavy Computation with Sorting

Sorting large datasets is another classic example of a CPU-heavy task. Here’s how we can simulate heavy computation by sorting a large array of random numbers:

function heavyComputation() {
  // Generate an array of random numbers
  const arr = [];
  for (let i = 0; i < 1e6; i++) {
    arr.push(Math.floor(Math.random() * 1000000));
  }

  // Sort the array (computationally expensive task)
  arr.sort((a, b) => a - b);

  console.log("Sorting complete.");
  return arr[0]; // Return the smallest element for demo purposes
}

console.log("Starting heavy computation...");
const result = heavyComputation();
console.log("Smallest element after sorting:", result);

Sorting a million numbers can take a significant amount of time, and this task is well-suited to be handled by worker threads. The worker can perform the sorting operation while the main thread continues to handle other tasks.

Example 3: Simulating Heavy Computation with Prime Number Calculation

Prime number calculation is another example of a CPU-intensive task. Here's how to find all prime numbers in a large range using a naive method:

function isPrime(num) {
  if (num <= 1) return false;
  for (let i = 2; i <= Math.sqrt(num); i++) {
    if (num % i === 0) return false;
  }
  return true;
}

function heavyComputation(limit) {
  const primes = [];
  for (let i = 2; i <= limit; i++) {
    if (isPrime(i)) primes.push(i);
  }
  return primes.length; // Return the count of prime numbers
}

console.log("Starting heavy computation...");
const result = heavyComputation(10000); // Check primes up to 10,000
console.log("Number of primes:", result);

This task requires checking each number up to limit to determine whether it is prime, which can be computationally expensive. Using worker threads to offload this task will prevent it from blocking the event loop.

Worker Threads vs. Threads in Other Languages

At this point, you might be wondering: How do worker threads in Node.js compare to traditional threads in other programming languages, like C++ or Java?

Here’s a breakdown of the key differences:
Here’s the updated table without the "Aspect" column:

Worker Threads in Node.js	Threads in C++/Java
No shared memory; communication is done via message passing.	Threads typically share memory, leading to easier data sharing but more potential for race conditions.
Each worker runs independently with its own event loop.	Threads run concurrently, each with its own execution flow, but they share a common memory space.
Communicates using message passing (via `postMessage()` and event listeners).	Communicate via shared memory, variables, or specialized synchronization methods (mutexes, semaphores).
More restrictive than traditional threads due to isolation and message passing, but safer in terms of concurrency.	Easier to work with for shared memory access, but more prone to issues like deadlocks or race conditions.
Ideal for offloading CPU-heavy tasks in a non-blocking environment.	Best for tasks that require frequent interaction with shared memory and parallel execution in memory-heavy applications.

Memory Sharing and Communication:

In Java and C++, threads typically share memory and can directly access the same variables. While this is efficient for communication between threads, it introduces the risk of race conditions if multiple threads try to modify the same data simultaneously. To avoid this, synchronization techniques like mutexes or semaphores are often used, which can lead to complex and error-prone code.

On the other hand, worker threads in Node.js do not share memory directly. Instead, they communicate via message passing, which makes them safer to use in highly concurrent applications. While this communication model is more restrictive, it avoids common issues found in multi-threaded programming.

Conclusion

Worker threads in Node.js provide a powerful mechanism for performing CPU-intensive tasks without blocking the main event loop. They allow for parallel execution of code, enabling Node.js to handle computationally expensive operations like sorting large datasets, calculating Fibonacci numbers, or finding prime numbers more efficiently.

When compared to threads in Java or C++, worker threads in Node.js offer a simpler model by enforcing memory isolation and communication through message passing. This reduces the risk of concurrency issues, making them easier and safer to use in applications where offloading tasks from the main thread is crucial.

Whether you are building a web server, performing data analysis, or processing large amounts of data, worker threads can help you achieve better performance and keep your application responsive.

Understanding Queues in Node.js (The Easy Way!)

Abdullah Yasir — Sat, 18 Jan 2025 09:38:58 +0000

If you’ve been working with Node.js, you’ve probably heard terms like event loop, promises, and queues thrown around. But what exactly are these queues, and how do they work together to make Node.js so efficient? Let’s break it down in simple, everyday English.

What Are Queues in Node.js?

In Node.js, queues are places where tasks (like callbacks) are stored and processed by the event loop. Think of the queues like different lines at a coffee shop:

One line for people with mobile orders (microtasks).
Another line for walk-in orders (macrotasks like timers).
A separate line for special requests (like closing the shop or cleaning up).

Each queue has a specific role, and the event loop decides the order in which to serve these lines.

Types of Queues in Node.js

1. Microtask Queue (VIP Line)

What is it?
- This is the queue for tiny, high-priority tasks. These include resolved promises and process.nextTick() callbacks.
How does it work?
- Imagine you have a VIP line at a coffee shop that always gets served before the regular line, even if the regular customers were waiting first. That’s how the microtask queue works—it gets priority over everything else.
Examples:

  console.log("Start");

  Promise.resolve().then(() => {
    console.log("Promise resolved");
  });

  process.nextTick(() => {
    console.log("Next tick");
  });

  console.log("End");

Output:

  Start
  End
  Next tick
  Promise resolved

Why? The synchronous code runs first. Then the microtasks (process.nextTick and Promise.then) are executed in order.

2. Timer Queue (Walk-In Customers)

What is it?
- This queue handles tasks scheduled by setTimeout() and setInterval().
How does it work?
- Imagine you walk into a coffee shop and place an order. Your order will only be prepared after a specific delay (the timeout period).
Example:

  setTimeout(() => {
    console.log("Timer callback");
  }, 0);

  console.log("End of script");

Output:

  End of script
  Timer callback

Even with a 0 delay, the timer callback is placed in the timer queue and only runs after the current code and microtasks finish.

3. I/O Queue (Order Processing)

What is it?
- This queue handles I/O tasks like reading files, database queries, or network requests.
How does it work?
- Imagine you placed an order that takes some time to prepare, like a custom latte. Your order goes into the “processing” line, and you’ll get it once it’s ready.
Example:

  const fs = require("fs");

  fs.readFile("file.txt", () => {
    console.log("File read complete");
  });

  console.log("End of script");

Output:

  End of script
  File read complete

The file read is handled in the I/O queue, so it happens after the synchronous code finishes.

4. Check Queue (Special Express Line)

What is it?
- This queue handles setImmediate() callbacks, which are processed after I/O tasks but before timers in the next loop iteration.
How does it work?
- Think of this as a special express line for people who ordered something unusual but still get priority over timers.
Example:

  setImmediate(() => {
    console.log("Immediate callback");
  });

  console.log("End of script");

Output:

  End of script
  Immediate callback

5. Close Queue (Closing Time Tasks)

What is it?
- This queue handles callbacks for the close event, such as closing a file stream or socket.
How does it work?
- Imagine it’s closing time at the coffee shop, and you’re finishing up orders for people who were already served.
Example:

  const net = require("net");

  const server = net.createServer();

  server.on("close", () => {
    console.log("Server closed");
  });

  server.close();

Putting It All Together

Here’s how the event loop processes these queues in order:

Execute all synchronous code first.
Process the microtask queue (e.g., resolved promises).
Process the timer queue (e.g., setTimeout, setInterval).
Handle I/O callbacks (e.g., file reads, network requests).
Process the check queue (e.g., setImmediate).
Handle the close queue (e.g., resource cleanup).

Summary Table

Queue Type	Examples	Priority
Microtask Queue	Promises, `process.nextTick`	Highest
Timer Queue	`setTimeout`, `setInterval`	After microtasks
I/O Queue	File system, network I/O callbacks	After timers
Check Queue	`setImmediate`	After I/O
Close Queue	Resource close events (`'close'`)	After check phase

Why Should You Care?

Understanding how these queues work can:

Help you debug issues like unexpected delays in callbacks.
Optimize performance by knowing when and where to schedule tasks.
Make you a better Node.js developer overall!

Next time you’re debugging a Node.js app, think of the coffee shop queues and remember—Node.js might look single-threaded, but it’s got a lot happening behind the scenes!

DEV Community: Abdullah Yasir

Flutter Development Setup for WSL2 + Windows Android Studio (Complete Guide)

🧠 Overview

⚙️ Environment Configuration (~/.bashrc)

Android SDK (on Windows)

Java (WSL2 native)

Flutter (via FVM)

🧩 Wrapper Scripts (~/bin/)

🛠️ Android SDK Build Tools

🪄 Flutter Configuration

🧰 Step-by-Step Setup Guide

Step 1 — Install Prerequisites

Step 2 — Install FVM and Flutter

Step 3 — Configure ~/.bashrc

Step 4 — Create Wrapper Scripts

Step 5 — Copy Android Build Tools

Step 6 — Create ADB Symlink

Step 7 — Configure Flutter

Step 8 — Reload and Verify

🧱 Project Configuration

android/local.properties

✅ Expected flutter doctor Output

🏗️ Architecture Overview

📂 Files Modified or Created

🧩 Troubleshooting

A Complete Roadmap for Software Engineers to Learn AI/ML in 2025

Why Learn AI/ML?

Phase 1: Build Your Foundations (1-3 Months)

Step 1: Brush Up on Math Basics

Step 2: Learn Python

Step 3: Understand Data Science Basics

Phase 2: Dive into Machine Learning (3-6 Months)

Step 4: Learn Core Machine Learning

Step 5: Explore Deep Learning

Phase 3: Build Projects and Get Hands-On (6-12 Months)

Step 6: Work on Real-World Projects

Step 7: Participate in Competitions

Phase 4: Specialize and Deepen Knowledge (12-24 Months)

Step 8: Explore Advanced Topics

Phase 5: Learn Deployment and MLOps

Step 9: Deploy AI Models

Step 10: Learn MLOps

Phase 6: Build Your Portfolio and Network

Step 11: Showcase Your Work

Step 12: Network and Stay Updated

Suggested Timeline

Final Thoughts

Understanding LRU Cache: Efficient Data Storage and Retrieval

What is an LRU Cache?

Why Use an LRU Cache?

How Does an LRU Cache Work?

LRU Cache in Action: Example Implementation

Example Code (JavaScript):

Explanation:

Example Flow:

LRU Cache: Use Cases

Advantages and Limitations

Advantages:

Limitations:

Conclusion

Understanding Worker Threads in Node.js: A Deep Dive

What Are Worker Threads in Node.js?

How Do Worker Threads Work in Node.js?

Key Characteristics of Worker Threads:

When to Use Worker Threads?

Simulating Heavy Computation with Worker Threads

Example 1: Simulating Heavy Computation with Fibonacci Numbers

Example 2: Simulating Heavy Computation with Sorting

Example 3: Simulating Heavy Computation with Prime Number Calculation

Worker Threads vs. Threads in Other Languages

Memory Sharing and Communication:

Conclusion

Understanding Queues in Node.js (The Easy Way!)

What Are Queues in Node.js?

Types of Queues in Node.js

1. Microtask Queue (VIP Line)

2. Timer Queue (Walk-In Customers)

3. I/O Queue (Order Processing)

4. Check Queue (Special Express Line)

5. Close Queue (Closing Time Tasks)

⚙️ Environment Configuration (`~/.bashrc`)

🧩 Wrapper Scripts (`~/bin/`)

Step 3 — Configure `~/.bashrc`

`android/local.properties`

✅ Expected `flutter doctor` Output