DEV Community: Kaifi Azam

How an Adaptive Typing Tutor Improves Accuracy Before Speed

Kaifi Azam — Tue, 04 Aug 2026 10:22:12 +0000

Most typing tests measure the final result.

They tell you:

How many words you typed per minute
How many mistakes you made
How accurate the completed text was

Those numbers are useful, but they do not always explain what is holding you back.

A learner might reach 50 words per minute while repeatedly mistyping the same letters. Another learner may appear accurate only because they use Backspace to repair every mistake before finishing.

A better typing tutor should do more than display a score.

It should identify weak keys, adjust the next lesson, track genuine first-attempt accuracy, and introduce new letters only when the learner is ready.

That is the approach behind the Olivez Typing Tutor.

In this article, we will explore:

Why accuracy should come before speed
What first-attempt accuracy means
How adaptive typing practice works
Why fixed passages are not enough
How weak keys can influence lesson generation
How progress can be stored locally
How students can build a more effective practice routine
Typing speed is only one part of the skill

Typing speed is commonly measured in words per minute, usually written as WPM.

A standard typing “word” is normally treated as five characters, including spaces and punctuation.

A simplified calculation is:

[
\text{WPM} =
\frac{\text{characters typed}}{5 \times \text{minutes}}
]

For example, if a student types 250 characters in one minute:

[
\frac{250}{5} = 50 \text{ WPM}
]

That number describes output speed, but it does not reveal how smoothly the text was produced.

Two students can both score 50 WPM while having very different typing habits.

One may type with steady rhythm and few mistakes.

The other may type quickly, pause frequently, make repeated errors, and rely heavily on Backspace.

The final WPM score can hide those differences.

Accuracy should come before speed

Trying to type faster before building accurate finger movements can reinforce poor habits.

Every repeated mistake teaches the learner something, even when the lesson is unintended.

If a student consistently presses i instead of o, rushing through more passages may strengthen that incorrect movement.

A more reliable learning sequence is:

Accuracy → consistency → speed

First, the correct finger should reach the correct key.

Next, that movement should become repeatable.

Only then should the learner increase speed.

This is similar to learning a musical instrument. Practising a difficult section slowly and correctly is usually more effective than playing it quickly with the same mistake every time.

Completed accuracy can hide mistakes

Many typing applications calculate accuracy by looking only at the final text.

Suppose the target word is:

typing

A learner enters:

typimg

They then press Backspace, replace the incorrect m with n, and finish with the correct word.

The final text matches the target, but the learner still made a mistake on the first attempt.

That distinction matters.

The corrected text shows the learner understood the target.

The first keypress shows whether the movement was reliable.

The Olivez Typing Tutor keeps first-attempt performance separate from visible corrections.

Backspace can repair the text on screen, but it does not erase the original error from the learning statistics.

This produces a more honest picture of which keys need practice.

What first-attempt accuracy means

First-attempt accuracy measures whether each character was typed correctly before any correction.

A simplified formula is:

[
\text{First-attempt accuracy} =
\frac{\text{correct first keypresses}}
{\text{total first keypresses}}
\times 100
]

Imagine a student attempts 100 characters.

They type 92 correctly on the first attempt and initially mistype 8.

Their first-attempt accuracy is:

[
\frac{92}{100} \times 100 = 92%
]

Even if they correct all eight mistakes with Backspace, the first-attempt score remains 92%.

This helps distinguish between:

Producing correct final text
Producing correct movements automatically

Both matter, but they describe different stages of learning.

Why fixed typing passages have limits

Fixed passages are useful for measuring general performance.

They can test:

Reading and transcription
Punctuation
Capital letters
Word spacing
Sustained typing
Overall speed

However, a fixed passage may not contain enough examples of the keys causing difficulty.

If a learner struggles with b, p, and y, a generic paragraph may include those letters only a few times.

The student can complete the exercise without receiving enough targeted practice to improve them.

An adaptive tutor can instead generate lessons that contain weak keys more frequently.

The goal is not to create meaningless repetition. It is to place difficult letters inside readable patterns and words so the learner practises the exact movements that need attention.

How adaptive typing practice works

An adaptive typing tutor changes the lesson based on recent performance.

A simplified cycle looks like this:

The learner completes a lesson.
The tutor records each attempted key.
Correct and incorrect first attempts are counted.
Frequently missed keys receive more weight.
The next lesson includes those keys more often.
Progress is reviewed before new letters are introduced.

This creates a feedback loop.

Instead of giving every learner the same exercise, the tutor responds to individual performance.

A student who struggles with r and t may receive more words containing those letters.

A student who types them accurately but slowly may receive practice designed to improve rhythm.

A student who has not collected enough attempts may continue practising the same active letter set before the system makes a strong judgement.

Why evidence count matters

A percentage can be misleading when it is based on very little data.

Suppose a learner types the letter j correctly once.

Their recorded accuracy for j would technically be 100%.

That does not prove the key has been mastered.

Compare these results:

Key A: 1 correct attempt out of 1
Key B: 97 correct attempts out of 100

Key A has the higher percentage, but Key B has much stronger evidence.

An adaptive learning system should therefore consider both:

Accuracy
Number of recorded attempts

This prevents the tutor from unlocking new material based on one or two lucky keypresses.

The Olivez Typing Tutor uses collected evidence alongside performance rather than relying on a percentage alone.

Controlled letter unlocking

Showing the entire keyboard immediately can overwhelm beginners.

There are too many movements to remember at once, and mistakes become difficult to diagnose.

A progressive typing tutor can begin with a smaller group of common letters.

New letters are introduced only after the learner demonstrates sufficient control over the current set.

The Olivez Typing Tutor evaluates factors such as:

First-attempt accuracy
Typing speed
Amount of practice evidence
Performance across active letters
Recent weak keys

A new letter should not unlock simply because one lesson was completed.

The learner needs to show that the existing set is becoming reliable.

This creates a more manageable learning path.

A simplified unlocking rule

An adaptive system might use conditions similar to these:

const canUnlockNextLetter =
firstAttemptAccuracy >= 95 &&
currentSpeed >= targetSpeed &&
minimumEvidenceReached;

The exact learning system can be more detailed, but the basic idea is clear.

Progress should depend on demonstrated ability rather than time spent clicking through exercises.

A learner who needs additional practice can remain on the current letter set.

A learner who meets the conditions can move forward without repeating material unnecessarily.

Identifying weak keys

A weak key is not always the key with the lowest raw accuracy.

Several factors may matter:

Number of mistakes
Number of total attempts
Recent performance
Time taken to type the key
Whether the same error repeats
Confusion with a nearby key
Improvement or decline over time

A simplified weakness score could combine error rate with evidence:

function getWeaknessScore(
mistakes,
attempts,
) {
if (attempts === 0) {
return 0;
}

const errorRate =
    mistakes / attempts;

const confidence =
    Math.min(attempts / 20, 1);

return errorRate * confidence;

}

The confidence factor prevents a key with one mistake from being treated as more important than a key with repeated errors across many attempts.

This is only a simplified example, but it demonstrates why adaptive systems should consider both performance and sample size.

Lesson generation around weak keys

After weak keys are identified, the tutor can give them a greater chance of appearing in the next lesson.

A basic weighted selection model might look like this:

const keyWeights = {
a: 1,
s: 1,
d: 3,
f: 2,
};

In this example, d and f need more attention.

The lesson generator can use the weights to include those letters more often while still mixing in stronger keys.

This is better than creating a lesson made entirely from the weakest character.

Typing requires transitions between letters, not isolated keypresses.

For example, a learner struggling with d may benefit from practising combinations such as:

ad
do
did
red
side
added

The surrounding letters help train realistic movement patterns.

Why repeated key errors matter

Not all mistakes are equally useful.

A one-off mistake may happen because the learner was distracted.

A repeated mistake suggests a more stable problem.

Examples include:

Pressing a neighbouring key
Using the wrong finger
Reaching too far
Losing the home-row position
Confusing two similar movements
Typing a familiar letter sequence incorrectly

A tutor that tracks repeated errors can provide more useful feedback than one that reports only a single overall accuracy percentage.

Instead of saying:

Accuracy: 92%

It can reveal:

Most difficult keys: R, T, and P

That gives the learner a clear next step.

Consistency matters too

A learner may produce a high average speed through short bursts followed by long pauses.

For example:

Fast burst → pause → correction → fast burst → pause

The average WPM may look respectable, but the rhythm is unstable.

Consistent typing means maintaining a controlled pace without frequent hesitation or correction.

This is important because practical typing is not a ten-second sprint.

Students often need to type:

Essays
Notes
Assignments
Emails
Code
Research
Exam answers
Long-form documents

A sustainable rhythm is more useful than a brief personal record.

Local progress storage

A typing tutor becomes more useful when it remembers progress between sessions.

That data may include:

Active letters
Per-key attempts
First-attempt accuracy
Weak keys
Recent speed
Lesson history
Unlock progress

The Olivez Typing Tutor stores progress locally on the user’s device.

This means practice data does not need to be tied to an account or uploaded simply to continue learning.

Local storage is useful for:

Quick access
No sign-up requirement
Reduced collection of personal data
Returning to the same practice level later

Students should remember that locally stored progress is usually connected to the current browser and device.

Clearing site data, changing browsers, or moving to another device may reset the saved progress.

A practical typing routine for students

A productive typing session does not need to be long.

Fifteen focused minutes can be more useful than an hour of careless repetition.

Step 1: Begin slowly

Start at a pace where you can press the correct keys without rushing.

Avoid chasing WPM during the first few minutes.

Step 2: Watch first-attempt accuracy

Notice which keys cause immediate errors.

Do not treat Backspace as proof that the original movement was correct.

Step 3: Review weak keys

Look for repeated patterns.

Are mistakes concentrated on one hand?

Do you confuse neighbouring letters?

Do errors appear more often after particular key combinations?

Step 4: Practise deliberately

Keep your fingers near the home row and use the intended finger for each key.

Typing slowly with correct technique builds movements that can later become fast.

Step 5: Increase speed gradually

Once accuracy becomes stable, raise the pace slightly.

Do not double the target speed in one session.

Step 6: Stop when technique declines

Fatigue can produce sloppy movements.

A shorter session completed carefully is often more valuable than continuing after accuracy falls sharply.

A student experiment

Students can compare fixed and adaptive practice using a simple experiment.

Phase 1: Baseline test

Complete a normal typing test and record:

WPM
Final accuracy
First-attempt accuracy
Most difficult keys
Phase 2: Targeted practice

Spend several sessions practising lessons that include the weakest keys more frequently.

Phase 3: Retest

Repeat a similar typing test and compare the results.

Ask:

Did first-attempt accuracy improve?
Did the same keys remain difficult?
Did corrections decrease?
Did speed improve without reducing accuracy?
Did typing rhythm become steadier?

This turns typing practice into a measurable learning exercise rather than repeated guessing.

Common mistakes when learning touch typing
Looking at the keyboard constantly

Looking down may help find a key immediately, but it slows the development of keyboard memory.

Use the screen as the main reference and look down only when necessary.

Chasing speed too early

Fast incorrect movements are still incorrect movements.

Build accuracy first.

Using the wrong finger repeatedly

A learner may reach a reasonable speed using improvised finger movements, but those habits can create limits later.

Consistent fingering reduces unnecessary movement.

Ignoring weak keys

Repeating easy passages can feel satisfying because the score stays high.

Improvement usually requires spending more time on uncomfortable movements.

Practising for too long

Extended sessions can cause fatigue and reduced concentration.

Short, regular sessions are easier to maintain.

Try the Olivez Typing Tutor

The Olivez Typing Tutor is designed around adaptive practice rather than fixed repetition.

It tracks first-attempt performance, identifies difficult keys, adjusts lessons, and introduces new letters progressively.

You can use it here:

https://olivez.in/tool/typing-tutor

No account is required, and progress is stored locally on the device.

The goal is not simply to produce the highest WPM score possible.

The goal is to build accurate, reliable typing movements that remain stable as speed increases.

A good typing tutor should not only tell you how you performed.

It should help decide what you need to practise next.

What affects your typing most: speed, repeated key errors, or maintaining a consistent rhythm?

How a Fair Online Dice Roller Works: Probability, Randomness, and Classroom Experiments

Kaifi Azam — Tue, 04 Aug 2026 10:18:21 +0000

Rolling a die looks simple.

You click a button, watch the die move, and receive a number from 1 to 6.

Behind a reliable online dice roller, however, there are several interesting ideas involving probability, randomness, software design, and fairness.

These ideas make dice rolling a useful starting point for students learning mathematics or programming.

In this article, we will explore:

How dice probabilities work
Why short sequences can look unfair
Why rolling two dice changes the distribution
How software generates random results
How students can run their own probability experiments
How the Olivez Dice Roller handles random rolls

The probability of rolling one die

A standard six-sided die has six possible outcomes:

1, 2, 3, 4, 5, and 6

When the die is fair, each face has the same theoretical probability.

[
P(\text{specific number}) = \frac{1}{6}
]

That is approximately:

[
16.67%
]

This means the probability of rolling a 4 is exactly the same as the probability of rolling a 1.

However, this does not mean every group of six rolls will contain each number exactly once.

A sequence such as this is completely possible:

3, 3, 6, 1, 3, 5

The number 3 appeared three times, while 2 and 4 did not appear at all.

That does not prove the die is unfair. Probability describes what we expect over many trials, not what must happen in every short sequence.

Randomness often looks less balanced than expected

People naturally look for patterns.

When the same number appears repeatedly, it can feel suspicious. When a number has not appeared recently, it can feel as though it is “due.”

Neither idea changes the next independent roll.

Suppose a die produces five consecutive sixes. The probability that the next roll is also a six remains:

[
\frac{1}{6}
]

The die does not remember its previous results.

This is an example of independence. Each roll begins with the same set of possible outcomes and the same probability for each face.

The belief that a missing result becomes more likely is often called the gambler’s fallacy.

What changes when you roll two dice?

Rolling two dice creates 36 ordered combinations.

For example:

(1, 1)
(1, 2)
(1, 3)
...
(6, 5)
(6, 6)

Although each individual combination has the same probability, the totals do not.

A total of 2 has only one possible combination:

1 + 1

A total of 7 has six possible combinations:

This makes 7 the most likely total when rolling two standard dice.

Total	Number of combinations	Probability
2	1	1/36
3	2	2/36
4	3	3/36
5	4	4/36
6	5	5/36
7	6	6/36
8	5	5/36
9	4	4/36
10	3	3/36
11	2	2/36
12	1	1/36

This distribution explains why totals near the middle appear more frequently than totals near the edges.

It also gives students a clear way to compare theoretical probability with experimental results.

How an online dice roller generates results

A physical die relies on motion, gravity, surface shape, and collisions.

An online dice roller needs a source of random values from the computer.

A basic implementation might use:

Math.floor(Math.random() * 6) + 1;

This is convenient for simple demonstrations, but Math.random() is not intended for situations where stronger and less predictable randomness is preferred.

The Olivez Dice Roller uses the browser’s secure random-value API instead.

A simplified version looks like this:

const values = new Uint32Array(1);
crypto.getRandomValues(values);

This produces a random unsigned 32-bit integer.

The application must then convert that large integer into one of six possible dice values.

Why directly using the remainder can introduce bias

A tempting approach is:

const result = (randomNumber % 6) + 1;

The remainder operator maps numbers into the range 0 to 5.

The problem is that the number of possible 32-bit values is not perfectly divisible by 6.

That means some remainders could receive one additional possible source value.

The difference is extremely small, but a carefully designed dice roller can avoid it entirely.

Using rejection sampling for even mapping

Rejection sampling solves the problem by ignoring values from the small uneven section at the top of the range.

The process is:

Generate a random integer.
Check whether it falls inside the largest range evenly divisible by 6.
Reject it if it falls outside that range.
Map the accepted value to a die face.

A simplified example:

function rollDie() {
    const range = 2 ** 32;
    const limit = range - (range % 6);

    while (true) {
        const values = new Uint32Array(1);
        crypto.getRandomValues(values);

        const value = values[0];

        if (value < limit) {
            return (value % 6) + 1;
        }
    }
}

Every final face receives the same number of accepted input values.

This is more careful than a dice roller strictly needs for casual classroom use, but it makes the mapping mathematically even.

The animation does not choose the result

A common misunderstanding is that the visible dice animation determines where the die lands.

In the Olivez Dice Roller, the result is generated by the random-number logic. The animation simply communicates that a new roll is taking place.

Separating the result from the visual effect has several advantages:

Reduced motion settings can be respected
The result does not depend on frame rate
Slower devices do not produce different probabilities
The interface remains predictable and accessible

The visual design makes the roll easier to follow, while the random-generation system determines the actual value.

Probability experiment for students

Students can use an online dice roller to compare theory with real results.

Experiment 1: Roll one die 60 times

Create a table with one row for each face.

Face	Expected count	Observed count
1	10
2	10
3	10
4	10
5	10
6	10

The expected count is:

[
60 \times \frac{1}{6} = 10
]

The observed values will probably not be exactly 10 for every face.

Students can then calculate the experimental probability:

[
P(\text{face}) = \frac{\text{number of times the face appeared}}{\text{total rolls}}
]

Increasing the experiment from 60 rolls to 600 rolls will usually produce proportions closer to the theoretical probability.

Experiment 2: Roll two dice 100 times

Record the total from each roll.

Students should expect:

7 to appear frequently
6 and 8 to appear slightly less frequently
2 and 12 to appear rarely

The exact results will vary, but the overall shape should begin to resemble the theoretical distribution as the number of trials increases.

Experiment 3: Test a prediction

Before rolling, ask students to predict:

Which total will appear most often?
Will 2 or 12 appear first?
How many rolls will be needed before every total appears?
Can the same total occur five times consecutively?

The purpose is not merely to guess correctly. It is to compare intuition with evidence.

Useful applications beyond probability lessons

An online dice roller can also support:

Board games when physical dice are unavailable
Classroom turn-taking activities
Creative writing prompts
Random decision exercises
Game design testing
Statistics demonstrations
Coding lessons involving arrays, loops, and frequency counts

The Olivez Dice Roller supports between 1 and 10 six-sided dice.

It also includes keyboard controls and a fullscreen view, making it practical for classroom displays, projectors, shared screens, and group activities.

The rolls are generated locally on the user’s device. There is no account requirement and no roll history needs to be uploaded.

Try the Olivez Dice Roller

You can use the tool here:

https://olivez.in/tool/dice-roller

Choose how many dice you need, roll them, and compare the results with your probability predictions.

A dice roller may be a small tool, but it provides a useful introduction to several larger ideas:

Theoretical and experimental probability
Independent events
Random-number generation
Distribution patterns
Fair value mapping
Accessible interface design

Sometimes the simplest tools provide the clearest way to understand difficult concepts.

What result do you think would appear most often if you rolled three dice 1,000 times?

javascript #webdev #education #probability

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

Post not found or has been removed.

DEV Community: Kaifi Azam

How an Adaptive Typing Tutor Improves Accuracy Before Speed

How a Fair Online Dice Roller Works: Probability, Randomness, and Classroom Experiments

The probability of rolling one die

Randomness often looks less balanced than expected

What changes when you roll two dice?

How an online dice roller generates results

Why directly using the remainder can introduce bias

Using rejection sampling for even mapping

The animation does not choose the result

Probability experiment for students

Experiment 1: Roll one die 60 times

Experiment 2: Roll two dice 100 times

Experiment 3: Test a prediction

Useful applications beyond probability lessons

Try the Olivez Dice Roller

javascript #webdev #education #probability

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!

The `/31` exception

What does `/32` mean?