DEV Community: Ikegbo Ogochukwu

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.

Sources

How to Change Wi-Fi Details on a Headless Raspberry Pi When You Don’t Know the Current Network

Ikegbo Ogochukwu — Fri, 08 May 2026 12:05:34 +0000

If you’ve ever worked with a headless Raspberry Pi, you’ve probably faced this problem:

The Raspberry Pi was previously connected to a Wi-Fi network
You do not know which network it is connected to
You cannot connect a monitor, keyboard, or mouse
SSH is your only option
The Pi is no longer appearing on your current network

This usually happens when:

You move to a new location
Your Wi-Fi name/password changes
Someone else configured the Pi
You forgot the old network credentials

In this guide, I’ll show you how to:

Diagnose the problem
Reconfigure Wi-Fi without a monitor
Force the Pi onto a new network
Recover SSH access

The methods below work for:

Raspberry Pi 3
Raspberry Pi 4
Raspberry Pi 5
Raspberry Pi Zero W/2W

Understanding the Problem

A Raspberry Pi configured for headless access boots and automatically tries to connect to the Wi-Fi credentials saved inside:

wpa_supplicant.conf

If:

the saved Wi-Fi no longer exists
the password changed
or the Pi is too far from the router

then the Pi never joins the network.

Since SSH depends on network access, you lose remote control completely.

Method 1 — Edit Wi-Fi Credentials Directly from the SD Card (Best Method)

This is the fastest recovery method.

Step 1 — Remove the SD Card

Power off the Raspberry Pi safely.

Remove the microSD card and insert it into your computer using:

SD card reader
USB adapter
laptop SD slot

Step 2 — Open the Boot Partition

After inserting the SD card, you’ll see a small partition called:

boot
bootfs

Open it.

This partition is readable on:

Windows
Linux
macOS

Step 3 — Create or Edit `wpa_supplicant.conf`

Inside the boot partition, create a file named:

wpa_supplicant.conf

If it already exists, edit it.

Paste this:

country=NG
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="YOUR_WIFI_NAME"
    psk="YOUR_WIFI_PASSWORD"
}

Example:

country=NG
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="MTN_Home"
    psk="mysecurepassword"
}

Why `country=NG` Matters

A lot of people ignore this.

The country code controls:

Wi-Fi regulatory channels
allowed radio frequencies
transmission compliance

If your country code is wrong:

Wi-Fi may fail silently
some channels become inaccessible

For Nigeria, use:

country=NG

Not:

US

unless you are actually in the US.

Do You Need to Remove Old Wi-Fi Networks?

Usually, no.

The Raspberry Pi can store multiple Wi-Fi networks and automatically connect to whichever known network is available.

For example:

network={
    ssid="Old_Wifi"
    psk="oldpassword"
}

network={
    ssid="New_Wifi"
    psk="newpassword"
}

If Old_Wifi is unavailable, the Pi will try New_Wifi.

When Should You Remove Old Networks?

You may want to remove old saved networks if:

The Pi keeps reconnecting to the wrong network
Multiple nearby networks are available
The old Wi-Fi has poor internet access
You want cleaner configuration management
You are deploying the Pi to a new environment permanently

In that case, simply delete the old network={} block from:

wpa_supplicant.conf

and leave only the new network.

Best Practice

For classroom projects, IoT deployments, and Raspberry Pi labs, it is usually better to:

remove outdated Wi-Fi networks
keep only the active network
avoid connection conflicts

This makes troubleshooting much easier later.

Step 4 — Enable SSH

Still inside the boot partition:

Create an empty file named:

ssh

No extension.

Not:

ssh.txt
ssh.conf

Just:

ssh

This enables the SSH server during boot.

Step 5 — Reinsert SD Card and Boot

Insert the SD card back into the Raspberry Pi.

Power it on.

Wait about:

1–3 minutes

for the Pi to boot and connect.

Step 6 — Find the Raspberry Pi on the Network

Now you need the Pi’s IP address.

Option A — Use Fing (Recommended)

Install:

Fing (Android/iPhone)
Fing Desktop

Scan your network.

Look for:

raspberrypi
Raspberry Pi Foundation
hostname you configured

Option B — Use Router Admin Page

Check:

Connected Devices
DHCP Clients
LAN Devices

You may see:

raspberrypi.local

or an IP like:

192.168.1.12

Option C — Use `ping`

Try:

ping raspberrypi.local

or:

ping yourhostname.local

Step 7 — SSH Into the Pi

Once you have the IP:

ssh pi@192.168.1.12

Or:

ssh username@hostname.local

Example:

ssh stanley@raspberrypi.local

What If You Don’t Know the Username?

Modern Raspberry Pi OS no longer uses:

pi
raspberry

by default.

The username is whatever was set during OS imaging.

If you forgot it:

reflash the OS
or inspect old documentation

Method 2 — Reflash Using Raspberry Pi Imager (Cleanest Option)

If recovery fails completely, just rewrite the OS.

Install Raspberry Pi Imager

Download from:

Raspberry Pi Imager

Configure Headless Setup Properly

Inside Raspberry Pi Imager:

Click:

NEXT → EDIT SETTINGS

Configure:

General

Hostname
Username
Password
Wi-Fi SSID
Wi-Fi Password
Country

Services

Enable:

Choose:

Password authentication

Then write the OS.

This is the most reliable method.

Troubleshooting Tips

1. Pi Not Appearing on Network

Possible causes:

Wrong Wi-Fi password
Wrong country code
Weak Wi-Fi signal
5GHz unsupported network
Hidden SSID

Try:

mobile hotspot
2.4GHz Wi-Fi
moving Pi closer

2. SSH “Hostname Could Not Be Resolved”

This means:

the Pi is not on the network
or mDNS isn’t working

Use direct IP instead.

3. SSH Connection Refused

Usually:

SSH disabled
Pi still booting
firewall issue

Recreate the empty ssh file.

4. Raspberry Pi Only Supports 2.4GHz

Some older Pis cannot use:

5GHz
Wi-Fi 6 only networks

Enable:

mixed mode
2.4GHz compatibility

Bonus Tip — Use Your Phone Hotspot

If you don’t know the old network:

Create a hotspot using:

same Wi-Fi name
same password

as the old network.

The Pi may reconnect automatically.

This is one of the fastest recovery tricks.

Recommended Headless Workflow

Here’s the workflow I now use for every Raspberry Pi deployment:

During OS Imaging

Always configure:

hostname
SSH
Wi-Fi
username/password

inside Raspberry Pi Imager.

Keep Backup Notes

Save:

hostname
username
password
Wi-Fi used

inside:

Notion
Google Docs
password manager

Use Static Hostnames

Instead of:

raspberrypi

Use:

cv-group1
iot-node2
weather-station

This makes network discovery easier.

Final Thoughts

Headless Raspberry Pi setups are incredibly powerful, but Wi-Fi issues can lock you out completely if you don’t plan ahead.

The good news is:
you usually do NOT need a monitor.

As long as you can access the SD card, you can:

change Wi-Fi
enable SSH
recover the device
regain remote access

Once you master this workflow, managing remote Raspberry Pis becomes much easier — especially in classrooms, IoT deployments, robotics projects, and AI edge systems.

Happy building 🚀

API Keys vs. Access Tokens: What's the Real Difference?

Ikegbo Ogochukwu — Wed, 06 May 2026 13:39:41 +0000

As a developer, you’ve definitely seen them: x-api-key, Authorization: Bearer <token>, and Personal Access Tokens.

If you've ever wondered if they are just different names for the same thing—they aren't. Using the wrong one can leave your app wide open to security risks.

Here is the "explain like I'm five" breakdown.

🔑 The API Key: The "Project ID Card"

Think of an API Key as a static ID card for an entire project or application.

Who is it? It identifies the application (e.g., "This request is coming from the WeatherDashboard app").
Life Span: Long-lived. It usually doesn't expire unless you manually rotate it.
Best for: Accessing public data (maps, weather) or simple server-to-server tasks where no specific user login is required.

Example Usage:

// Simple but less secure - anyone with the key can use it.
const url = `https://weather.com{YOUR_API_KEY}`;

🎟️ The Access Token: The "Visitor Badge"

An Access Token (like a JWT) is more like a temporary visitor badge.

Who is it? It identifies the specific user and what they are allowed to do.
Life Span: Short-lived. It expires quickly (often in 1 hour) and needs a "refresh" to stay active.
Best for: Private user data (Gmail, Spotify, Banking). It ensures that even if a token is stolen, the damage is limited by time and scope.

📊 Side-by-Side Comparison

Feature	API Key	Access Token
Identifies	The Application	The User
Expiration	Usually Permanent	Short-lived (Expires)
Security	Low (Static)	High (Dynamic)
Common Flow	Generated in a Portal	Generated via Login (OAuth)

💡 When to use which?

Use an API Key when:

You are calling a public service (like Google Maps).
You need to track usage for billing (e.g., "App X used 1,000 requests").
You are doing internal server-to-server communication in a trusted environment.

Use an Access Token when:

You are dealing with user-specific data (e.g., reading my emails).
Security is a priority (you want the credential to expire).
You need "granular permissions" (e.g., "This app can read my profile but NOT post for me").

🛡️ Pro-tip: Never Hardcode!

Whether you use a key or a token, never commit them to GitHub. Always use environment variables and a .env file.

What are you currently using in your latest project? Drop a comment below! 👇

🚀 Setting Up Raspberry Pi & Camera for AI Projects (Complete Command Guide)

Ikegbo Ogochukwu — Mon, 04 May 2026 18:34:12 +0000

If you're working with a Raspberry Pi for computer vision or AI projects, getting everything set up can be confusing—especially with newer devices like the Raspberry Pi 5.

This guide compiles all essential commands used for:

Setting up your Raspberry Pi
Configuring network access
Enabling remote control
Troubleshooting camera issues
Capturing images

🧠 1. System Setup & Updates

Before doing anything, your system should be updated:

sudo apt update
sudo apt upgrade

🌐 2. Network & IP Configuration

Check IP address

hostname -I

👉 This is needed for:

SSH connection
VNC connection

🔐 3. Remote Access Setup

Enable SSH and VNC

sudo raspi-config

Then navigate:

Interface Options → Enable SSH
Interface Options → Enable VNC

Connect via SSH

ssh pi@<IP_ADDRESS>

Example:

ssh pi@192.168.43.25

🖥️ 4. VNC (Remote Desktop Access)

Used when you want full GUI access from your laptop.

Steps:

Enable VNC (see above)
Install VNC Viewer on your laptop
Connect using:

<IP_ADDRESS>

📸 5. Camera System (Important Update)

On modern Raspberry Pi OS:

Camera is enabled by default (libcamera system)

👉 You will NOT see "Camera" in raspi-config anymore.

🧪 6. Test Camera

Preview camera

rpicam-hello

👉 Works only on GUI (monitor or VNC)

Capture image

rpicam-still -o test.jpg

Record video

rpicam-vid -t 5000 -o video.h264

📂 7. File Management Commands

List files

ls

Create folder

mkdir dataset
cd dataset

🔁 8. Capture Multiple Images

for i in {1..10}; do rpicam-still -o img_$i.jpg; sleep 2; done

🖼️ 9. Open Image (on Raspberry Pi GUI)

xdg-open test.jpg

🧪 10. Python + OpenCV Setup

Start Python

python3

Import OpenCV

import cv2

Load image

img = cv2.imread("test.jpg")

Resize image

resized = cv2.resize(img, (224, 224))
cv2.imwrite("resized.jpg", resized)

Convert to grayscale

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imwrite("gray.jpg", gray)

Convert to HSV

hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
cv2.imwrite("hsv.jpg", hsv)

Exit Python

exit()

⚠️ 11. Common Troubleshooting

Camera not working?

Check:

Cable orientation
Proper connection
Correct port (Pi 5 has 2 ports)

No preview?

SSH = No preview
VNC/Monitor = Preview works

Restart system

sudo reboot

🧠 Key Takeaways

✔ Raspberry Pi OS now uses libcamera
✔ No manual camera enable needed
✔ rpicam-* commands replace raspistill
✔ SSH is for control, not display
✔ VNC gives full desktop access

🎯 Final Thoughts

Once your Raspberry Pi and camera are set up:

👉 You are ready to:

Collect image datasets
Train AI models
Deploy computer vision applications

🔥 If you found this useful

Drop a ❤️
Share with someone learning Raspberry Pi
Follow for more AI + Embedded Systems content

COMPLETE COURSE: Git & GitHub (From Zero to Advanced)

Ikegbo Ogochukwu — Thu, 30 Apr 2026 17:59:55 +0000

📘 COURSE OVERVIEW

This course gives you a rock-solid foundation in:

Git (local version control)
GitHub (remote collaboration)
Real-world workflows (branching, merging, collaboration)

Git = tracks changes locally
GitHub = cloud platform for collaboration

🧩 MODULE 1: WHAT IS GIT?

🔹 Definition

Git is a Version Control System (VCS) that:

Tracks every change in your files
Stores history (who, when, what changed)
Allows rollback to previous versions

🔹 Key Features

Tracks any file type (code, text, images, videos)
Maintains multiple versions
Enables safe experimentation

🔹 Real-world Problem Git Solves

You:

Build a project → client likes it
Update it → client wants old version

👉 Without Git → you're stuck
👉 With Git → you restore instantly

🔗 MODULE 2: GIT vs GITHUB

🔹 Git

Local tool
Runs on your computer

🔹 GitHub

Cloud platform
Stores repositories online
Enables collaboration

🔹 Analogy

Git = coffee ☕
GitHub = coffee shop 🏪

🔹 Alternatives

GitLab
Bitbucket

🏗️ MODULE 3: GIT ARCHITECTURE

🔹 Two Parts

Local
Remote (GitHub)

🔹 Workflow Stages

Working Directory

Where you edit files

Staging Area

Temporary holding area

Repository

Permanent storage (commit history)

🔁 Workflow Summary

Working Directory → Staging Area → Local Repo → Remote Repo

⚙️ MODULE 4: INSTALLING GIT

🔹 Steps

Go to official Git website
Download for:

Windows (32/64-bit)
Mac (Homebrew)
Linux

🔹 Verify Installation

git --version

✔ If installed → shows version
❌ Else → error

💻 MODULE 5: TERMINAL BASICS

🔹 Important Commands (NOT Git commands)

cd       # change directory
pwd      # show current path
mkdir    # create folder
touch    # create file
ls       # list files

📁 MODULE 6: CREATING A PROJECT

🔹 Steps

cd Desktop
mkdir git-1
cd git-1

touch 1.txt
touch 2.txt

mkdir my-folder
cd my-folder
touch 3.txt

🚀 MODULE 7: INITIALIZING GIT

🔹 Command

git init

🔹 What Happens

Creates hidden .git folder
Git starts tracking project

ls -la

👉 Shows .git folder

🌐 MODULE 8: GITHUB REPOSITORY

🔹 Steps

Go to GitHub
Create new repo
Add files online
Commit changes

📥 MODULE 9: CLONING A REPO

🔹 Command

git clone <repo-url>

🔹 Result

Downloads remote repo
Creates local copy

🔍 MODULE 10: TRACKING CHANGES

🔹 Command

git status

🔹 Shows:

Modified files
New files
Deleted files

📦 MODULE 11: STAGING (git add)

🔹 Purpose

Move changes → staging area

🔹 Variations

1. Add everything

git add --all
git add -A

2. Add current directory

git add .

3. Add specific file

git add file.txt

4. Add by extension

git add *.txt

5. Add using wildcard

git add *

⚠️ Does NOT include deleted files

🔄 MODULE 12: UNSTAGING

🔹 Command

git reset

👉 Moves files back to working directory

💾 MODULE 13: COMMITTING

🔹 Command

git commit -m "message"

🔹 Meaning

Permanently saves changes

⚠️ First-time Setup

git config --global user.email "you@email.com"
git config --global user.name "Your Name"

⏪ MODULE 14: UNDO COMMITS

git reset HEAD~

👉 Undo last commit

❌ MODULE 15: DELETING FILES

🔹 Delete + stage

git rm file.txt

🔹 Force delete

git rm -f file.txt

🔹 Remove from Git only

git rm --cached file.txt

📜 MODULE 16: VIEW HISTORY

git log

Short version:

git log --oneline

🌿 MODULE 17: BRANCHING

🔹 Create branch

git branch development

🔹 View branches

git branch

🔹 Switch branch

git checkout development

🔹 Concept

Main = stable code
Branch = experimentation

🔀 MODULE 18: MERGING

🔹 Merge branch

git merge development

⚠️ MODULE 19: MERGE CONFLICTS

Occurs when:

Same file edited in different branches

🔹 Resolution Steps

Open file
Choose correct version
Remove conflict markers
Commit

⏳ MODULE 20: TIME TRAVEL

🔹 Go to old commit

git checkout <commit-id>

🔹 Return to latest

git checkout main

🔍 MODULE 21: COMPARE CHANGES

git diff <commit1> <commit2>

Red → removed
Green → added

☁️ MODULE 22: REMOTE OPERATIONS

🔹 Push

git push origin main

🔹 Fetch

git fetch

🔹 Pull

git pull

🔁 Summary

push → local → remote
fetch → remote → local (no merge)
pull → fetch + merge

🔄 MODULE 23: RESTORE

🔹 Undo changes

git restore file.txt

🔹 Restore all

git restore .

🔹 Unstage

git restore --staged file.txt

📦 MODULE 24: STASH

🔹 Save unfinished work

git stash

🔹 Retrieve later

git stash apply

🧠 FINAL SUMMARY

You now understand:

Git fundamentals
Local vs remote workflow
Full command lifecycle
Branching & collaboration
Conflict resolution
Undoing mistakes safely

Git and GitHub tutorials for Beginners

Ikegbo Ogochukwu — Thu, 30 Apr 2026 11:03:44 +0000

🔰 1. What is Git?

Git = Version Control System

👉 It helps you:

Track changes in your code
Go back to previous versions
Collaborate with others safely

Think of it like:

“Google Docs version history… but for code”

Git records every change as a snapshot (commit) ([FreeCodeCamp][1])

🌐 2. What is GitHub?

GitHub is a cloud platform that hosts Git repositories
It allows:
- Collaboration
- Sharing code
- Team development

👉 Key idea:

Git = tool
GitHub = online platform using Git ([product.hubspot.com][2])

🏗️ 3. Core Git Concepts (VERY IMPORTANT)

📁 Repository (Repo)

A project folder tracked by Git

🧾 Commit

A saved snapshot of your work

📦 Staging Area

Where you prepare changes before saving

🌿 Branch

A separate version of your project (for new features)

🔀 Merge

Combining branches together

⚙️ 4. Basic Git Workflow (The Heart of Everything)

This is the main flow taught in the video:

Step 1: Initialize Git

git init

👉 Turns your folder into a Git repository

Step 2: Add Files

git add .

👉 Moves files to the staging area

Step 3: Commit Changes

git commit -m "Your message"

👉 Saves a snapshot of your work

Step 4: Connect to GitHub

git remote add origin <repo-url>

Step 5: Push to GitHub

git push -u origin main

👉 Uploads your code online

🔄 5. Everyday Git Commands

Check status

git status

See history

git log

Download updates

git pull

Upload changes

git push

🌿 6. Working with Branches (Key Skill)

Create a branch

git checkout -b feature-name

Switch branch

git checkout main

Merge branch

git merge feature-name

👉 Why branches matter:

Work on features without breaking main code ([product.hubspot.com][2])

🤝 7. Collaboration Workflow (GitHub Flow)

This is how teams work:

Create branch
Make changes
Push branch
Open Pull Request (PR)
Review
Merge

👉 Pull Request = “Please review my changes”

🧠 8. Mental Model (Very Important)

Think of Git like this:

Working Directory → Staging → Commit → GitHub

Working → you edit files
Staging → you prepare changes
Commit → you save version
GitHub → you share it

⚡ 9. Common Beginner Mistakes (From the Video)

❌ Forgetting to git add
❌ Bad commit messages
❌ Working directly on main branch
❌ Not pulling before pushing

🚀 10. Your First Practice Exercise

Try this:

mkdir my-project
cd my-project
git init

echo "Hello Git" > file.txt
git add .
git commit -m "First commit"

# connect to GitHub repo
git remote add origin <your-repo-url>
git push -u origin main

🔐 Android App Signing: Why the "Keystore" is Your Most Important File

Ikegbo Ogochukwu — Tue, 28 Apr 2026 22:35:07 +0000

If you are a new Android developer, there is one file that can literally make or break your entire career: the Keystore.
In this post, let’s break down what Android App Signing actually is, why it matters for security, and how Google Play App Signing saved us all from potential disaster.

🧱 The Basics: What is an App Signature?

Think of an app signature as a digital wax seal.
When you build an APK or AAB, you sign it with a private key. This signature tells the Android OS:

Identity: This app was created by Developer X.
Integrity: This app hasn't been modified or tampered with since it was signed.

🛡️ The "Secure Update" Model

The most important thing to understand is how Android handles updates.
When you try to install an update over an existing app, Android checks if the new signature matches the old signature.

Matches? The update proceeds and your user data is safe.
Doesn't match? Android throws an error and blocks the install.

This prevents a hacker from creating a "fake" update to your app to steal user passwords or data.

😱 The "Lost Key" Nightmare (The Old Way)

Before 2017, if you lost your .jks (Java Keystore) file or forgot the password, you were finished.
Because the signature is the only way Android identifies the developer, losing the key meant you could never update your app again. You would have to upload a completely new app with a new package name, losing all your installs and reviews.

🚀 How "Google Play App Signing" Fixed It

Google introduced Play App Signing to solve this exact problem. It splits the signing into two parts:

The Upload Key: This is the key you keep. You sign your app with it and upload it to Google.
The App Signing Key: Google keeps this master key in their secure "Vault."

The big win: If you lose your Upload Key, you just message Google Support. They verify your ID, reset the key, and you're back in business. The App Signing Key (the one the users see) never changes, so the update chain is never broken.

🛠️ Quick Pro-Tips for Devs:

Never commit your .jks file to GitHub (even in a private repo). Use Environment Variables or Secrets.
Always opt-in to Google Play App Signing for new apps.
Backup your keystore in a secure password manager like Bitwarden or 1Password.

Final Thoughts

App signing isn't just a technical hurdle; it’s the foundation of trust between you and your users. Treat your keys like your house keys—don't lose them, and don't give them to anyone else!
Have you ever had a "Lost Keystore" horror story? Let’s talk in the comments! 👇

Stop Losing Progress: Setting Up a Pro Jupyter Workflow in VS Code (No More Colab Timeouts!)

Ikegbo Ogochukwu — Tue, 21 Apr 2026 08:46:18 +0000

The Problem: The "Colab Heartbreak"

We’ve all been there: You’re 40 epochs into a multimodal model for crop disease detection, and suddenly—Session Terminated. Your variables are gone, your local drive isn't synced, and you have to start over.
While Google Colab is great for quick scripts, serious AI projects (like my current multimodal yield prediction system) need persistence and the power of a local IDE.

Why VS Code for Jupyter?

IntelliSense: Better code completion than any browser-based notebook.
Local Environment Control: No more !pip install every time you open the file.
Git Integration: Version control your experiments easily.
The Best of Both Worlds: Use your local UI while connecting to powerful cloud GPUs (like Paperspace or Saturn Cloud).

Step 1: The Essentials

First, grab the Jupyter Extension from the VS Code Marketplace. This transforms VS Code into a full-featured notebook editor.

Step 2: Virtual Environment (The Secret to Stability)

Don't install your ML libraries globally! Create a dedicated environment for your project:

Create the env

python -m venv crop_ai_env

Activate it

source crop_ai_env/bin/activate # Mac/Linux# .\crop_ai_env\Scripts\activate # Windows

Install the kernel connector

pip install ipykernel tensorflow-gpu pillow pandas

Step 3: Launching the Notebook

Create a file named experiment.ipynb.
Look at the top right corner of the editor. Click Select Kernel.
Choose your crop_ai_env.

Tip: If you don't see it, press Ctrl+Shift+P and run "Python: Select Interpreter" first.

Step 4: Pro-Tip for Long Training Runs

If you are doing heavy transfer learning (like MobileNetV3), use a Checkpoint Callback. This ensures that even if your computer restarts, your model weights are safe on your drive:

checkpoint_path = "checkpoints/crop_model_v1.ckpt"cp_callback = tf.keras.callbacks.ModelCheckpoint(
filepath=checkpoint_path,
save_weights_only=True,
verbose=1
)

Your model.fit() now has a safety net

model.fit(train_data, epochs=50, callbacks=[cp_callback])

Conclusion

Switching from Colab to VS Code + a local virtual environment (synced via GitHub or a Cloud Drive) has saved me hours of re-training time. If you're building lightweight TFLite models for offline use, this local-first workflow is a game-changer.

What’s your biggest frustration with browser-based notebooks? Let’s discuss in the comments!

Fixing a Flutter Release APK Build That Failed on Windows

Ikegbo Ogochukwu — Thu, 16 Apr 2026 13:27:12 +0000

How I diagnosed a misleading Gradle failure, separated a temporary Maven network issue from the real Android packaging problem, and fixed the release APK build with a small Gradle change

Introduction

I was building a Flutter release APK on Windows for tester distribution and ran into a confusing sequence of build failures.

The first error looked like a dependency-resolution problem:

Could not GET 'https://repo.maven.apache.org/...'
No such host is known (repo.maven.apache.org)

That made it look like the project or Firebase setup was broken.

After retrying once the network recovered, the real build blocker appeared:

Execution failed for task ':app:extractReleaseNativeSymbolTables'.
Failed to create MD5 hash for file ... libflutter.so.sym.temp-stream ...

This is the kind of issue that wastes time because the first failure distracts you from the second one. The Maven error was temporary. The actual release-build problem was native symbol extraction during Android packaging on Windows.

This post explains how I diagnosed it and the small fix that got the APK building successfully.

The goal

The goal was simple:

produce a signed release APK
share it directly with testers
avoid changing unrelated parts of the Android build

The project already had release signing configured, so this was not a keystore or package-name problem.

Step 1: Separate the temporary network error from the real build issue

The first failure was:

Could not resolve all files for configuration ':firebase_core:releaseRuntimeClasspath'
Could not download error_prone_annotations-2.26.0.jar
No such host is known (repo.maven.apache.org)

That is not a Flutter code issue.

It means Gradle could not reach Maven Central at that moment. Before changing any project files, I verified whether the host was reachable from the machine.

Useful checks on Windows:

nslookup repo.maven.apache.org
Test-NetConnection repo.maven.apache.org -Port 443

Once Maven Central was reachable again, the dependency download issue disappeared.

That was important, because fixing the wrong problem would have been wasted effort.

Step 2: Retry the build and read the next failure carefully

After the network issue cleared, the build failed again, but with a different error:

Execution failed for task ':app:extractReleaseNativeSymbolTables'.
Cannot access output property 'outputDir' of task ':app:extractReleaseNativeSymbolTables'.
Failed to create MD5 hash for file ... libflutter.so.sym.temp-stream ... as it does not exist.

This pointed to Android native symbol extraction, not Firebase, not signing, and not dependency resolution.

That distinction matters.

By this point, the release APK build was already far enough along to show that:

Flutter dependencies were resolving
Firebase packages were not the main blocker
the Android project structure was basically valid

The failure was happening in the release packaging phase.

Step 3: Identify what was actually safe to disable

For a tester APK, I did not need packaged native debug symbols.

That made the fix straightforward: disable native debug symbol packaging for the release build.

In android/app/build.gradle.kts, I updated the release build type to set:

ndk {
    debugSymbolLevel = "none"
}

The relevant release block became:

buildTypes {
    release {
        isMinifyEnabled = true
        isShrinkResources = true
        ndk {
            debugSymbolLevel = "none"
        }
        if (hasKeystoreConfig) {
            signingConfig = signingConfigs.getByName("release")
        } else {
            signingConfig = signingConfigs.getByName("debug")
        }
    }
}

This was a targeted fix. It did not relax signing. It did not remove shrinking. It only stopped the build from trying to package native debug symbols that were triggering the failure.

Step 4: Rebuild the APK

From the Flutter project root, I reran:

flutter pub get
flutter build apk --release

After the debugSymbolLevel = "none" change, the build completed successfully and produced:

build\app\outputs\flutter-apk\app-release.apk

In my case, the resulting APK was about 64.5 MB, which was fine for direct tester distribution.

Warnings that looked scary but were not the blocker

During the build, there were also warnings like these:

source value 8 is obsolete
target value 8 is obsolete

and:

Font asset "MaterialIcons-Regular.otf" was tree-shaken

Those warnings were not what caused the release build to fail.

It is worth calling that out because large build logs often mix harmless warnings with the real failure, and it is easy to chase the wrong thing.

Why this fix made sense

This was a pragmatic release-build decision.

For a tester APK, the priority was:

get a stable release artifact
keep minification and shrinking enabled
avoid unnecessary Gradle/NDK packaging work that was failing on this environment

If I were setting up a more advanced crash-symbol workflow later, I could revisit symbol generation in a more controlled release pipeline. But for immediate tester distribution, disabling native debug symbol packaging was the right tradeoff.

Final takeaway

The key lesson was not just the Gradle fix. It was the debugging sequence:

verify whether the first error is actually environmental
retry once the environment is healthy
fix the first reproducible project-level failure, not the first scary message in the log

In this case:

the Maven Central error was temporary network/DNS trouble
the actual reproducible blocker was extractReleaseNativeSymbolTables
the successful fix was setting debugSymbolLevel = "none" in the release build

If your Flutter release APK build fails on Windows during native symbol extraction, and you do not need packaged native symbols for that build, this is a clean fix worth trying.

Build command recap

flutter pub get
flutter build apk --release

Gradle fix recap

ndk {
    debugSymbolLevel = "none"
}

DEV Community: Ikegbo Ogochukwu

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

Why PowerShell Matters for Networking

Understanding TCP Before Troubleshooting

1. Check Your Network Configuration

2. Test Connectivity Properly

3. Discover Devices on Your Network

4. Scan an Entire Subnet

5. Find Open TCP Ports

6. Monitor Active TCP Connections

7. Troubleshoot Docker Connectivity

8. Automate Network Diagnostics

9. Network Monitoring at Scale

Real Lesson: Developers Need Networking Skills

Final Thoughts

Further Reading

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

What Is an HPC Cluster?

Understanding the Architecture

The Biggest Mindset Shift in HPC

Connecting to the Cluster

Linux Skills You MUST Know

Navigation Commands

File Inspection

Process Monitoring

Understanding Modules

Checking Available Modules

Loading Python

Viewing Loaded Modules

Clearing Modules

Understanding SLURM

Essential SLURM Commands

View Available Partitions

View Running Jobs

Submit a Job

Start Interactive Session

Cancel a Job

Your First SLURM Script

Understanding SBATCH Parameters

Monitoring Jobs

Check Queue

Live Monitoring

View Job Details

Understanding Job States

Interactive GPU Sessions

Python Environments on HPC

Create Environment

GPU Training Workflow

Storage Systems Matter More Than Beginners Think

Transferring Files

SCP Example

RSYNC Example

Running PyTorch on HPC

Multi-GPU Training

MPI and Distributed Computing

Containers in HPC

Common Beginner Mistakes

Running Heavy Jobs on Login Nodes

Requesting Too Many Resources

Ignoring Logs

CUDA Version Mismatches

HPC vs Cloud GPUs

Recommended Learning Path

Stage 1 — Linux

Stage 2 — SLURM

Stage 3 — Python Environments

Stage 4 — GPU Computing

Stage 5 — Advanced HPC

Practice Projects for Beginners

Beginner

Intermediate

Advanced

Final Thoughts

Useful Resources

Docker Cheat Sheet: Commands Every Developer Should Know

Introduction

1. Check Docker Installation

2. Docker Images

List images

Pull an image

Example `docker-compose.yml`