DEV Community: Ikegbo Ogochukwu

How to Convert Bash Kaggle Commands to PowerShell (Without Breaking Your Setup)

Ikegbo Ogochukwu — Thu, 10 Sep 2026 14:17:16 +0000

How to Convert Bash Kaggle Commands to PowerShell (Without Breaking Your Setup)

If you have ever tried to follow a machine learning tutorial on Windows, you have probably run into a Bash script that looks exactly like this:

mkdir -p ~/.kaggle && echo "YOUR_TOKEN" > ~/.kaggle/access_token && chmod 600 ~/.kaggle/access_token

You paste it into PowerShell, hit enter, and... Boom. Red error text everywhere. 💥

Windows handles file paths, environment variables, and file permissions completely differently than Linux or macOS. If you need to translate that exact Bash one-liner into clean, native PowerShell, here is how you do it step-by-step.

The PowerShell Equivalent

Open your PowerShell window and run this block of code:

1. Create the directory safely (acts like mkdir -p)

New-Item -ItemType Directory -Force -Path "$HOME.kaggle"

2. Write the token to the file (acts like echo >)

Set-Content -Path "$HOME.kaggle\access_token" -Value "KGAT_f84238731c3b8830736ae42599c6ac80"

3. Restrict permissions exclusively to your user (acts like chmod 600)

$Acl = Get-Acl -Path "$HOME.kaggle\access_token"
$Acl.SetAccessRuleProtection($true, $false) # Strip away inherited permissions
$AccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($env:USERNAME, "FullControl", "Allow")
$Acl.AddAccessRule($AccessRule)
Set-Acl -Path "$HOME.kaggle\access_token" -AclObject $Acl

🔍 Breaking Down the Differences## 1. File Paths (~ vs $HOME)

In Bash: ~ points directly to your home directory (/home/username).
In PowerShell: While PowerShell supports ~ in some commands, it can be unpredictable in scripts. Using $HOME points cleanly to your Windows user profile (typically C:\Users\YourName).

2. Creating Folders (mkdir -p vs New-Item -Force)

In Bash: mkdir -p ensures the folder is created and prevents errors if it already exists.
In PowerShell: New-Item -ItemType Directory -Force does the exact same thing. The -Force parameter prevents PowerShell from throwing an error if the .kaggle folder is already there.

3. Writing Files (echo > vs Set-Content)

In Bash: echo token > file creates or overwrites a file with the string text.
In PowerShell: While echo "token" > file technically works in PowerShell, it often encodes the file in UTF-16 LE, which causes weird character parsing errors with API clients. Set-Content ensures a cleaner, standard string delivery.

4. Permissions (chmod 600 vs Windows ACL)

This is where developers usually get stuck. Windows does not use POSIX bitmask permissions (600, 755, etc.). It uses an Access Control List (ACL).
chmod 600 means: "Only the file owner can read/write this file. Everyone else gets nothing."
To do this in Windows, our script:

Uses SetAccessRuleProtection($true, $false) to block inherited permissions from the parent folder (which normally lets administrators or other users read it).
Explicitly grants Full Control exclusively to your active Windows username ($env:USERNAME).

💡 Pro-Tip: Exporting the Config Directory

Many Kaggle API tools look for a kaggle.json file inside a directory path stored in your environment variables.
If you need to quickly tell your session where to look for your credentials, you can set an environment variable using this command:

For the current session only:

$env:KAGGLE_CONFIG_DIR = "$HOME.kaggle"

To make it permanent across all future sessions:

Note: If you run the permanent command, make sure to restart your PowerShell window for it to take effect!

Wrap Up

Switching back and forth between terminal syntaxes can be a headache, but learning how PowerShell processes paths and ACL objects will save you hours of debugging when deploying local data science environments on Windows.

Happy coding! 🚀

How to Set Up n8n Locally with Docker Desktop:

Ikegbo Ogochukwu — Tue, 01 Sep 2026 17:20:24 +0000

This complete beginner's guide walks through every step to prepare your computer, install Docker Desktop, and run n8n locally with persistent storage.

1. Check System Requirements and Enable Virtualization

Docker requires hardware virtualization enabled in your computer's BIOS/UEFI to run containers.

Check on Windows:

Press Ctrl + Shift + Esc to open Task Manager.
Click the Performance tab, then select CPU.
Look at the bottom-right for Virtualization: Enabled. If disabled, enable Intel VT-x / AMD-V in your BIOS.
Open PowerShell as Administrator and run:


powershell
   wsl --install

I Built a Soil Fertility AI Pipeline That Runs on a Raspberry Pi 5 — Here's How

Ikegbo Ogochukwu — Tue, 01 Sep 2026 09:54:19 +0000

An end-to-end walkthrough of training a CNN on soil images, fusing predictions with synthetic sensor data, and deploying to the edge — including every gotcha.

Introduction

Our "5G in Agriculture" project required building a full soil fertility assessment pipeline: multi-parameter sensors, GPS-based spatial mapping, deep learning inference, and a cloud dashboard — all running on a Raspberry Pi 5 edge device.

Since we don't have real sensor hardware yet, and haven't visited any farmland, we needed the entire system to be testable right now from my desk — without sacrificing fidelity. So I combined synthetic sensor data with a custom CNN trained on public soil image datasets, fused both streams at inference time, and served results through a live web dashboard.

Here's the complete story — architecture, code, results, and the things that almost didn't work.

Architecture

┌───────────────(one-time)──────────────┐   ┌──────────────(continuous)─────────────┐
│  train_all.py                         │   │  run_edge.py                           │
│                                       │   │                                        │
│  data/download.py    ──────────────┐  │   │  SimulatedSensor                       │
│         ↓                          │  │   │      ↓ NPK / pH / moisture             │
│  model/train_image.py  ────────────┼──┼──→  edge/infer_loop.py                     │
│         ↓                          │  │   │      ↓ MLP (windowed readings)         │
│  models/*.pt          ← Model file →│  │   │      ↓ (optional) Camera frame         │
└───────────────training──────────────┘  │   │            ↓ Image CNN                 │
                                         │   │      ↓ Late Fusion                      │
┌────────────────────────────────────────┘   │   │            ↓ MQTT                   │
│  web/app.py           ← Dashboard         │   │            ↓ Publish                  │
│         ↓                                 │   │                                        │
│  Flask server: / /map /history /settings │   └────────────────────────────────────────┘
└──────────────────────────────────────────┘

Two independent pipelines feeding into one decision:

Sensor branch: Sliding window of 12 recent readings → sklearn MLPClassifier → class probability vector
Image branch: Real soil photograph → Pure-PyTorch MobileNetV3-style CNN → class probability vector
Fusion: Weighted average (0.7 × sensor + 0.3 × image) → final prediction

Both produce (High, Low, Moderate) softmax vectors, so fusion is just element-wise weighted averaging — simple, interpretable, reversible.

Why Pure PyTorch (Not TensorFlow or ONNX)

A common mistake is reaching for TensorFlow first. On this stack, it was broken:

Framework	Status
TF 2.21 + Python 3.13	Broken — ABI mismatch on Windows DLLs
ONNX Runtime	Broken — same VC++ redistributable issue
torchvision	Unavailable — no wheel for our Python version
PyTorch CPU	Working — pure Python ops, TorchScript export

The fix was straightforward: build a custom CNN entirely from torch.nn primitives (no torchvision). Trained from scratch on public soil image datasets, exported as a TorchScript .pt file — zero Python dependency at inference time.

Training Results

Dataset: Phantom-fs/Soil-Classification-Dataset (7 soil types → mapped to 3 fertility tiers via agricultural science):

Tier	Soil Types
High	Alluvial, Black
Moderate	Red, Yellow
Low	Laterite, Arid, Mountain

SoilCNN Architecture

~0.6M parameters. Inspired by MobileNetV3-Small but built from scratch:

class SoilCNN(nn.Module):
    def __init__(self, num_classes=3, img_size=224):
        # Stem: Conv2d(3→16, k=3, s=2, p=1) → BN → HardSwish()
        self.stem = nn.Sequential(...)
        # Body: 7 stages of DepthwiseSeparableConv blocks
        self.body = nn.Sequential(*layers)
        # Head: Conv2d(320→1280, k=1) → BN → HardSwish → GAP → Dropout → FC
        self.head = nn.Sequential(...)

Each body stage uses DepthwiseSeparableConv internally, which wraps a SEBlock (Squeeze-and-Excitation) followed by depthwise → pointwise convolution + batch norm + activation. The last block uses HardSwish instead of ReLU to stay closer to MobileNetV3 design principles.

Metrics

After 30 epochs (Adam, cosine annealing LR, class-weighted loss):

Class	Precision	Recall	F1	Support
High	0.98	0.98	0.98	445
Low	0.96	0.95	0.96	280
Moderate	0.99	0.99	0.99	533
Overall	—	—	0.98	1258

Validation accuracy peaked at 98.4%. Not production-grade for soil science (real lab validation would require thousands of annotated field photographs), but strong enough to demonstrate the dual-stream pipeline end-to-end.

Export: models/soil_image_model.pt — a 3 MB TorchScript file ready for the Pi.

What You Can Actually Test Right Now

With --simulate, the entire system runs without hardware:

# Terminal 1 — inference loop with simulated sensors + synthetic camera
python run_edge.py --simulate --map --map-walk --sim-demo --camera-demo \
    --period 1

# Terminal 2 — web dashboard
python run_web.py
# Open http://localhost:5000

This produces:

A live IDW-mapped PNG showing high/moderate/low zones across the farm
JSON-per-line logs pushed to MQTT
A Flask dashboard with latest map, table of predictions, colour-feature stats
CSV with 15 columns: timestamp, lat, lon, score, class, confidence, img_label, img_conf, L*, a*, b*, dark_colour_index, organic_proxy, moisture_proxy, crack_proxy

Replace --camera-demo with --picamera when you have a PiCamera v3 module connected. The Picamera2Camera class wraps libcamera on Raspberry Pi OS Bookworm natively.

Deploying to the Raspberry Pi 5

The hard part wasn't writing code — it was getting it to run. Three blockers took most of the effort:

Blocker 1: No PyTorch wheels for Python 3.13 on ARM

ERROR: Could not find a version that satisfies the requirement torch

PyTorch doesn't ship Python 3.13 ARM wheels yet (as of August 2026). Python 3.13 on the Pi was too bleeding-edge. Fix: install Python 3.11 and use a separate venv.

Blocker 2: scikit-image won't compile on Python 3.13 + GCC 14.2.0

When pip tried to build scikit-image from source, pythran-generated C++ code failed because Pythran uses _v suffix traits (is_integral_v) that Debian's GCC 14 headers expose as plain is_integral:

error: 'is_integral_v' is not a member of 'std'; did you mean 'is_integral'?

Fix: pin scikit-image < 0.24 (the 0.23.x series has a pre-built wheel for 3.13) or downgrade to Python 3.11 where both packages have pre-built wheels.

Blocker 3: NetworkManager profile secret never persisted to disk

The most frustrating bug. After creating a Wi-Fi connection profile with nmcli, checking its contents with nmcli -s show showed the password correctly stored. But the actual config file on disk had psk= empty:

[wifi-security]
key-mgmt=wpa-psk
psk=   ← nothing here

NetworkManager reads the file, sees no secret, rejects the connection, and nmcli lies to your face about having saved it. Fix: edit /etc/NetworkManager/system-connections/<profile>.nmconnection directly and restart NM.

These three issues alone cost more time than writing the actual pipeline code. Lesson learned: always verify state with cat before assuming a tool reported truth.

File Structure

soil_ai/
├── config.py                # Central config: paths, classes, fusion weights
├── requirements.txt
├── run_edge.py              # Edge inference entry point
├── run_web.py               # Web dashboard entry point
├── model/
│   ├── train_image.py       # Train SoilCNN (pure PyTorch) → TorchScript
├── edge/
│   ├── sensors.py           # SimulatedSensor (synthetic NPK/pH/moisture/GPS)
│   ├── mqtt_client.py       # MQTT publisher
│   ├── infer_loop.py        # Main loop: buffer → predict → fuse → publish
│   └── camera.py            # CameraSimulator + Picamera2Camera + preprocessing
├── spatial/
│   ├── live.py              # MapRecorder: CSV + periodic PNG render
│   └── interpolate.py       # IDW interpolation for continuous maps
├── web/
│   ├── app.py               # Flask routes: /, /map, /history, /settings, API
│   └── templates/           # Dashboard, map, history, settings pages
└── outputs/
    ├── predictions.csv      # 15-column log
    ├── farm_live_*.png      # Animated map snapshots
    └── latest_image.jpg     # Latest captured frame

Next Steps

Retrain on real labeled data when we get to a farm. The crop → fertility mapping is approximate; lab-tested samples are the path to production accuracy.
Add EC sensor driver in edge/sensors.py. Currently logged but not modeled (public dataset lacks EC).
Online retraining — weekly fine-tuning on newly labeled readings could improve drift performance.
Anomaly detection — z-score filtering or autoencoder outlier detection before the MLP catches broken-sensor noise.

TL;DR

What we built	How
Sensor model	sklearn MLP on sliding windows of 6 features
Image model	Pure PyTorch CNN (~0.6M params), TorchScript export
Fusion	Weighted softmax average (0.7 sensor + 0.3 image)
Spatial mapping	IDW interpolation → animated PNG heatmaps
Deployment	Raspberry Pi 5, Picamera2, MQTT, Flask dashboard
Fully testable?	Yes — `--simulate --camera-demo` needs zero hardware

The full code is in the project repo. Happy to share links if you want to clone and experiment.

Special thanks to everyone who debugged Python 3.13 compatibility issues and NetworkManager race conditions along the way. The code works; the infrastructure fought back.

Why Use .then() When Async/Await Is Cleaner?

Ikegbo Ogochukwu — Tue, 11 Aug 2026 13:05:27 +0000

series: JavaScript Deep Dives

If you ask any modern JavaScript developer how to handle asynchronous code, they will almost certainly tell you to use async/await. It reads like synchronous code, eliminates callback nesting, and works beautifully with standard try/catch blocks.

So why does .then() still exist? Is it just legacy technical debt, or does it actually have legitimate use cases in 2026?

Let’s look at why .then() is still a vital tool in your JavaScript toolkit.

1. Fire-and-Forget Operations (Non-Blocking Tasks)

Sometimes you want to trigger an asynchronous action in the background, but you don't want to pause your main function while waiting for it to finish.

Imagine a user clicks a button. You need to track an analytics event (async) and immediately redirect them to their dashboard.

The Async/Await Approach:

If you use await, you force the user to wait for the analytics server to respond before they get redirected:

async function handleLogin() {
  // The user is stuck waiting here!
  await trackAnalytics("User Logged In"); 

  navigateToDashboard(); 
}

The .then() Solution:

With .then(), you kick off the analytics call in the background and immediately move the user forward:

function handleLogin() {
  // Fires in the background, non-blocking
  trackAnalytics("User Logged In").then(() => console.log("Logged!")); 

  // Runs instantly!
  navigateToDashboard(); 
}

2. Cleaner Inline Pipelines (Functional Programming)

If you love clean, functional programming pipelines, .then() allows you to chain pure functions together cleanly without declaring temporary variables.

// Quick, readable data pipeline
fetchUserData()
  .then(extractEmail)
  .then(validateDomain)
  .then(sendWelcomeEmail);

To do this with async/await, you have to assign a new variable to every single step, which creates a lot of visual boilerplate:

async function pipeline() {
  const user = await fetchUserData();
  const email = extractEmail(user);
  const isValid = validateDomain(email);
  return sendWelcomeEmail(isValid);
}

3. Quick Top-Level Scripts

While modern environments support "Top-Level Await" in ES modules, you still cannot use await at the root level of older Node.js scripts or legacy CommonJS files without wrapping everything in an Immediately Invoked Function Expression (IIFE).

The Async/Await Wrapper:

(async () => {
  const data = await database.connect();
  console.log(data);
})();

The .then() Alternative:

database.connect().then(console.log);

For a quick script or a scratchpad file, .then() gets the job done with zero boilerplate.

The Verdict: Use the Right Tool

async/await and .then() are not enemies—async/await is literally built on top of promises.

Use async/await for 90% of your code, especially linear workflows, complex API fetches, and heavy error handling.
Use .then() when you need background tasks, quick one-liners, or functional data pipelines.

What’s your preference? Do you still use .then() in your projects, or have you completely migrated to async/await? Let me know in the comments below! 👇

Recovering Wi-Fi Access on a Headless Raspberry Pi with `nmcli`

Ikegbo Ogochukwu — Tue, 11 Aug 2026 10:05:46 +0000

If you manage Raspberry Pis remotely, eventually you'll run into this problem:

The Raspberry Pi needs new Wi-Fi credentials, but there is no keyboard, monitor, or physical access to configure it.

This happened to me while working with a headless Raspberry Pi. The Pi was connected through SSH, and I needed to update its Wi-Fi credentials without accidentally locking myself out.

The solution was NetworkManager + nmcli.

What You'll Need

Raspberry Pi running Raspberry Pi OS with NetworkManager
SSH access to the Pi
Access to the Wi-Fi router/hotspot
The new Wi-Fi password
Another computer on the network for SSH

NetworkManager treats Wi-Fi configurations as connection profiles. These profiles can be inspected, modified, activated, and deactivated using nmcli.

1. Check the NetworkManager status

Start by checking the network devices:

nmcli device status

Example:

DEVICE   TYPE      STATE      CONNECTION
wlan0    wifi      connected  dex
lo       loopback  connected   lo

Here:

wlan0 is the Raspberry Pi's Wi-Fi interface.
dex is the active Wi-Fi connection profile.

2. List saved Wi-Fi profiles

nmcli connection show

Example:

NAME                 UUID                                  TYPE      DEVICE
dex                  140ad8be-fcc2-475c-95af-e0491b93760a  wifi      wlan0
lo                   588680fc-bd8f-4526-9eb1-af8640764a0e  loopback  lo
MTN_4G_320E79        b9b81206-1ec4-4000-8c96-2d69716c1acd  wifi      --
Wired connection 1   13d4485f-0739-3ae3-9c21-6a8fd811361a  ethernet  --

The important part is identifying which profile is currently connected.

In my case:

dex → wlan0

3. Check the current IP address

Before changing anything, record the Raspberry Pi's IP address:

hostname -I

For example:

192.168.0.6

This is important because after reconnecting, the router could assign the Pi a different IP address.

4. Scan for Wi-Fi networks

You can scan for available networks with:

nmcli device wifi list

To force a fresh scan:

sudo nmcli device wifi rescan

Then:

nmcli device wifi list

NetworkManager's nmcli device wifi commands can list available access points and initiate Wi-Fi connections from the command line.

Changing the Wi-Fi Password Remotely

This is the important part.

Suppose the Wi-Fi network is:

SSID: dex
New password: NEW_PASSWORD

Update the password stored in the Raspberry Pi's connection profile:

sudo nmcli connection modify "dex" wifi-sec.psk "NEW_PASSWORD"

The wifi-sec.psk property represents the pre-shared key used for WPA Wi-Fi connections.

Important distinction

This command does not change the router's actual Wi-Fi password.

It changes the password saved in the Raspberry Pi's NetworkManager connection profile.

So the safe sequence is:

Save the new password on the Pi.
Change the actual password on the router/hotspot.
Reconnect the Pi.

5. Enable automatic reconnection

I also recommend making sure the connection is configured to reconnect automatically:

sudo nmcli connection modify "dex" connection.autoconnect yes

This is particularly useful for headless devices because you don't want to manually reconnect the Pi after every reboot.

6. Change the actual router Wi-Fi password

Now change the Wi-Fi password on your router/hotspot.

Use the same password that you stored in the Raspberry Pi:

Router password:
NEW_PASSWORD

Raspberry Pi saved password:
NEW_PASSWORD

This is where the headless setup becomes useful.

You have already prepared the Pi for the new credentials before disconnecting it.

7. Reconnect the Raspberry Pi

After changing the router's password:

sudo nmcli connection down "dex"

Then:

sudo nmcli connection up "dex"

Your SSH session will probably disconnect.

That's expected.

The Pi is temporarily losing its Wi-Fi connection while it reconnects using the new credentials.

NetworkManager supports explicitly activating and deactivating connection profiles with nmcli connection up and nmcli connection down.

8. Wait and reconnect through SSH

Give the Pi around 10–20 seconds to reconnect.

Then try:

ssh pi@192.168.0.6

If DHCP assigned the Pi a different address, you'll need to find the new IP from your router or another device on the network.

Connecting the Pi to a Completely Different Wi-Fi

If you're not changing the password of the existing network but want to connect the Pi to another Wi-Fi network, you can use:

sudo nmcli device wifi connect "WIFI_NAME" password "WIFI_PASSWORD"

For example:

sudo nmcli device wifi connect "MyNewWiFi" password "MyNewPassword"

NetworkManager can create and activate a connection profile when connecting to a new WPA-PSK network.

You can then check the connection:

nmcli device status

And find the new IP:

hostname -I

Useful `nmcli` Commands for Headless Raspberry Pi

Show network devices

nmcli device status

Show detailed Wi-Fi information

nmcli device show wlan0

Show saved connections

nmcli connection show

Show active connections

nmcli connection show --active

Scan Wi-Fi

nmcli device wifi list

Force Wi-Fi scan

sudo nmcli device wifi rescan

Connect to Wi-Fi

sudo nmcli device wifi connect "SSID" password "PASSWORD"

Activate a saved connection

sudo nmcli connection up "CONNECTION_NAME"

Deactivate a connection

sudo nmcli connection down "CONNECTION_NAME"

Change Wi-Fi password

sudo nmcli connection modify "CONNECTION_NAME" wifi-sec.psk "NEW_PASSWORD"

Enable automatic connection

sudo nmcli connection modify "CONNECTION_NAME" connection.autoconnect yes

Find IP address

hostname -I

A Safer Trick for Remote Changes

One particularly useful NetworkManager feature for remote administration is connection checkpoints.

NetworkManager can create a temporary checkpoint before making potentially disruptive network changes. If the change isn't confirmed, the configuration can automatically be restored after the timeout.

For example, NetworkManager supports:

sudo nmcli device checkpoint --timeout 60 -- wlan0

This is useful when you're making network changes over SSH and are worried about locking yourself out.

Final Headless Wi-Fi Workflow

For future Raspberry Pi deployments, my basic workflow is:

# 1. Identify Wi-Fi interface
nmcli device status

# 2. Find active connection
nmcli connection show --active

# 3. Record IP
hostname -I

# 4. Update saved Wi-Fi credentials
sudo nmcli connection modify "dex" wifi-sec.psk "NEW_PASSWORD"

# 5. Enable automatic reconnection
sudo nmcli connection modify "dex" connection.autoconnect yes

# 6. Change the actual router password

# 7. Reconnect Pi
sudo nmcli connection up "dex"

# 8. Check connection
nmcli device status

# 9. Check IP
hostname -I

The main lesson is simple:

When managing a headless Raspberry Pi, configure the new network credentials before breaking the existing connection.

That small precaution can save you from needing a physical keyboard and monitor just to recover Wi-Fi access.

How to Identify Your Raspberry Pi's RAM Size: A Developer's Guide

Ikegbo Ogochukwu — Thu, 23 Jul 2026 13:33:20 +0000

Ever inherited a Raspberry Pi board, bought a used one, or forgot which model you grabbed from your electronics drawer? Since many Pi boards share the exact same physical layout, telling a 2GB, 4GB, or 8GB model apart just by looking at the green PCB can be tricky.

Here are the four best ways to identify your Raspberry Pi’s RAM size, ranging from quick terminal commands to inspecting the hardware components.

1. The Software Way: Terminal Commands (Fastest)

If your Raspberry Pi is powered on and you can access the terminal (via SSH or a desktop window), software commands provide the quickest answer.

Method A: Check /proc/meminfo

The Linux kernel keeps track of system memory in the /proc virtual filesystem. Run this command to see your total memory in kilobytes:

cat /proc/meminfo | grep MemTotal

What to look for:
~940,000 kB = 1GB
- ~1,900,000 kB = 2GB
- ~3,800,000 kB = 4GB
- ~7,800,000 kB = 8GB

Method B: Use the free Command

For a more human-readable format, use the free tool with the -h (human-readable) flag:

free -h

Look under the Total column in the Mem row. It will explicitly display 1.8Gi, 3.7Gi, or 7.6Gi.

2. The Configuration Way: Reading the Revision Code

Every Raspberry Pi has a specific hardware revision code embedded in its processor. This code encodes the model, revision number, manufacturer, and exact RAM size.
Run this command:

cat /proc/cpuinfo | grep Revision

You will get a 4-to-6-digit hexadecimal string (e.g., c03111 or d03114). You can match your code against the official Raspberry Pi documentation, or use this quick cheat sheet for the Raspberry Pi 4 Model B:

b03111 / b03112 / b03114 / b03115 = 2GB RAM
c03111 / c03112 / c03114 / c03115 = 4GB RAM
d03114 / d03115 = 8GB RAM

3. The Visual Way: Reading Silk-Screened PCB Markings

If your Pi is powered off, look directly at the top of the circuit board.

Raspberry Pi 5 and Recent Pi 4 Boards

On newer Raspberry Pi models, the developers made our lives incredibly easy. Look closely at the top-right corner of the board, right next to the headphone jack or micro-HDMI ports. You will see small, silver silk-screened text directly on the board indicating the memory size:

2, 4, or 8 printed explicitly inside a small rectangular border.

Older Pi 4 Boards

Look closely at the board between the USB ports and the 40-pin GPIO header. The text Raspberry Pi 4 Model B is printed there. On some production runs, the RAM size is printed directly after the model name.

4. The Hardware Way: Decoding the RAM Chip FBGA Code

If your board doesn't have the size printed on the PCB, you can read the physical markings on the RAM chip itself. The RAM is the square, dark-metallic integrated circuit (IC) located right next to the main Broadcom CPU.
Raspberry Pi uses memory chips from manufacturers like Micron or Samsung. Micron chips use a 5-digit alphanumeric FBGA code instead of a traditional part number.
You can look up the code on Micron's website, or reference these common Raspberry Pi 4/5 markers:

D9WHV = 2GB LPDDR4
D9WHZ = 4GB LPDDR4
D9ZCL = 8GB LPDDR4X

Summary: Which Method Should You Use?

Pi is running headless? Use free -h.
Writing an automation script? Parse /proc/cpuinfo for the revision code.
Pi is sitting on your desk unplugged? Check the silver silk-screened number on the corner of the PCB.

How do you usually check your Pi hardware specs? Let me know in the comments below!

Understanding ADCs and Using the ADS1115 with Raspberry Pi

Ikegbo Ogochukwu — Tue, 16 Jun 2026 11:35:42 +0000

Understanding ADCs and Using the ADS1115 with Raspberry Pi

Learn how analog signals become digital data, and how to connect the ADS1115 ADC to a Raspberry Pi for high-precision sensor measurements.

Introduction

One of the first surprises many Raspberry Pi users encounter is that the Pi has no built-in Analog-to-Digital Converter (ADC).

This means that while the Raspberry Pi excels at digital communication, it cannot directly read analog sensors such as:

Potentiometers
Light sensors (LDRs)
Gas sensors
Analog temperature sensors
Soil moisture sensors

To bridge this gap, we use an external ADC such as the ADS1115, a high-precision 16-bit ADC that communicates with the Raspberry Pi over I²C. The ADS1115 provides four analog input channels, programmable gain amplification, and up to 860 samples per second. (Texas Instruments)

What is an ADC?

An Analog-to-Digital Converter (ADC) converts a continuously varying analog voltage into a digital number that software can process.

Consider a potentiometer:

Potentiometer
     │
     ▼
  0V ───────► 3.3V

The output voltage changes smoothly as you rotate the knob.

A computer, however, understands only numbers.

The ADC measures the voltage and converts it into a digital value.

Analog Voltage
      │
      ▼
+------------+
|    ADC     |
+------------+
      │
      ▼
Digital Value

The Principle Behind ADCs

ADC conversion involves three major stages.

1. Sampling

The ADC captures the voltage at a specific moment in time.

Voltage

5V |      /\
   |     /  \
   |    /    \
0V +---+------+----> Time
      ↑
   Sample

The sampled voltage is then processed.

2. Quantization

The ADC divides the voltage range into discrete levels.

For example, a 3-bit ADC can represent:

2³ = 8 levels

0V ───────────── 8V
│ │ │ │ │ │ │ │
0 1 2 3 4 5 6 7

Any input voltage is rounded to the nearest level.

3. Encoding

The selected level is represented in binary form.

Example:

Voltage	Level	Binary
5.3V	5	101

The ADC outputs the binary value to the processor.

ADC Resolution Explained

Resolution determines how many unique values an ADC can produce.

Formula:

Levels = 2^N

where N is the number of bits.

Resolution	Levels
8-bit	256
10-bit	1,024
12-bit	4,096
16-bit	65,536

Higher resolution means greater measurement precision.

Why the ADS1115 is Popular

The ADS1115 is a 16-bit delta-sigma ADC featuring:

16-bit resolution
Four analog input channels
I²C communication
Programmable Gain Amplifier (PGA)
Differential measurements
Up to 860 samples/sec
Supply voltage from 2.0V to 5.5V (Texas Instruments)

ADS1115 Module

Why Raspberry Pi Needs the ADS1115

Unlike many microcontrollers, the Raspberry Pi does not include ADC hardware.

Without an ADC:

# This will not work on Raspberry Pi
analogRead(sensor)

With the ADS1115:

Sensor
  │
  ▼
ADS1115
  │
  ▼
I²C Bus
  │
  ▼
Raspberry Pi

The Pi reads digital values from the ADS1115 through I²C. (Adafruit Learning System)

Hardware Connections

Connect the ADS1115 to the Raspberry Pi as follows:

ADS1115	Raspberry Pi
VDD	3.3V
GND	GND
SDA	GPIO2 (SDA)
SCL	GPIO3 (SCL)

Wiring Diagram

Enable I²C on Raspberry Pi

Open Raspberry Pi configuration:

sudo raspi-config

Navigate to:

Interface Options
 └── I2C
     └── Enable

Reboot:

sudo reboot

Verify the ADS1115 is detected:

sudo apt install -y i2c-tools

i2cdetect -y 1

Expected output:

The default I²C address of the ADS1115 is 0x48. (Instructables)

Installing Python Libraries

Install the required packages:

sudo apt update

pip install adafruit-circuitpython-ads1x15

The Adafruit ADS1x15 library provides Python support for both ADS1015 and ADS1115 devices. (CircuitPython Docs)

Reading Analog Voltages

Create a file:

nano ads1115_test.py

Paste:

import board
import busio
import adafruit_ads1x15.ads1115 as ADS

from adafruit_ads1x15.analog_in import AnalogIn

i2c = busio.I2C(board.SCL, board.SDA)

ads = ADS.ADS1115(i2c)

chan = AnalogIn(ads, ADS.P0)

while True:
    print(f"Voltage: {chan.voltage:.3f}V")

Run:

python ads1115_test.py

Example output:

Voltage: 1.245V
Voltage: 1.251V
Voltage: 1.260V

Reading a Potentiometer

Connect:

3.3V ─────┐
          │
      Potentiometer
          │
A0 ◄──────┘
          │
GND ──────┘

Code:

from adafruit_ads1x15.analog_in import AnalogIn

pot = AnalogIn(ads, ADS.P0)

while True:
    print(pot.value)

You should see values changing as the knob rotates.

Measuring Multiple Sensors

The ADS1115 provides four channels:

A0
A1
A2
A3

Example:

ch0 = AnalogIn(ads, ADS.P0)
ch1 = AnalogIn(ads, ADS.P1)

print(ch0.voltage)
print(ch1.voltage)

This allows one Raspberry Pi to monitor multiple analog sensors simultaneously.

Differential Measurements

The ADS1115 can measure the difference between two voltages.

Example:

diff = AnalogIn(ads, ADS.P0, ADS.P1)

print(diff.voltage)

Useful for:

Current sensing
Wheatstone bridges
Precision instrumentation

The ADS1115 supports both single-ended and differential input configurations. (Adafruit)

Understanding the Programmable Gain Amplifier (PGA)

One of the most powerful ADS1115 features is its built-in PGA.

Suppose your sensor outputs:

0V - 0.2V

Using the PGA:

ads.gain = 16

The signal is amplified internally, allowing much higher measurement precision. (Adafruit Learning System)

Real-World Applications

The ADS1115 is commonly used in:

Smart agriculture
Environmental monitoring
Battery management systems
Industrial automation
Embedded AI projects
Raspberry Pi sensor networks

Example workflow:

Temperature Sensor
       │
       ▼
    ADS1115
       │
       ▼
 Raspberry Pi
       │
       ▼
 Machine Learning Model
       │
       ▼
 Prediction

Common Troubleshooting

Device Not Found

Check wiring:

i2cdetect -y 1

If 0x48 is missing:

Verify SDA connection
Verify SCL connection
Verify power supply

Permission Errors

Add your user to the required groups:

sudo usermod -aG gpio,i2c $USER

Logout and login again.

Incorrect Voltage Readings

Verify:

Sensor voltage range
ADS1115 gain setting
Ground connections

Final Thoughts

The ADS1115 is one of the most useful expansion modules for Raspberry Pi projects. It solves the Pi's lack of analog inputs while providing significantly higher precision than many built-in microcontroller ADCs.

By understanding how ADCs work—through sampling, quantization, and encoding—you gain a deeper appreciation of how physical sensor data becomes digital information that software, machine learning models, and intelligent systems can use.

If you're building IoT devices, sensor networks, robotics systems, or Embedded AI projects, the ADS1115 is an excellent addition to your toolkit.

References

Happy building! 🚀

How to Fix SSH Error: "REMOTE HOST IDENTIFICATION HAS CHANGED!"

Ikegbo Ogochukwu — Tue, 02 Jun 2026 10:55:55 +0000

A quick, step-by-step guide to resolving the dreaded SSH host key verification failure when connecting to your Raspberry Pi or remote server.

We have all been there. You flash a fresh OS onto your Raspberry Pi, try to SSH back into it using the same hostname, and boom—your terminal screens at you with a massive wall of warning text:

@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
...
Host key verification failed.

Why is this happening?

Your computer keeps a local registry of unique security keys (fingerprints) for every server you connect to inside a file named known_hosts.

When you reinstall an OS or change your remote device, its security key changes. Your computer notices that the new key doesn't match the old saved key, panics, and blocks the connection to protect you from a potential Man-in-the-Middle (MITM) attack.

Since you know you caused this change, it is safe to bypass. Here are the two quickest ways to fix it on Windows.

Solution 1: The One-Line Terminal Fix (Recommended) 🚀

The fastest approach is to let the system automatically remove the old, conflicting key. Open your Command Prompt or PowerShell and run:

ssh-keygen -R raspberrypi.local

(Replace raspberrypi.local with your target IP address if you are connecting via IP).

What this does: It searches your local known_hosts file, strips out the outdated entry, and saves a backup of your old file just in case.

Solution 2: Manual Line Surgery 🛠️

If the automated command fails or you prefer to see exactly what you are deleting, you can edit the file directly using Notepad.

Press Win + R to open the Run window.
Paste the following path and click OK:

   notepad C:\Users\PAVILION\.ssh\known_hosts

Look at your original error message. It will tell you exactly which line is broken (e.g., offending ECDSA key in ...known_hosts:6).
Go to Line 6 in Notepad, delete that entire line, delete any blank spaces, and save (Ctrl + S).

Connecting Again

Once the old key is cleared out, try connecting to your Raspberry Pi again:

ssh pi@raspberrypi.local

Your terminal will now ask if you want to trust the new fingerprint. Type yes, press Enter, and you are officially back in business!

Found this helpful? Drop a unicorn 🦄 or bookmark it for the next time you rebuild your homelab!

Stop Guessing Your Network: Using PowerShell and TCP Commands to Understand What’s Happening Behind the Scenes

Ikegbo Ogochukwu — Tue, 19 May 2026 18:47:05 +0000

Most developers and IT beginners only touch networking when something breaks.

The internet is “working,” the API is responding, Docker containers are starting, and life moves on.

Until one day:

Your app cannot connect to a database
Docker says the daemon is unreachable
A server responds slowly for no obvious reason
A device disappears from the network
SSH refuses connections
Your Raspberry Pi suddenly becomes invisible

That is usually when people realize they do not actually understand their network.

One of the best ways to fix that is by learning how to inspect and troubleshoot networks directly from the terminal using PowerShell and TCP-based tools.

This post is inspired by a networking article from Paessler Blog and expands it into a more developer-focused practical guide. (blog.paessler.com)

Why PowerShell Matters for Networking

For years, networking on Windows relied heavily on old tools like:

ping
ipconfig
netstat
tracert
netsh

These still work.

But modern Windows networking is increasingly PowerShell-driven. Microsoft has gradually shifted many administration and diagnostic workflows toward PowerShell because it is:

scriptable
automatable
object-oriented
easier to integrate into larger workflows

Instead of parsing messy text output, PowerShell returns structured objects you can filter, sort, and automate. (blog.paessler.com)

Understanding TCP Before Troubleshooting

Most developer tools rely on TCP underneath:

Docker
APIs
databases
SSH
web servers
cloud platforms

TCP (Transmission Control Protocol) is responsible for:

reliable communication
packet ordering
retransmission
connection establishment

When applications fail to communicate, the problem is often not the application itself — it is the TCP/network layer.

Understanding a few networking commands can save hours of frustration.

1. Check Your Network Configuration

The first thing to inspect is your machine’s network configuration.

Get-NetIPAddress

This gives you:

IP address
subnet
interface
IPv4/IPv6 details

You can also use:

ipconfig

But PowerShell gives more structured information.

2. Test Connectivity Properly

Most people know ping.

PowerShell modernizes it with:

Test-Connection google.com

You can test multiple systems:

Test-Connection google.com, github.com

Or continuously monitor latency:

Test-Connection 192.168.1.1 -Count 10

This helps detect:

unstable Wi-Fi
packet loss
intermittent routing issues

Microsoft’s networking documentation also recommends PowerShell-based connectivity testing for modern administration workflows. (Microsoft Learn)

3. Discover Devices on Your Network

One of the most useful troubleshooting techniques is identifying what devices are actually online.

You can inspect your ARP table:

arp -a

This maps:

IP addresses
MAC addresses

to devices your machine has communicated with recently.

Modern network discovery guides still rely heavily on ARP-based discovery for local troubleshooting. (blog.paessler.com)

4. Scan an Entire Subnet

Suppose your Raspberry Pi disappeared from the network.

You can sweep your subnet:

1..254 | ForEach-Object {
    Test-Connection "192.168.1.$_" -Count 1 -Quiet
}

This checks which devices respond.

Microsoft demonstrates similar subnet enumeration approaches in PowerShell networking examples. (Microsoft Learn)

5. Find Open TCP Ports

Sometimes the device is online, but the service is not.

For example:

SSH may not be running
Docker daemon may be down
database service may have crashed

You can test ports directly:

Test-NetConnection 192.168.1.10 -Port 22

Example ports:

Service	Port
SSH	22
HTTP	80
HTTPS	443
MySQL	3306
PostgreSQL	5432
Docker API	2375/2376

This immediately tells you whether the issue is:

routing
firewall
service availability
TCP-level rejection

6. Monitor Active TCP Connections

To inspect live connections:

Get-NetTCPConnection

You can filter by state:

Get-NetTCPConnection | Where-Object {$_.State -eq "Established"}

Or inspect a specific port:

Get-NetTCPConnection -LocalPort 80

This is extremely useful when debugging:

APIs
containers
backend services
reverse proxies

7. Troubleshoot Docker Connectivity

If Docker suddenly breaks on Windows, PowerShell networking commands become incredibly useful.

For example, errors like:

failed to connect to the docker API

often indicate:

Docker daemon stopped
named pipe failure
TCP bridge issue
virtualization problem

Useful checks:

Get-Service *docker*

Test-NetConnection localhost -Port 2375

docker context ls

Understanding networking basics makes Docker troubleshooting much easier because Docker heavily relies on virtual networking and TCP communication internally.

8. Automate Network Diagnostics

This is where PowerShell becomes powerful.

Instead of manually checking systems one by one, you can automate diagnostics.

Example:

$servers = @(
    "192.168.1.10",
    "192.168.1.11",
    "192.168.1.12"
)

foreach ($server in $servers) {
    Test-NetConnection $server -Port 22
}

Now you can verify SSH availability across multiple systems automatically.

This scales extremely well for:

labs
classrooms
hubs
server farms
IoT deployments

9. Network Monitoring at Scale

At some point, command-line troubleshooting is not enough.

That is where monitoring systems come in.

Platforms like PRTG Network Monitor automate:

network discovery
latency tracking
device monitoring
traffic inspection
uptime monitoring

Modern network visibility systems combine:

ARP discovery
TCP monitoring
SNMP
device inventories
automated alerting

to give administrators full infrastructure visibility. (blog.paessler.com)

Real Lesson: Developers Need Networking Skills

One pattern keeps repeating in modern software engineering:

The deeper you go, the more networking matters.

Machine learning engineers, backend developers, DevOps engineers, cybersecurity analysts, embedded engineers, and cloud architects all eventually run into:

ports
sockets
firewalls
routing
DNS
TCP failures

Networking knowledge is no longer optional.

Final Thoughts

Learning PowerShell networking commands is not about becoming a network engineer overnight.

It is about gaining visibility.

Once you can inspect:

connections
devices
ports
adapters
latency
routing

you stop guessing and start diagnosing systems properly.

And honestly, that is one of the biggest transitions from beginner developer to advanced engineer.

From Zero to Supercomputing: A Beginner-Friendly Guide to Using HPC Clusters Like CINECA

Ikegbo Ogochukwu — Thu, 14 May 2026 11:05:39 +0000

A practical introduction to Linux, SLURM, GPU clusters, AI workloads, and supercomputing workflows.

Supercomputers are no longer reserved only for physicists and national laboratories.

Today, AI engineers, machine learning researchers, data scientists, and students increasingly rely on High Performance Computing (HPC) systems for:

large-scale AI training
scientific simulations
big data analytics
distributed computing
computational research

Recently, I started exploring the documentation of the CINECA HPC infrastructure, one of Europe’s major supercomputing environments, and I realized something important:

Most beginners struggle not because HPC is impossible, but because the ecosystem feels overwhelming at first.

This article breaks down the core concepts into a practical workflow that beginners can actually understand.

What Is an HPC Cluster?

An HPC (High Performance Computing) cluster is a network of powerful computers called nodes working together to solve computational problems.

Instead of training a model on:

one laptop CPU
one small GPU

you may gain access to:

hundreds of CPU cores
multiple A100/H100 GPUs
terabytes of memory
ultra-fast networking
distributed storage systems

Systems like those hosted at CINECA are used for:

AI training
weather forecasting
genomics
computational physics
climate simulations
deep learning research

Understanding the Architecture

Most HPC systems follow this structure:

Your Laptop
     ↓
Login Node
     ↓
SLURM Scheduler
     ↓
Compute Nodes
     ↓
GPU/CPU Execution

Let’s simplify what each layer means.

Component	Purpose
Login Node	Used for coding, editing, compiling
Compute Node	Where actual jobs run
GPU Node	Used for AI and deep learning
Scheduler	Manages resources and queues
Storage System	Stores datasets and outputs

One important rule:

Never run heavy workloads directly on login nodes.

The Biggest Mindset Shift in HPC

On a laptop, you usually do this:

Write code → Run immediately → See output

In HPC, the workflow becomes:

Write code
↓
Submit job
↓
Wait in queue
↓
Resources allocated
↓
Execution starts
↓
Logs/results generated

HPC is asynchronous.

That is one of the biggest transitions beginners must adapt to.

Connecting to the Cluster

Most HPC systems are accessed using SSH.

Example:

ssh username@login.clustername.cineca.it

Modern systems may also require:

2FA
SSH certificates
OTP authentication

Linux Skills You MUST Know

Before touching supercomputers seriously, Linux fundamentals are essential.

Navigation Commands

pwd
ls
cd
mkdir
rm
cp
mv

File Inspection

cat
less
head
tail
nano
vim

Process Monitoring

top
htop
ps
kill

If you are weak in Linux, HPC will feel painful very quickly.

Understanding Modules

HPC environments rarely allow random software installations directly on the system.

Instead, they use modules.

Modules dynamically load:

Python versions
CUDA versions
compilers
MPI libraries
AI frameworks

Checking Available Modules

module avail

Loading Python

module load python

Viewing Loaded Modules

module list

Clearing Modules

module purge

This prevents dependency conflicts between projects.

Understanding SLURM

Most HPC systems use a scheduler called SLURM.

SLURM manages:

job queues
GPU allocation
runtime limits
cluster resources

You do not directly “take” GPUs.

You request resources from SLURM.

Essential SLURM Commands

View Available Partitions

sinfo

View Running Jobs

squeue

Submit a Job

sbatch train.sh

Start Interactive Session

srun --pty bash

Cancel a Job

scancel JOB_ID

Your First SLURM Script

Create a file:

nano train.sbatch

Example content:

#!/bin/bash
#SBATCH --job-name=my_training
#SBATCH --partition=gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --gres=gpu:1
#SBATCH --time=04:00:00
#SBATCH --mem=32G
#SBATCH --output=output.log

module purge
module load cuda
module load python

python train.py

Submit it:

sbatch train.sbatch

SLURM responds with something like:

Submitted batch job 12345

Understanding SBATCH Parameters

Parameter	Meaning
`--job-name`	Name of the job
`--partition`	Queue name
`--nodes`	Number of machines
`--cpus-per-task`	CPU cores
`--gres=gpu:1`	Request GPU
`--time`	Runtime limit
`--mem`	RAM allocation

Monitoring Jobs

Check Queue

squeue -u username

Live Monitoring

watch squeue -u username

View Job Details

scontrol show job 12345

Understanding Job States

State	Meaning
PD	Pending
R	Running
CG	Completing
CD	Completed
F	Failed

If your job stays in PD, it usually means:

resources are busy
queue is full
requested resources are too large

Interactive GPU Sessions

Interactive sessions are useful for:

debugging
notebook testing
experimentation

Example:

srun --partition=gpu \
     --gres=gpu:1 \
     --cpus-per-task=8 \
     --mem=32G \
     --pty bash

Python Environments on HPC

Never rely entirely on system Python for serious AI work.

Most researchers use:

Conda
virtual environments

Create Environment

conda create -n ml python=3.11

Activate:

conda activate ml

Install packages:

pip install torch transformers datasets

GPU Training Workflow

A common AI workflow looks like this:

Local Machine
    ↓
Upload Dataset
    ↓
Prepare Environment
    ↓
Write SLURM Script
    ↓
Submit Training
    ↓
Monitor Logs
    ↓
Download Results

Storage Systems Matter More Than Beginners Think

HPC systems typically have:

home storage
scratch storage
project storage
high-speed temporary storage

A common beginner mistake is training directly from slow home directories.

For large AI workloads:

use scratch storage
optimize data loading
clean temporary files regularly

Transferring Files

SCP Example

scp dataset.zip username@cluster:/scratch/project/

RSYNC Example

rsync -av dataset/ username@cluster:/scratch/project/

Running PyTorch on HPC

Simple GPU check:

import torch

print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

SLURM script:

#SBATCH --gres=gpu:1

python train.py

Multi-GPU Training

Example:

#SBATCH --nodes=1
#SBATCH --gres=gpu:4

PyTorch distributed execution:

torchrun --nproc_per_node=4 train.py

This is where HPC becomes significantly more powerful than normal laptops.

MPI and Distributed Computing

Scientific applications often use MPI.

Example:

module load openmpi

mpirun -np 16 ./simulation

MPI is heavily used in:

physics
computational fluid dynamics
simulations
weather forecasting

Containers in HPC

Unlike cloud-native environments that heavily use Docker, HPC systems often use:

Singularity
Apptainer

Example:

module load singularity

Run container:

singularity exec container.sif python train.py

Common Beginner Mistakes

Running Heavy Jobs on Login Nodes

This annoys system administrators very quickly.

Requesting Too Many Resources

Large requests stay longer in queue.

Ignoring Logs

Logs explain most failures.

Example:

tail -f output.log

CUDA Version Mismatches

Your PyTorch CUDA version must match cluster CUDA support.

HPC vs Cloud GPUs

HPC	Cloud
Shared infrastructure	Commercial infrastructure
Often research-funded	Pay-as-you-go
Queue-based	Immediate provisioning
Strong interconnects	Flexible scaling
Excellent for huge workloads	Excellent for startups

Recommended Learning Path

Stage 1 — Linux

Learn:

bash
file systems
SSH
permissions

Stage 2 — SLURM

Learn:

job submission
monitoring
partitions
scheduling

Stage 3 — Python Environments

Learn:

Conda
CUDA
pip
virtual environments

Stage 4 — GPU Computing

Learn:

PyTorch
distributed training
checkpointing

Stage 5 — Advanced HPC

Learn:

MPI
NCCL
DeepSpeed
multi-node training

Practice Projects for Beginners

Beginner

Submit hello-world SLURM job
Train MNIST on GPU
Monitor job states

Intermediate

Multi-GPU image classifier
Jupyter on HPC
Distributed preprocessing pipeline

Advanced

DeepSpeed training
MPI simulations
Large language model fine-tuning

Final Thoughts

The people who stand out in HPC environments are usually not just the best programmers.

They are the people who understand:

systems
optimization
storage bottlenecks
resource management
debugging workflows
automation

Supercomputing is less about “running code fast” and more about learning how to think computationally at scale.

If you are entering AI, scientific computing, or large-scale machine learning research, learning HPC may become one of the most valuable technical skills you acquire.

Useful Resources

If you are already working with supercomputers or HPC clusters, what was the hardest concept for you when you first started?

Docker Cheat Sheet: Commands Every Developer Should Know

Ikegbo Ogochukwu — Tue, 12 May 2026 18:57:12 +0000

Introduction

Docker helps you package an application with everything it needs to run: code, dependencies, environment variables, and runtime settings. This cheat sheet covers the most useful Docker commands for daily development.

1. Check Docker Installation

docker --version
docker info
docker help

2. Docker Images

List images

docker images

Pull an image

docker pull nginx
docker pull python:3.12
docker pull node:20

Remove an image

docker rmi image_name
docker rmi image_id

Build an image from a Dockerfile

docker build -t my-app .

Build with a specific Dockerfile

docker build -f Dockerfile.dev -t my-app-dev .

3. Docker Containers

Run a container

docker run nginx

Run container in detached mode

docker run -d nginx

Run container with a name

docker run --name my-nginx nginx

Run container and map ports

docker run -p 8080:80 nginx

This maps port 8080 on your computer to port 80 inside the container.

Run container with environment variables

docker run -e APP_ENV=development my-app

Run container interactively

docker run -it ubuntu bash

4. List Containers

Running containers

docker ps

All containers

docker ps -a

5. Stop, Start, Restart Containers

docker stop container_name
docker start container_name
docker restart container_name

6. Remove Containers

Remove one container

docker rm container_name

Remove all stopped containers

docker container prune

7. Logs and Debugging

View logs

docker logs container_name

Follow logs live

docker logs -f container_name

Enter a running container

docker exec -it container_name bash

If bash is not available:

docker exec -it container_name sh

Inspect container details

docker inspect container_name

8. Volumes

Volumes help you persist data outside the container.

Create a volume

docker volume create my-volume

List volumes

docker volume ls

Use a volume

docker run -v my-volume:/app/data my-app

Remove a volume

docker volume rm my-volume

Remove unused volumes

docker volume prune

9. Bind Mounts

Bind mounts connect a folder on your computer to a folder inside the container.

docker run -v $(pwd):/app my-app

On Windows PowerShell:

docker run -v ${PWD}:/app my-app

10. Networks

List networks

docker network ls

Create a network

docker network create my-network

Run container on a network

docker run --network my-network --name app my-app

Remove a network

docker network rm my-network

11. Dockerfile Example

FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "app.py"]

12. Docker Compose

Docker Compose helps you run multiple containers together.

Example `docker-compose.yml`

services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - APP_ENV=development
    volumes:
      - .:/app

  database:
    image: postgres:16
    environment:
      - POSTGRES_USER=admin
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=mydb
    ports:
      - "5432:5432"

Start services

docker compose up

Start in detached mode

docker compose up -d

Stop services

docker compose down

Rebuild services

docker compose up --build

View logs

docker compose logs
docker compose logs -f

13. Cleaning Up Docker

Remove unused data

docker system prune

Remove unused data including images

docker system prune -a

Remove unused containers

docker container prune

Remove unused images

docker image prune

Remove unused volumes

docker volume prune

Be careful with prune commands because they delete unused Docker resources.

14. Common Docker Commands Summary

docker build -t my-app .
docker run -p 8000:8000 my-app
docker ps
docker ps -a
docker stop container_name
docker start container_name
docker restart container_name
docker rm container_name
docker rmi image_name
docker logs -f container_name
docker exec -it container_name bash
docker system prune

15. Useful Docker Compose Commands Summary

docker compose up
docker compose up -d
docker compose down
docker compose up --build
docker compose logs -f
docker compose ps
docker compose exec app bash

Final Note

Docker is powerful because it makes your application easier to run, share, test, and deploy. Once you understand images, containers, volumes, networks, and Docker Compose, you can package almost any application into a reproducible environment.

Implementing Facebook Login in Flutter with Meta and Firebase: The Configuration Guide Most Teams Actually Need

Ikegbo Ogochukwu — Mon, 11 May 2026 22:33:07 +0000

Subtitle

How to set up Meta for Developers, Business ownership, Firebase Authentication, and native mobile config without mixing up App Domains, key hashes, and redirect URIs

Introduction

Facebook Login looks simple from the Flutter side. In code, it can be as small as calling FacebookAuth.instance.login(), converting the token to a Firebase credential, and signing the user in.

The real complexity is not in the Dart code. It is in the configuration spread across four systems:

Meta for Developers
Meta Business ownership and app access
Firebase Authentication
Native Android and iOS app configuration

If one of those layers is misconfigured, the failure usually shows up as a vague login cancellation, invalid OAuth redirect, key-hash error, or a token exchange failure. That is why treating Facebook Login as a console-configuration workflow, not only a code task, saves time.

This guide explains the full setup path using abstract examples instead of production identifiers.

1. Understand the flow before configuring anything

In a Firebase-backed Flutter app, the Facebook login flow usually works like this:

The app launches the Facebook login flow using the native Facebook SDK through a Flutter plugin.
Facebook returns an access token to the app.
The app converts that Facebook token into a Firebase credential.
Firebase signs the user in and issues a Firebase ID token.
Your backend can then verify the Firebase token and create or update the app-specific user session.

That means Meta is not replacing Firebase. Meta is the identity provider, Firebase is the authentication broker, and your backend remains the application session authority if your product uses its own access and refresh tokens.

2. Start with a real Meta developer account

Before you can create a Facebook app, you need to register as a Meta developer.

Meta's developer registration flow requires:

a Facebook account
agreement to Meta's platform terms and policies
verification of your account contact details

Meta's documentation states that developer verification is based on confirming the phone number and email address you provide for developer notifications. In practice, the exact verification flow can vary depending on the account and region.

The practical takeaway is simple:

do not build the app under a throwaway personal Facebook account
use an account your organization can retain access to
enable two-factor authentication

Useful references:

3. Use a Business-owned app, not a personal orphan app

This is the part many teams skip until they run into access problems.

Even if a single developer creates the app initially, the long-term owner should be the business, not one person's personal account. A proper Meta Business portfolio helps with:

shared ownership
teammate access
future app review or verification requests
preserving control if a developer leaves

For a simple Facebook Login integration that only requests minimal data, business verification may not be the first blocker. But for production ownership, review, and future scaling, organizing the app under the correct business from the beginning is still the better decision.

Keep this distinction clear:

developer account: the person who can access Meta for Developers
business portfolio: the organization that should own the app and related assets

4. Meta app setup has three different configuration buckets

This is where the confusion usually starts. Developers often mix up values that belong in completely different places.

Basic Settings

This area is about the identity of your Meta app.

Typical values here include:

app name
app contact email
privacy policy URL
app domains

The important trap: App Domains is not the same thing as Firebase's OAuth redirect URI.

App Domains should represent the real public domain associated with your app or website. In practice, this is the host that serves your public web presence or policy pages.

Example:

exampleapp.com
auth.exampleapp.com

Do not put these in App Domains:

https://sample-project.firebaseapp.com/__/auth/handler
any URL with https://
callback paths
localhost
Android package names

That guidance aligns with how Meta uses the field. OAuth redirect URIs belong elsewhere.

Facebook Login product settings

This is where you configure login-specific callback handling.

If you use Firebase Authentication with Facebook as a provider, Firebase requires the OAuth redirect URI from Firebase Console to be added to your Facebook app.

Example redirect URI:

https://sample-project.firebaseapp.com/__/auth/handler

This belongs in:

Facebook Login
Settings
Valid OAuth Redirect URIs

Reference:

Firebase Federated Authentication Docs

Platform settings

Meta also needs to know which native apps are allowed to use the Meta app.

For Android, Meta requires:

package name
default activity class
development and release key hashes

For iOS, Meta requires:

bundle identifier registration

These are platform identity values, not OAuth redirect values.

References:

5. Firebase sits in the middle of the sign-in flow

Firebase's Flutter authentication documentation describes the Facebook setup in a very direct way:

create a Facebook Developer App
enable Facebook provider in Firebase Console
add the Facebook App ID and App Secret
use a native Facebook SDK path on Android and iOS
authenticate using FacebookAuthProvider.credential(...)

Firebase also highlights two important details:

the Facebook provider must be enabled in Firebase Console
the Firebase OAuth redirect URI must be added to the Facebook app

That is why setup order matters. If Meta is configured but Firebase is not, the native token may be returned while Firebase authentication still fails.

Reference:

Firebase Auth for Flutter

6. Native mobile config still matters in a Flutter project

Flutter does not remove the need for native Facebook settings.

Meta's Android setup requires:

facebook_app_id
facebook_client_token
fb_login_protocol_scheme
manifest metadata
Facebook activities
Custom Tab configuration
INTERNET permission
package/class association
key hashes

Meta's iOS setup requires:

CFBundleURLSchemes
FacebookAppID
FacebookClientToken
FacebookDisplayName
LSApplicationQueriesSchemes
bundle ID registration

Even in Flutter, Facebook Login still relies on native Android and iOS configuration under the hood.

7. What a properly configured project usually contains

In a typical Flutter + Firebase + Facebook Login project, you will usually have:

flutter_facebook_auth
a login flow calling FacebookAuth.instance.login()
Firebase credential conversion
Android package identifiers
iOS bundle identifiers
native Android metadata
iOS Info.plist Facebook entries
Firebase Authentication enabled
a configured Firebase auth domain

At that stage, the remaining work is often:

aligning Meta console settings with native identifiers
adding Android debug and release key hashes
enabling Facebook provider in Firebase
confirming the correct ownership and admin structure

8. Business portfolio is operational hygiene, not bureaucracy

If you are building a real product, business ownership matters for reasons beyond compliance.

Without proper business ownership, you can run into:

one developer privately owning the Meta app
broken access when people leave the team
confusion over who can submit apps for review
delays when Meta later requests verification

For a small team, the disciplined approach is:

create or select the correct business portfolio
make the business the long-term owner
assign appropriate admin and developer roles
keep business documentation ready if verification is requested

9. Testing should happen in stages

A reliable testing sequence looks like this:

Confirm Facebook provider is enabled in Firebase.
Confirm Android and iOS platform values are correct in Meta.
Add Android debug key hash and test debug builds.
Add Android release key hash and test release builds.
Test iOS on a real device if shipping on iOS.
Confirm Firebase user creation succeeds.
Confirm backend session creation succeeds.
Test logout and account deletion flows.

If you only test debug Android builds, you can still ship a broken production login flow.

10. Common mistakes to avoid

putting the Firebase redirect URI into App Domains
forgetting Android release key hashes
enabling Facebook Login in Meta but not in Firebase
exposing the Facebook App Secret in Flutter code
registering the app under the wrong personal account
assuming Flutter removes native setup requirements
testing only in development mode

Final takeaway

Facebook Login in Flutter is not mainly a Dart problem. It is a configuration and ownership problem.

The teams that get it right usually do four things well:

they create the Meta app under a durable owner
they align Meta settings, Firebase settings, and native mobile settings
they understand the difference between App Domains and OAuth redirect URIs
they test both debug and release login paths

Once those pieces are aligned, the Flutter implementation becomes the easy part.

DEV Community: Ikegbo Ogochukwu

How to Convert Bash Kaggle Commands to PowerShell (Without Breaking Your Setup)

How to Convert Bash Kaggle Commands to PowerShell (Without Breaking Your Setup)

Windows handles file paths, environment variables, and file permissions completely differently than Linux or macOS. If you need to translate that exact Bash one-liner into clean, native PowerShell, here is how you do it step-by-step.

The PowerShell Equivalent

1. Create the directory safely (acts like mkdir -p)

2. Write the token to the file (acts like echo >)

3. Restrict permissions exclusively to your user (acts like chmod 600)

🔍 Breaking Down the Differences## 1. File Paths (~ vs $HOME)

2. Creating Folders (mkdir -p vs New-Item -Force)

3. Writing Files (echo > vs Set-Content)

4. Permissions (chmod 600 vs Windows ACL)

💡 Pro-Tip: Exporting the Config Directory

For the current session only:

To make it permanent across all future sessions:

Note: If you run the permanent command, make sure to restart your PowerShell window for it to take effect!

Wrap Up

Happy coding! 🚀

How to Set Up n8n Locally with Docker Desktop:

1. Check System Requirements and Enable Virtualization

Check on Windows:

I Built a Soil Fertility AI Pipeline That Runs on a Raspberry Pi 5 — Here's How

Introduction

Architecture

Why Pure PyTorch (Not TensorFlow or ONNX)

Training Results

SoilCNN Architecture

Metrics

What You Can Actually Test Right Now

Deploying to the Raspberry Pi 5

Blocker 1: No PyTorch wheels for Python 3.13 on ARM

Blocker 2: scikit-image won't compile on Python 3.13 + GCC 14.2.0

Blocker 3: NetworkManager profile secret never persisted to disk

File Structure

Next Steps

TL;DR

Why Use .then() When Async/Await Is Cleaner?

1. Fire-and-Forget Operations (Non-Blocking Tasks)

The Async/Await Approach:

The .then() Solution:

2. Cleaner Inline Pipelines (Functional Programming)

3. Quick Top-Level Scripts

The Async/Await Wrapper:

The .then() Alternative:

The Verdict: Use the Right Tool

Recovering Wi-Fi Access on a Headless Raspberry Pi with `nmcli`

What You'll Need

1. Check the NetworkManager status

2. List saved Wi-Fi profiles

3. Check the current IP address

4. Scan for Wi-Fi networks

Changing the Wi-Fi Password Remotely

Important distinction

5. Enable automatic reconnection

6. Change the actual router Wi-Fi password

7. Reconnect the Raspberry Pi

8. Wait and reconnect through SSH

Connecting the Pi to a Completely Different Wi-Fi

Useful nmcli Commands for Headless Raspberry Pi

Show network devices

Show detailed Wi-Fi information

Show saved connections

Show active connections

Scan Wi-Fi

Force Wi-Fi scan

Connect to Wi-Fi

Activate a saved connection

Deactivate a connection

Change Wi-Fi password

Enable automatic connection

Find IP address

A Safer Trick for Remote Changes

Final Headless Wi-Fi Workflow

How to Identify Your Raspberry Pi's RAM Size: A Developer's Guide

Here are the four best ways to identify your Raspberry Pi’s RAM size, ranging from quick terminal commands to inspecting the hardware components.

1. The Software Way: Terminal Commands (Fastest)

Method A: Check /proc/meminfo

Method B: Use the free Command

Look under the Total column in the Mem row. It will explicitly display 1.8Gi, 3.7Gi, or 7.6Gi.

2. The Configuration Way: Reading the Revision Code

Useful `nmcli` Commands for Headless Raspberry Pi