DEV Community: Homayoun Mohammadi

WinRAR’s 40-Day “Trial” That Never Ends: The Genius of Eugene Roshal

Homayoun Mohammadi — Tue, 09 Jun 2026 17:16:58 +0000

This is Eugene Roshal, the software engineer behind WinRAR.

The creator of one of the most famous "free trials" in software history.

Back in 1995, Roshal launched WinRAR with a simple 40-day trial.

Pretty normal, right?

Except there was one unusual detail.

When the trial expired...

The software didn't stop working.

No lockouts.
No disabled features.
No forced subscription.

Just a small message politely asking users to buy a license.

And millions of people clicked "Close."

Year after year.

As a result, WinRAR spread to computers all over the world.

Students used it.
Developers used it.
Office workers used it.

Many people have seen the WinRAR trial reminder hundreds if not thousands of times.

What makes the story even more interesting is that this wasn't some clever viral growth hack.

It was simply the shareware model of the time.

The software trusted users to pay if they found it valuable.

And many businesses, organizations, and professional users did.

That revenue was enough to keep the project alive for decades.

Meanwhile, WinRAR became one of the most recognizable applications in computing history.

Even today, millions of people still use it to compress, extract, and manage files.

In an industry obsessed with subscriptions, paywalls, and aggressive upselling, WinRAR became famous for doing something surprisingly simple:

It asked.

And trusted users to decide.

Scary ChatGPT Bug: AI Generates Nightmarish Images from a Simple Prompt Trick

Homayoun Mohammadi — Mon, 08 Jun 2026 20:10:03 +0000

A newly discovered glitch in ChatGPT is sending shivers down users' spines. By using a simple prompt to retrieve a non-existent image, the AI falls into a hallucination loop, generating deeply unsettling and nightmarish visuals.

Users have recently uncovered a bizarre and terrifying bug in OpenAI’s ChatGPT. When fed a basic prompt asking to retrieve an imaginary photo that was never uploaded, the AI bypasses its safety guardrails and generates horrifying, surreal images—ranging from a naked man with a fish head to armed Teletubbies.

The glitch has rapidly gone viral across social media platforms, leaving users shocked by the dark side of AI hallucinations.

What is the New ChatGPT Image Bug?

According to a report by Digital Trends, the bug exploits a loophole in how ChatGPT handles image retrieval requests. Users are sending a specific text prompt demanding the AI to "retrieve the attached image" and process it without asking any questions.

The catch? There is no attached image.

Instead of recognizing the missing file and returning a standard error message, the AI begins to hallucinate. It attempts to fulfill the prompt by generating completely random, deeply disturbing visuals. While the AI might initially resist the prompt, users have found that simply tweaking a few words allows them to bypass the system's resistance, forcing it to generate the eerie content.

The Creepiest AI Hallucinations Reported

Because the AI is essentially guessing what a "non-existent" image might be, the outputs are entirely random. However, they almost universally share a theme of emptiness, dread, and surreal horror.

Users on X (formerly Twitter) have shared some of the most unsettling outputs generated by the bug, including:

A naked man with a fish head sitting in a bathtub.
A giant rat feeding a human baby.
Familiar cartoon characters placed in deeply horrifying and violent situations.
Armed and hostage-taking Teletubbies.

Every time the prompt is run, the AI generates a completely new, unpredictable image, making the results feel like a digital game of Russian roulette with nightmare fuel.

Echoes of Google’s 2024 Pixel Studio Glitch

This unsettling phenomenon strongly echoes a major controversy from 2024 involving Google’s Pixel Studio app. During that incident, Google’s AI image generator was caught producing highly inappropriate and violent images of beloved, family-friendly characters like Mickey Mouse and SpongeBob SquarePants.

Both incidents highlight a persistent challenge in generative AI: when models are pushed into edge cases or confused by conflicting prompts, their "hallucinations" can quickly veer into disturbing territory.

Has OpenAI Responded?

As of now, there is no clear technical explanation for why this specific prompt triggers such dark and surreal hallucinations. It remains unknown whether the AI is pulling from specific dark corners of its training data or if the lack of visual context simply causes its image-generation weights to degrade into chaotic noise.

OpenAI has not yet released an official statement or acknowledged the bug. Until a patch is deployed, users are advised to avoid experimenting with the prompt, as the resulting images are highly unsettling.

Anthropic Calls for Global Pause on AI Development: Are We Losing Control?

Homayoun Mohammadi — Sat, 06 Jun 2026 18:57:43 +0000

Anthropic, the AI safety company behind the popular Claude family of models, has issued a stark warning to the tech world: it is time to temporarily halt the development of the world’s most powerful AI systems.

According to a newly released report, the rapid pace of AI advancement is producing models that show early indicators of slipping out of human control. Anthropic argues that slowing down the development of frontier AI is not just a safety precaution, but a global necessity to allow societal structures and AI alignment research to catch up.

However, the company acknowledges a massive "prisoner’s dilemma" in the tech industry. If only one company pauses, its competitors will quickly overtake it. Therefore, Anthropic is calling for a synchronized, globally verifiable pause involving major AI players, particularly in the United States and China.

The Proposal: A Coordinated Global Pause

In its report, Anthropic explicitly states:

"We believe it would be good for the world to have the option to slow down or temporarily pause the development of frontier AI, so that social structures and alignment research can adapt to the advancement of this technology."

For this pause to be effective, it cannot be a solo endeavor. Anthropic emphasizes that without a global coordination mechanism, companies and governments will be forced to make incredibly difficult security decisions amidst intense geopolitical and market pressures.

The "Nuclear Arms Control" Dilemma for AI

Anthropic draws a strong parallel between the regulation of advanced AI and historical nuclear arms control treaties. However, the company notes that managing AI will be significantly more difficult.

While it is relatively easy to spot the physical infrastructure required to build a nuclear missile via satellite imagery, hiding the training process of an AI model is incredibly easy. The temptation for a company or nation to secretly continue developing frontier AI in the shadows will be immense. To combat this, Anthropic plans to convene government officials, scientists, advocacy groups, and rival AI companies in the coming months to design a verifiable framework for an AI pause.

The Looming Threat of "Recursive Self-Improvement"

One of the most chilling sections of the report focuses on a concept known in computer science as Recursive Self-Improvement.

This refers to a scenario where an AI system can fundamentally train itself to become exponentially smarter, entirely without human assistance. While Anthropic notes that we have not yet reached this exact milestone, the company warns that it could arrive much sooner than most governments are prepared for. Current evidence suggests that human involvement in the AI development process is shrinking at an alarming rate.

Alarming Internal Data: AI is Rapidly Surpassing Humans

To illustrate how quickly the landscape is shifting, Anthropic shared staggering internal data regarding its own models:

Coding Output: With the help of Claude, Anthropic’s engineers are now shipping 8 times more code compared to the 2021–2025 period.
Complex Problem Solving: Claude’s success rate in solving open-ended, complex coding problems has reached 76%, with code quality now rivaling that of human developers.
Mythos Preview Capabilities: The new Mythos Preview model has accelerated the optimization of AI training code by a massive 52x (compared to a mere 3x improvement in 2024 models).
Research Superiority: In internal tests, Mythos Preview outperformed human researchers in research decision-making 64% of the time.

Anthropic concedes that if AI systems can successfully design their successor models, it could trigger unprecedented, positive revolutions in medicine, technology, and the economy. However, this exact capability drastically amplifies security risks and the danger of losing control.

Geopolitical Hurdles: The US, China, and the White House

Despite the clear safety warnings, Anthropic’s proposal faces fierce pushback from Silicon Valley executives and US government officials. Critics argue that Anthropic is fear-mongering, focusing on worst-case doomsday scenarios to artificially slow down competitors under the guise of "AI safety."

Furthermore, the geopolitical reality makes a global pause incredibly difficult. US officials have repeatedly argued that any slowdown in AI development risks handing a strategic technological supremacy to China.

However, there are glimmers of diplomatic progress. US President Donald Trump recently announced that during a trip to Beijing, he held discussions with Chinese leaders regarding potential cooperation on AI safety and security. Furthermore, Trump signed an executive order this week mandating a 30-day government evaluation period before the most powerful American AI models are allowed to be released to the public.

The Road Ahead

Anthropic’s call for a pause is a watershed moment in the AI safety debate. It shifts the conversation from theoretical philosophy to urgent, actionable policy. As AI models like Claude and Mythos Preview continue to break records in coding and research, the window for humanity to establish robust, verifiable guardrails is rapidly closing.

Whether the world’s leading tech giants and superpowers can agree to hit the brakes remains the most critical question of the decade.

The Lonely Programmer Who Built an Entire Operating System: Terry Davis

Homayoun Mohammadi — Thu, 04 Jun 2026 13:20:28 +0000

This is Terry A. Davis the singular mind behind TempleOS and HolyC.

A developer who didn’t just want to build software…

He wanted to understand the computer at its absolute core.

While most programmers build apps, websites, or tools, Terry spent nearly a decade building something almost unimaginable for one person:

✅ a complete 64-bit operating system

✅ a custom JIT compiler

✅ an entirely new programming language

all from scratch.

Alone.

At first, many people mocked the project.

The retro 16-color graphics.
The lack of internet connectivity.
The unconventional design.

To outsiders, it looked strange and outdated.

But underneath was one of the most astonishing feats of solo engineering in programming history.

TempleOS included:

a 3D graphics engine
a playable flight simulator
a word processor
a full development environment

all written by one man, with zero external dependencies.

Then came the darkest chapters.

Terry battled severe schizophrenia, homelessness, public breakdowns, and relentless online harassment.

For many people, the noise of his illness became louder than the brilliance of his work.

But he never stopped building.

Even during his hardest moments, he continued refining his operating system, driven by a deeply personal and uncompromising vision.

After his tragic death in 2018, the conversation began to change.

Developers started looking past the internet memes and recognizing the raw genius behind what he created.

Today, TempleOS is studied and respected worldwide as one of the most extraordinary solo software projects ever built.

Terry Davis’s story is more than programming.

It’s about obsession.
Vision.
Dedication.
And continuing to build even when nobody understands what you’re creating.

Sometimes the people who change computing the most are the ones building quietly, completely alone.

New Features Added to the Web Platform in May 2026

Homayoun Mohammadi — Tue, 02 Jun 2026 19:31:22 +0000

The web platform keeps evolving every month, and May 2026 introduced several surprisingly useful improvements across modern browsers.

New releases from:

Chrome 148
Firefox 151
Safari 26.5

brought better CSS capabilities, improved performance APIs, and new browser features that can make web apps feel more modern and efficient.

Here are some of the most interesting updates developers should know about.

1. The `:open` CSS pseudo-class is finally fully supported

One of the most practical CSS improvements this month is the :open pseudo-class becoming Baseline supported across major browsers.

This lets developers style elements based on whether they are open or closed.

Examples:

<details>
<dialog>
date pickers
color pickers
<select> dropdowns

Before this, developers often used attributes like:

details[open]

Now we can simply use:

:open

which is cleaner, easier to read, and more semantic.

This may look like a small change, but it improves maintainability in larger UI systems.

2. Container queries just became much easier to use

Container queries continue getting better.

Previously, developers had to define both:

a container name
and a container type

just to query a container.

Now browsers support name-only container queries.

Example:

#container {
  container-name: --sidebar;
}

@container --sidebar {
  .content {
    padding: 2rem;
  }
}

This removes extra setup and makes responsive component-based design much simpler.

For frontend developers working with design systems, this is a very welcome improvement.

3. CSS style queries are now supported everywhere

Firefox 151 added support for style queries using custom properties.

This means developers can now apply styles depending on CSS variables defined on parent containers.

Example:

@container style(--theme: dark) {
  .card {
    background: #1a1a1a;
    color: white;
  }
}

This opens the door for much smarter theming systems and reusable UI components.

Instead of relying heavily on JavaScript, many dynamic styling behaviors can now be handled directly in CSS.

4. Native lazy loading for video and audio

Chrome 148 introduced lazy loading support for:

<video>
<audio>

using:

loading="lazy"

This works similarly to lazy loading images.

Media files will only load when they are close to entering the viewport.

Benefits:

faster page loads
reduced bandwidth usage
better performance on mobile devices

For content-heavy websites, this can make a noticeable difference.

5. Firefox now supports the Document Picture-in-Picture API

This is one of the most interesting additions this month.

Unlike traditional Picture-in-Picture that only works for videos, the Document Picture-in-Picture API allows developers to open an always-on-top floating window containing custom HTML content.

Possible use cases:

floating music players
meeting controls
timers
stock trackers
productivity widgets

This creates opportunities for much richer multitasking experiences on the web.

6. The Web Serial API is expanding

Firefox 151 added support for the Web Serial API on desktop, while Chrome 148 added Android support.

This API allows websites to communicate with hardware devices like:

microcontrollers
Arduino boards
3D printers
embedded systems

The web platform continues moving beyond traditional websites and becoming more capable as an application platform.

Beta Features Worth Watching

Some exciting features also appeared in beta browser releases.

Chrome 149 Beta

Includes:

CSS gap decorations
improved shape-outside
Promise-based smooth scrolling APIs
better BFCache support for WebSockets

Firefox 152 Beta

Includes:

full support for field-sizing
improved Notifications API
better animation APIs

These features are not fully stable yet, but they show where modern frontend development is heading.

Final Thoughts

What makes these updates interesting is not just the number of new features.

It’s how much the web platform is improving developer experience.

Many things that previously required:

JavaScript workarounds
heavy frameworks
custom hacks

can now be done directly with modern CSS and native browser APIs.

The web keeps becoming more powerful, more performant, and more capable every month.

I Built rtl-text-tools ( A Complete RTL Text Processing Toolkit for JavaScript )

Homayoun Mohammadi — Mon, 01 Jun 2026 18:40:06 +0000

If you’ve ever worked with Arabic, Persian, Hebrew, Urdu, or any RTL (Right-to-Left) language on the web, you probably know the pain.

Mixed RTL/LTR text rendering breaks unexpectedly. Punctuation looks wrong. Numbers don’t match the locale. Ellipsis appears on the wrong side. URLs inside Arabic text become unreadable. And emails or plain-text environments completely destroy formatting.

After dealing with this problem repeatedly, I decided to build:

rtl-text-tools

A lightweight RTL text processing toolkit for JavaScript and TypeScript.

It handles:

RTL detection
Direction normalization
Arabic/Persian digit conversion
RTL punctuation conversion
Ellipsis fixing
Unicode bidi wrapping
CSS helpers
DOM helpers

And it works all the way back to IE11 with zero runtime dependencies.

Why This Exists

Most internationalization libraries focus on translations and formatting APIs.

But very few actually solve the rendering problems of RTL text itself.

For example:

"مرحبا, رقم 123..."

Visually, this often renders awkwardly in mixed-direction environments.

You usually want:

"...مرحبا، رقم ۱۲۳"

That means:

move ellipsis to the correct visual side
convert punctuation
convert digits
preserve RTL readability

That’s exactly what rtl-text-tools does.

Installation

npm install rtl-text-tools

Quick Example

import { fixRTL } from 'rtl-text-tools';

fixRTL('مرحبا, رقم 123...');
// → "...مرحبا، رقم ۱۲۳"

Arabic digits are also supported:

fixRTL('مرحبا, رقم 123...', { lang: 'arabic' });

// → "...مرحبا، رقم ١٢٣"

If the text isn’t RTL, it returns the original string unchanged:

fixRTL('Hello world');

// → "Hello world"

Features

1. RTL Detection

Detect whether text contains RTL scripts.

import { hasRTL } from 'rtl-text-tools';

hasRTL('مرحبا'); // true
hasRTL('שלום');  // true
hasRTL('Hello'); // false

Supports:

Arabic
Hebrew
Persian/Farsi
Urdu
Syriac
Thaana
N’Ko
Samaritan
Mandaic
and more

2. Digit Conversion

Convert Latin digits into locale-specific numerals.

Persian digits

import { toPersianDigits } from 'rtl-text-tools';

toPersianDigits('Price 123');

// "Price ۱۲۳"

Arabic-Indic digits

import { toArabicDigits } from 'rtl-text-tools';

toArabicDigits('Price 123');

// "Price ١٢٣"

3. RTL Punctuation Conversion

Convert standard punctuation into RTL equivalents.

import { convertPunctuation } from 'rtl-text-tools';

convertPunctuation('مرحبا, كيف حالك?');

// "مرحبا، كيف حالك؟"

Converts:

LTRRTL,،?؟;؛

4. Ellipsis Fixing

One of the most annoying RTL rendering issues.

import { moveEllipsis } from 'rtl-text-tools';

moveEllipsis('مرحبا...');

// "...مرحبا"

Also supports the Unicode ellipsis character:

moveEllipsis('مرحبا…');

// "…مرحبا"

5. Bidi Wrapping for Plain Text

CSS doesn’t exist in:

emails
terminals
textareas
logs
PDFs
some chat systems

For those environments, Unicode bidi markers are essential.

import { wrapRTL } from 'rtl-text-tools';

wrapRTL('مرحبا');

It wraps text using invisible Unicode direction control characters for reliable RTL rendering.

You can also safely embed LTR content inside RTL paragraphs:

import { wrapLTR } from 'rtl-text-tools';

wrapLTR('https://example.com');

6. React + CSS Helpers

import { getRTLStyles } from 'rtl-text-tools';

<div style={getRTLStyles()}>
  مرحبا بالعالم
</div>

Returns:

{
  direction: 'rtl',
  unicodeBidi: 'embed'
}

7. DOM Helper

import { setDirAttribute } from 'rtl-text-tools';

setDirAttribute(element, 'ar');

Outputs:

<div dir="rtl" lang="ar">

IE11 Compatibility

I intentionally made this package compatible with legacy environments.

The compiled output targets ES5:

no arrow functions
no replaceAll
no regex u flag
no modern syntax assumptions

So yes , it even works in IE11.

The Real Problem With RTL on the Web

Most developers only think about:

direction: rtl;

But RTL support is actually much deeper than that.

The difficult part is:

mixed-direction content
Unicode bidi behavior
punctuation mirroring
locale digits
inline URLs
plain-text rendering
email clients
terminals
copy/paste consistency

This package tries to solve those practical problems in one place.

Example: Mixed RTL/LTR Text

Without normalization:

من در پارکی راه می رفتم Do not Park here

The rendering can become visually confusing depending on the environment.

With normalization:

normalizeDirection(text)

The text becomes readable with proper RTL base direction.

Why Zero Dependencies?

Text utilities should be lightweight.

This package is:

dependency-free
tree-shakeable
framework-agnostic
TypeScript-friendly
browser-compatible
usable in Node.js

Open Source

The project is fully open source and contributions are welcome.

GitHub: https://github.com/homayounmmdy/rtl-text-tools

NPM: https://www.npmjs.com/package/rtl-text-tools

Final Thoughts

RTL support on the web is still surprisingly underdeveloped.

A lot of developers building multilingual products end up reinventing the same utilities repeatedly.

I wanted a small toolkit that handled the annoying RTL edge cases properly and could be dropped into any project easily.

If you work with Arabic, Persian, Hebrew, Urdu, or multilingual interfaces, I hope this package saves you some time.

Feedback, issues, and contributions are always welcome.

Modern Web Security Attacks Every Developer Must Know (2026 Guide) Clickjacking

Homayoun Mohammadi — Sun, 31 May 2026 16:38:47 +0000

Modern websites are not only about beautiful UI and animations security matters too.

One of the most common browser-based attacks is called Clickjacking.

Even frontend developers should understand it because this attack targets the UI itself.

🛡️ What is Clickjacking?

Clickjacking is a type of attack where a malicious website tricks users into clicking something they cannot see.

Usually, the attacker places your website inside an invisible <iframe> and overlays fake buttons or content on top of it.

The user thinks they are clicking one thing…

but they are actually clicking buttons on your real website underneath.

⚠️ Real Example

Imagine this:

A user visits a fake website with a “Play Video” button.

But behind that button, your banking website is loaded invisibly inside an iframe.

When the user clicks “Play Video” they might actually:

transfer money
change account settings
enable permissions
delete data

without realizing it.

🧠 Why It’s Dangerous

Clickjacking can:

trick users into performing actions
steal interactions
bypass user intention
abuse trusted websites

In some advanced cases, attackers can even capture keyboard input or sensitive interactions.

🔒 Modern Protection Methods

Modern browsers provide built-in defenses.

1. X-Frame-Options Header

This HTTP header controls whether your website can be embedded inside an iframe.

Block all framing

X-Frame-Options: DENY

Allow only your own website

X-Frame-Options: SAMEORIGIN

This is the most common option.

2. Content Security Policy (Recommended)

Today, most developers prefer using CSP.

Content-Security-Policy: frame-ancestors 'self';

This tells the browser:

“Only allow this website to be framed by itself.”

You can also allow specific domains:

Content-Security-Policy: frame-ancestors 'self' https://example.com;

⚠️ Important Note

Older browsers handled clickjacking differently.

Some legacy protections used JavaScript frame-busting techniques like this:

<script>
  if (self !== top) {
    top.location = self.location;
  }
</script>

But modern security headers are much more reliable.

✅ Best Practice

For modern applications:

Use Content-Security-Policy
Add frame-ancestors
Avoid unnecessary iframes
Protect sensitive actions with confirmation steps

Final Thoughts

Frontend security is not only the backend developer’s responsibility.

Even UI decisions can become security vulnerabilities.

Understanding attacks like Clickjacking helps developers build safer and more trustworthy web applications.

From Quiet Researcher to Programming Pioneer: Dennis Ritchie’s Lasting Legacy

Homayoun Mohammadi — Sat, 07 Feb 2026 16:56:15 +0000

Dennis Ritchie was the computer scientist who created the C programming language and co-created the Unix operating system , two innovations that shaped nearly all modern software.

In the late 1960s at Bell Labs, Ritchie worked alongside Ken Thompson on building Unix, a new operating system designed to be simple, portable, and powerful. But Unix needed a better programming language to grow.

So Ritchie created C in the early 1970s.

C allowed developers to write efficient, low-level system software while staying flexible and portable. This made it the perfect language to rewrite Unix, which helped the operating system spread across different machines , something revolutionary at the time.

C later became the foundation for many major languages including C++, Java, JavaScript, Go, and more, influencing how modern software is built.

Unix itself became the ancestor of countless systems, including Linux, macOS, iOS, and Android.

For their groundbreaking work, Ritchie and Thompson received the Turing Award (1983) and later the National Medal of Technology (1999).

Despite his massive impact, Ritchie remained a quiet figure in tech, focused more on building tools than seeking recognition.

Some of the most powerful innovations aren’t loud , they quietly become the foundation everything else is built on.

From Student Hacker to Open-Source Legend: Linus Torvalds’ Revolution

Homayoun Mohammadi — Fri, 06 Feb 2026 17:51:55 +0000

Linus Torvalds is the creator of Linux and Git, two technologies that silently power modern software development.

In 1991, while studying computer science in Finland, Torvalds started building a small operating system out of curiosity. He shared it online as a “fun project” and invited developers to contribute.

That project became Linux, which today powers most servers, cloud platforms, Android devices, and supercomputers worldwide.

But Torvalds didn’t stop there.

In 2005, frustrated with existing version control tools while managing Linux development, he created Git in just a few days. Git later became the backbone of modern software collaboration and is now used by millions of developers and platforms like GitHub.

Torvalds also faced criticism for his blunt communication style and stepped back in 2018 to improve his leadership approach before returning to guide the Linux community.

Today, his work proves one powerful idea:

When you build tools that help others create, your impact multiplies far beyond your own work.

From JavaScript Creator to Privacy Pioneer: Brendan Eich’s Comeback Story

Homayoun Mohammadi — Sat, 03 Jan 2026 11:26:28 +0000

This is Brendan Eich the visionary who created JavaScript, the language powering the modern web. But his story didn’t start with recognition.

As a teenager fascinated by math and computers, Eich obsessed over how software worked beneath the surface. That curiosity led him to study computer science and eventually join Netscape in the mid-1990s.

Then came the moment that changed the internet.

Under extreme deadline pressure, he built JavaScript in just 10 days. At first, it was mocked by developers as messy and inconsistent… even called a “toy.” But while critics doubted it, JavaScript quietly fueled the early web and never stopped growing.

Within two decades, it became one of the most widely used programming languages in the world, running browsers, servers, mobile apps, and even IoT devices.

Then came the fall.

In 2014, after becoming Mozilla’s CEO, past political donations triggered massive backlash. Amid public controversy and internal pressure, he stepped down after only two weeks. For many, that would have ended their influence in tech.

But Eich didn’t disappear.

In 2015, he co-founded Brave Software, launching the Brave browser a fast, privacy-focused alternative that blocks ads and trackers by default. Brave challenged Big Tech with a new vision: user-controlled attention and privacy-first browsing.

Today, Brave serves millions of users, supports decentralized technologies like IPFS, and integrates cryptocurrency through Brave Rewards.

Brendan Eich’s journey isn’t just about building software. It’s about resilience, reinvention, and staying true to your vision.

Even if the world pushes you out, you can still build something greater.

ByteSize Bios , Big Stories in Small Bytes

Homayoun Mohammadi — Fri, 02 Jan 2026 15:26:15 +0000

Introducing ByteSize Bios, a new series starting in 2026, where I explore the history of computing byte by byte.

In each post, I spotlight the pioneers, rebels, and visionaries who shaped code, culture, and the digital world. From forgotten geniuses to household names, these are the stories worth remembering.

Each bio is short, scannable, and meaningful

⏱️ 1-2 minutes to read
✨ No fluff. Just legacy.

Who built the first compiler?
Who fought for an open web?
Who coded in silence during wartime?

I’ll uncover the stories that shaped the digital world we live in today. 🔍

📅 First bio drops soon.

JavaScript Closures Explained in Simple Terms

Homayoun Mohammadi — Tue, 30 Dec 2025 17:31:05 +0000

Closures are one of the most important concepts in JavaScript, and understanding them makes you a stronger developer.

What Is a Closure?

A closure is:

A function that remembers and can access variables from its outer function, even after that outer function has finished running.

Think of it like a function carrying a backpack of variables wherever it goes.

Closures Explained With an ATM Example

This is one of the easiest ways to understand closures:

function createBankAccount(initialBalance) {
  let balance = initialBalance; // private money in the "vault"

  return function ATM(withdrawalAmount) {
    if (withdrawalAmount <= balance) {
      balance -= withdrawalAmount;
      console.log(`Withdrawn: $${withdrawalAmount}. Remaining: $${balance}`);
      return withdrawalAmount;
    } else {
      console.log("Insufficient funds!");
      return 0;
    }
  };
}

const myATM = createBankAccount(1000);

myATM(100); // Withdrawn: $100. Remaining: $900
myATM(500); // Withdrawn: $500. Remaining: $400
myATM(450); // Insufficient funds!

What’s happening here?

createBankAccount(1000) sets up the vault (balance)
The returned ATM() function remembers balance
Even when the outer function is done, ATM() still has access to it
That “memory” is the closure in action

How Closures Work

The outer function creates some variables

The inner function uses them

When the outer function finishes, the variables normally disappear

But if the inner function still needs them, they stay alive

This “saved scope” is called a closure

Closures give a function memory.

Why Closures Are Useful?

Closures appear everywhere in JavaScript. Here are three common uses:

1. Private Variables (Data Privacy)

Closures let you hide data so no one can access it directly.

function createCounter() {
  let count = 0;

  return {
    increment: () => ++count,
    decrement: () => --count,
    getValue: () => count
  };
}

const counter = createCounter();

console.log(counter.getValue()); // 0
counter.increment();
counter.increment();
console.log(counter.getValue()); // 2

The variable count cannot be changed from outside — it's protected.

2. Function Factories (Preset Functions)

You can create functions that remember preset values.

function createMultiplier(multiplyBy) {
  return function(number) {
    return number * multiplyBy;
  };
}

const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log(double(5)); // 10
console.log(triple(5)); // 15

Each multiplier function remembers its own value.

3. Event Handlers (UI Programming)

Each function remembers its loop index or state.

function setupButtons() {
  const buttons = document.querySelectorAll('button');

  for (let i = 0; i < buttons.length; i++) {
    buttons[i].addEventListener('click', () => {
      console.log(`Button ${i + 1} clicked!`);
    });
  }
}

Each click handler remembers its own i.

Closures in One Sentence

A closure is a function that keeps access to variables from the outer scope, even after that outer scope has finished.

Final Summary

Closures let functions remember values
They keep variables alive & protected
They are used in counters, event handlers, callbacks, modules, and more
Closures are everywhere in JavaScript once you start noticing them
They are essential for writing clean, powerful, and modern JavaScript

DEV Community: Homayoun Mohammadi

WinRAR’s 40-Day “Trial” That Never Ends: The Genius of Eugene Roshal

Scary ChatGPT Bug: AI Generates Nightmarish Images from a Simple Prompt Trick

What is the New ChatGPT Image Bug?

The Creepiest AI Hallucinations Reported

Echoes of Google’s 2024 Pixel Studio Glitch

Has OpenAI Responded?

Anthropic Calls for Global Pause on AI Development: Are We Losing Control?

The Proposal: A Coordinated Global Pause

The "Nuclear Arms Control" Dilemma for AI

The Looming Threat of "Recursive Self-Improvement"

Alarming Internal Data: AI is Rapidly Surpassing Humans

Geopolitical Hurdles: The US, China, and the White House

The Road Ahead

The Lonely Programmer Who Built an Entire Operating System: Terry Davis

Then came the darkest chapters.

New Features Added to the Web Platform in May 2026

1. The :open CSS pseudo-class is finally fully supported

2. Container queries just became much easier to use

3. CSS style queries are now supported everywhere

4. Native lazy loading for video and audio

5. Firefox now supports the Document Picture-in-Picture API

6. The Web Serial API is expanding

Beta Features Worth Watching

Chrome 149 Beta

Firefox 152 Beta

Final Thoughts

I Built rtl-text-tools ( A Complete RTL Text Processing Toolkit for JavaScript )

Why This Exists

Installation

Quick Example

Features

1. RTL Detection

2. Digit Conversion

3. RTL Punctuation Conversion

4. Ellipsis Fixing

5. Bidi Wrapping for Plain Text

6. React + CSS Helpers

7. DOM Helper

IE11 Compatibility

The Real Problem With RTL on the Web

Example: Mixed RTL/LTR Text

Why Zero Dependencies?

Open Source

Final Thoughts

Modern Web Security Attacks Every Developer Must Know (2026 Guide) Clickjacking

🛡️ What is Clickjacking?

⚠️ Real Example

🧠 Why It’s Dangerous

🔒 Modern Protection Methods

1. X-Frame-Options Header

Block all framing

Allow only your own website

2. Content Security Policy (Recommended)

⚠️ Important Note

✅ Best Practice

Final Thoughts

From Quiet Researcher to Programming Pioneer: Dennis Ritchie’s Lasting Legacy

From Student Hacker to Open-Source Legend: Linus Torvalds’ Revolution

From JavaScript Creator to Privacy Pioneer: Brendan Eich’s Comeback Story

Then came the fall.

ByteSize Bios , Big Stories in Small Bytes

JavaScript Closures Explained in Simple Terms

What Is a Closure?

Closures Explained With an ATM Example

How Closures Work

Why Closures Are Useful?

1. Private Variables (Data Privacy)

2. Function Factories (Preset Functions)

3. Event Handlers (UI Programming)

Closures in One Sentence

Final Summary

1. The `:open` CSS pseudo-class is finally fully supported