DEV Community: Kaifi Azam

How to Calculate an IPv4 Subnet Range From Any IP Address

Kaifi Azam — Fri, 31 Jul 2026 21:42:35 +0000

How to Calculate an IPv4 Subnet Range From Any IP Address

A CIDR value such as:

192.168.1.130/26

contains two pieces of information:

192.168.1.130 is an address inside the subnet
/26 means the first 26 bits identify the network

The entered address does not need to be the network address. You can calculate the containing network from any valid address inside the range.

In this example, the result is:

Network:          192.168.1.128/26
Broadcast:        192.168.1.191
First usable:     192.168.1.129
Last usable:      192.168.1.190
Subnet mask:      255.255.255.192
Wildcard mask:    0.0.0.63
Total addresses:  64
Usable hosts:     62

Here is how to calculate every value manually.

Step 1: Convert the prefix into host bits

IPv4 addresses contain 32 bits.

A /26 prefix reserves 26 bits for the network:

Host bits = 32 - 26
Host bits = 6

The subnet therefore contains:

2⁶ = 64 addresses

For a normal subnet, the lowest address identifies the network and the highest address is the broadcast address.

That leaves:

64 - 2 = 62 usable host addresses

Step 2: Find the subnet mask

A /26 mask contains 26 ones followed by 6 zeros:

11111111.11111111.11111111.11000000

Convert each octet to decimal:

255.255.255.192

So the subnet mask is:

255.255.255.192

Step 3: Calculate the block size

The interesting octet is the first mask octet that is not 255.

For /26, that octet is 192.

Calculate the block size:

Block size = 256 - 192
Block size = 64

The possible subnet boundaries in the final octet are therefore:

Each range contains 64 addresses:

The entered address ends in 130.

Since 130 falls between 128 and 191, its network is:

192.168.1.128/26

Step 4: Find the broadcast address

The broadcast address is the final address in the subnet.

The selected block runs from:

192.168.1.128

through:

192.168.1.191

Therefore:

Broadcast address = 192.168.1.191

Another way to calculate it is:

Broadcast = Network + Total addresses - 1
Broadcast = 128 + 64 - 1
Broadcast = 191

Step 5: Find the usable host range

For a traditional IPv4 subnet:

First usable = Network + 1
Last usable  = Broadcast - 1

That gives:

First usable: 192.168.1.129
Last usable:  192.168.1.190

The same calculation in binary

The final octet of the entered IP is 130:

130 = 10000010

The final octet of the /26 mask is 192:

192 = 11000000

Apply the mask to the address:

IP:       10000010
Mask:     11000000
Network:  10000000

10000000 is 128, giving:

192.168.1.128

Set all six host bits to 1 to find the broadcast address:

Network:    10000000
Broadcast:  10111111

10111111 is 191, giving:

192.168.1.191

Quick CIDR reference

Prefix	Subnet mask	Total addresses	Traditional usable hosts
`/24`	`255.255.255.0`	256	254
`/25`	`255.255.255.128`	128	126
`/26`	`255.255.255.192`	64	62
`/27`	`255.255.255.224`	32	30
`/28`	`255.255.255.240`	16	14
`/29`	`255.255.255.248`	8	6
`/30`	`255.255.255.252`	4	2
`/31`	`255.255.255.254`	2	Special case
`/32`	`255.255.255.255`	1	Single address

The same block-size method works across octet boundaries.

For example, with a /20 mask:

Subnet mask = 255.255.240.0
Block size  = 256 - 240
Block size  = 16

The third-octet boundaries are:

0, 16, 32, 48, 64, 80...

An address such as:

172.16.37.10/20

falls inside the 32–47 block.

Its containing network is therefore:

172.16.32.0/20

and its broadcast address is:

172.16.47.255

The `/31` exception

A /31 contains two addresses.

Under the traditional subnet rule, subtracting a network and broadcast address would leave no usable hosts. However, /31 networks can use both addresses as endpoints on a point-to-point link.

For example:

10.0.0.4/31

contains:

10.0.0.4
10.0.0.5

On an appropriately configured point-to-point link, both can be used as endpoint addresses.

Do not automatically treat /31 like a regular LAN subnet.

What does `/32` mean?

A /32 identifies one exact IPv4 address:

203.0.113.25/32

It contains no additional addresses and is commonly used when a route, rule, or configuration must match a single host.

Calculate and verify it automatically

For quick checks, I built the Olivez IPv4 Subnet Calculator.

You can enter any IPv4 address with a prefix from /0 through /32, including an address that is not already the network boundary.

It calculates:

Containing CIDR network
Subnet mask
Wildcard mask
Broadcast address
First and last usable addresses
Total and usable address counts
Address classification
Binary network and host split

For example, entering:

192.168.1.130/26

returns the normalized network:

192.168.1.128/26

The calculator is useful for verifying manual work, but understanding the block-size method makes it much easier to spot incorrect CIDR ranges in routing tables, firewall rules, cloud networks, and infrastructure configuration.

A reusable calculation process

For any IPv4 address and prefix:

Subtract the prefix from 32 to find the number of host bits.
Calculate 2^host bits to find the total number of addresses.
Convert the prefix to a subnet mask.
Find the first mask octet that is not 255.
Calculate its block size using 256 - mask octet.
Find which block contains the entered address.
Use the first address as the network boundary.
Use the final address as the broadcast boundary.
Exclude those two addresses for the traditional usable range.
Handle /31 and /32 as special cases.

Once you can identify the block boundary, the rest of the subnet becomes straightforward.

How to Verify a SHA-256 Checksum on Windows, macOS, and Linux

Kaifi Azam — Fri, 31 Jul 2026 21:34:52 +0000

How to Verify a SHA-256 Checksum on Windows, macOS, and Linux

You download an ISO, installer, archive, or release binary. The publisher provides a long value such as:

9f86d081884c7d659a2feaa0c55ad015
a3bf4f1b2b0b822cd15d6c15b0f00a08

That value is a checksum, usually generated with SHA-256.

Verifying it answers one practical question:

Does the file you downloaded have exactly the same contents as the file the publisher hashed?

A checksum mismatch can indicate a damaged download, an incomplete transfer, the wrong file version, or modified contents.

Before verifying anything

Get the expected checksum from a source you trust.

Ideally, use the software publisher’s official website, release page, package repository, or signed checksum file.

A matching checksum confirms that your file matches the data represented by the expected hash. It does not prove that the original publisher or website was trustworthy. If an attacker can replace both the download and the displayed checksum, they can make the two values match.

For stronger authenticity verification, use a signed release when the publisher provides one.

Verify SHA-256 on Windows

Open PowerShell in the folder containing the downloaded file.

Run:

Get-FileHash ".\filename.iso" -Algorithm SHA256

Example:

Get-FileHash ".\ubuntu.iso" -Algorithm SHA256

PowerShell returns something similar to:

Algorithm : SHA256
Hash      : 4A1F...
Path      : C:\Users\You\Downloads\ubuntu.iso

Compare the value beside Hash with the checksum published by the download provider.

Uppercase and lowercase letters do not matter in hexadecimal hashes. The characters themselves must otherwise match exactly.

Compare automatically in PowerShell

Instead of comparing two 64-character values manually, store the expected checksum and let PowerShell compare them:

$expected = "PASTE_EXPECTED_SHA256_HERE"
$actual = (Get-FileHash ".\filename.iso" -Algorithm SHA256).Hash

if ($actual -eq $expected) {
    Write-Host "Checksum matches"
} else {
    Write-Host "Checksum does not match"
}

Verify SHA-256 on macOS

Open Terminal and run:

shasum -a 256 filename.dmg

Example:

shasum -a 256 application.dmg

The result contains the calculated checksum followed by the filename:

4a1f...  application.dmg

Compare the calculated value with the publisher’s expected SHA-256 checksum.

Quotes are useful when a filename contains spaces:

shasum -a 256 "Application Installer.dmg"

Verify SHA-256 on Linux

Most Linux distributions provide sha256sum through GNU core utilities.

Run:

sha256sum filename.iso

Example:

sha256sum linux-distribution.iso

The output looks like this:

4a1f...  linux-distribution.iso

Compare the first value with the checksum from the publisher.

Verify a SHA256SUMS file on Linux

Some projects provide a file named SHA256SUMS, checksums.txt, or something similar.

A GNU checksum line normally looks like:

4a1f...  linux-distribution.iso

When the checksum file and downloaded file are in the same directory, run:

sha256sum --check SHA256SUMS

The short form also works:

sha256sum -c SHA256SUMS

A successful result looks like:

linux-distribution.iso: OK

A failure may look like:

linux-distribution.iso: FAILED

This method is safer than visually comparing long values because the command performs the comparison directly.

Verify a checksum without using the command line

For occasional checks, I built the Olivez Hash Generator & Checksum Checker.

It supports SHA-256, SHA-384, and SHA-512 for files and exact text.

The verification field accepts several common formats:

4a1f...

4a1f...  filename.iso

SHA256 (filename.iso) = 4a1f...

SHA-256: 4a1f...

It can also read multiline checksum lists and select the entry matching the chosen filename.

Files and text are processed locally and are not uploaded. The current file limit is 100 MB, so command-line tools remain the better option for large ISO images and multi-gigabyte archives.

Why did my checksum fail?

A mismatch does not automatically mean malware. Common causes include:

You downloaded a different version

Checksums change whenever file contents change. Version 2.1 and version 2.1.1 will normally have completely different hashes.

The download was incomplete or corrupted

Delete the file, download it again, and recalculate the checksum.

You selected the wrong algorithm

A SHA-256 value contains 64 hexadecimal characters.

Common digest lengths are:

Algorithm	Hexadecimal characters
MD5	32
SHA-1	40
SHA-256	64
SHA-384	96
SHA-512	128

Calculating SHA-512 will never match a published SHA-256 value, even when both were generated from the same file.

The checksum belongs to another filename

Checksum lists often contain values for several operating systems, architectures, or package formats. Confirm that you are comparing the entry for the exact file you downloaded.

The expected value contains extra text

Publishers may use GNU, BSD, labelled, or custom checksum formats. Make sure you are comparing the digest itself rather than copying punctuation, a filename, or the algorithm label into a field that expects only hexadecimal characters.

SHA-256 is not password hashing

SHA-256 is useful for file integrity, release verification, content identification, and similar tasks.

Do not store passwords as plain SHA-256 hashes.

Password storage requires a dedicated password-hashing function such as Argon2id, scrypt, bcrypt, or PBKDF2 with appropriate parameters and unique salts.

The practical rule

Use the operating system command when you regularly verify files or work with large downloads:

Windows: Get-FileHash
macOS:   shasum -a 256
Linux:   sha256sum

Use a local-processing interface when you need to check a smaller file, compare text, parse a complete checksum line, or inspect a multiline checksum list without manually extracting the correct digest.

Whichever method you use, obtain the expected checksum from a trusted source and make sure the algorithm, filename, and file version all match.

How to Convert Nested JSON to CSV Without Losing Fields

Kaifi Azam — Fri, 31 Jul 2026 20:22:35 +0000

Converting a flat JSON array to CSV is straightforward. Real datasets are rarely flat.

API responses often contain nested objects, arrays, optional fields, large numeric identifiers, and properties that appear only in later records. A basic conversion can silently drop data, misalign columns, or change values when the CSV is opened in spreadsheet software.

This guide covers the main problems and how to handle them safely.

The converted table can be reviewed and adjusted before exporting CSV or XLSX.

A simple JSON to CSV conversion

This JSON is already tabular:

[
  {
    "name": "Ada",
    "role": "Engineer"
  },
  {
    "name": "Linus",
    "role": "Developer"
  }
]

It maps cleanly to:

name,role
Ada,Engineer
Linus,Developer

Each object becomes a row, and each property becomes a column.

The problems begin when the structure becomes more complex.

1. Flatten nested objects

Consider this dataset:

[
  {
    "id": 101,
    "name": "Ada",
    "company": {
      "name": "Analytical Systems",
      "country": "UK"
    }
  }
]

CSV does not support nested objects directly. One practical solution is to flatten nested fields using dot notation:

id,name,company.name,company.country
101,Ada,Analytical Systems,UK

This preserves the original field relationships without storing the complete object as an unreadable JSON string.

For deeper structures:

{
  "customer": {
    "address": {
      "city": "London"
    }
  }
}

The resulting column can be:

customer.address.city

The flattening rule should remain predictable throughout the dataset.

2. Handle arrays consistently

Arrays may contain primitive values, objects, different numbers of items, or mixed structures.

Example:

[
  {
    "name": "Ada",
    "skills": ["JavaScript", "Python"]
  },
  {
    "name": "Linus",
    "skills": ["C"]
  }
]

One approach is to expand array positions into numbered columns:

name,skills__001,skills__002
Ada,JavaScript,Python
Linus,C,

The second row keeps an empty skills__002 cell instead of shifting data into the wrong column.

Arrays of objects can follow the same pattern:

{
  "orders": [
    {
      "id": 1,
      "total": 25
    },
    {
      "id": 2,
      "total": 40
    }
  ]
}

Possible columns include:

orders__001.id
orders__001.total
orders__002.id
orders__002.total

This may not be the ideal structure for every analysis workflow, but it creates stable columns without discarding values.

3. Scan every record for columns

A common conversion mistake is using only the first object to determine the CSV headers.

Consider:

[
  {
    "id": 1,
    "name": "Ada"
  },
  {
    "id": 2,
    "name": "Linus",
    "email": "linus@example.com"
  }
]

Using only the first object would produce:

id,name
1,Ada
2,Linus

The email field disappears.

A safer converter scans the complete dataset and creates a union of every discovered field:

id,name,email
1,Ada,
2,Linus,linus@example.com

Missing values become empty cells while every row remains correctly aligned.

4. Preserve large numeric identifiers

JavaScript cannot safely represent every large integer as a normal number.

For example:

{
  "accountId": 9223372036854775807
}

That value exceeds JavaScript's safe integer range. Parsing it normally may change the final digits.

This matters for values such as:

Database IDs
Order numbers
Social media identifiers
Financial reference numbers
Snowflake-style IDs

Large identifiers should be preserved as text rather than silently rounded.

Spreadsheet software may also display long identifiers using scientific notation, so treating them as strings is often safer.

5. Support JSONL and NDJSON

Not every dataset is stored as one JSON array.

JSON Lines and NDJSON store one complete JSON object on each line:

{"id":1,"name":"Ada"}
{"id":2,"name":"Linus"}
{"id":3,"name":"Grace"}

This format is common in:

Log exports
Streaming systems
Data pipelines
Large datasets
Command-line workflows

A useful converter should recognize both standard JSON arrays and line-delimited JSON.

Each valid line becomes one table row.

6. Escape CSV values correctly

CSV values need escaping when they contain:

Commas
Quotation marks
New lines
The selected delimiter

A value such as:

London, United Kingdom

Must be exported as:

"London, United Kingdom"

Quotation marks inside a quoted value must be doubled.

This value:

She said "hello"

Becomes:

"She said ""hello"""

Without correct escaping, columns may become misaligned when the file is opened.

7. Protect against spreadsheet formulas

Spreadsheet software may interpret cells beginning with certain characters as formulas.

Potential examples include:

=SUM(A1:A5)
+CMD
-10+20
@IMPORTXML(...)

This is commonly called CSV or spreadsheet formula injection.

A safer CSV export can prefix suspicious values so the spreadsheet treats them as text instead of executing them as formulas.

This is especially important when the original JSON contains values from users, forms, APIs, or external systems.

8. Preview the table before exporting

A table preview helps reveal structural problems before creating the final file.

Useful checks include:

Were nested fields flattened correctly?
Did later records introduce additional columns?
Are arrays expanding consistently?
Are large identifiers unchanged?
Are unexpected fields present?
Are some columns mostly empty?

Column selection is also useful when an API response contains dozens of fields but only a few are needed.

9. Choose CSV or XLSX based on the workflow

CSV is usually better when:

The file will be imported into another system
Portability matters
A simple text format is preferred
The dataset will be processed by code

XLSX can be more convenient when:

The file will be opened directly in spreadsheet software
Users expect a native spreadsheet file
Long identifiers need more controlled handling
A structured workbook is preferred

The correct format depends on what will happen after conversion.

Practical checklist

Before exporting JSON data, confirm that the converter:

Scans every record for fields
Flattens nested objects predictably
Handles arrays without shifting columns
Keeps missing values aligned
Preserves large integer identifiers
Escapes delimiters, quotation marks, and new lines
Protects against spreadsheet formulas
Supports JSONL and NDJSON when needed
Provides a preview before downloading
Lets users remove unnecessary columns

A converter built for these cases

I built Olivez JSON to CSV Converter while working through these problems.

It supports:

JSON, JSONL, and NDJSON
Pasted data
Local files up to 100 MB
Public JSON URLs
Nested object flattening
Stable numbered array columns
Full-dataset column discovery
Large integer preservation
Table preview and column selection
CSV and XLSX export
Custom CSV delimiters
Spreadsheet formula protection

Local files and pasted data are processed on your device, and no account is required.

https://olivez.in/tool/json-to-csv-converter

The goal was not only to replace braces with commas. It was to make the conversion predictable enough that you can inspect the result and trust the exported file.

This is my fav design for a web!

Kaifi Azam — Fri, 31 Jul 2026 16:23:16 +0000

Kaifi Azam

Jul 31

I built a browser color picker that replaces five separate color tools

#showdev #webdev #nextjs #design

1 min read

I built a browser color picker that replaces five separate color tools

Kaifi Azam — Fri, 31 Jul 2026 16:21:50 +0000

I kept switching between separate tools for picking a color, sampling an image, converting formats, generating a palette, and checking contrast.

So I built one browser-based workspace that combines them.

What it includes

Visual saturation, brightness, and hue controls
Screen eyedropper where the browser supports it
Pixel sampling from a locally uploaded image
Synchronized HEX, RGB, HSL, HSV, and CMYK values
Complementary, analogous, triadic, and split-complementary palettes
WCAG contrast checks for normal and large text
CSS custom property and JSON palette exports
Recent colors stored during the current session

Everything runs in the browser. Image files are processed locally, and no account is required.

Live tool:
Color Picker Olivez

The interface was also an important part of the project. I wanted it to feel like a proper design workspace rather than another form inside a generic calculator card.

I would especially appreciate feedback on two things:

Does the transition from the hero into the color workbench feel natural?
Does the tool expose too many controls at once, or is the layout still easy to understand?

DEV Community: Kaifi Azam

How to Calculate an IPv4 Subnet Range From Any IP Address

How to Calculate an IPv4 Subnet Range From Any IP Address

Step 1: Convert the prefix into host bits

Step 2: Find the subnet mask

Step 3: Calculate the block size

Step 4: Find the broadcast address

Step 5: Find the usable host range

The same calculation in binary

Quick CIDR reference

The /31 exception

What does /32 mean?

Calculate and verify it automatically

A reusable calculation process

How to Verify a SHA-256 Checksum on Windows, macOS, and Linux

How to Verify a SHA-256 Checksum on Windows, macOS, and Linux

Before verifying anything

Verify SHA-256 on Windows

Compare automatically in PowerShell

Verify SHA-256 on macOS

Verify SHA-256 on Linux

Verify a SHA256SUMS file on Linux

Verify a checksum without using the command line

Why did my checksum fail?

You downloaded a different version

The download was incomplete or corrupted

You selected the wrong algorithm

The checksum belongs to another filename

The expected value contains extra text

SHA-256 is not password hashing

The practical rule

How to Convert Nested JSON to CSV Without Losing Fields

A simple JSON to CSV conversion

1. Flatten nested objects

2. Handle arrays consistently

3. Scan every record for columns

4. Preserve large numeric identifiers

5. Support JSONL and NDJSON

6. Escape CSV values correctly

7. Protect against spreadsheet formulas

8. Preview the table before exporting

9. Choose CSV or XLSX based on the workflow

Practical checklist

A converter built for these cases

This is my fav design for a web!

I built a browser color picker that replaces five separate color tools

I built a browser color picker that replaces five separate color tools

What it includes

The `/31` exception

What does `/32` mean?