DEV Community: Jehadur Rahman (Emran)

Building NLP Tools for Languages That Big Tech Ignores

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 06:10:34 +0000

In an era where massive Large Language Models (LLMs) dominate headlines, millions of speakers of underrepresented languages remain excluded from the AI revolution. Building NLP tools for these "low-resource" languages isn't just a technical challenge; it is a necessity for democratizing technology.

Understanding the Fundamentals

To build effective tools, we must first understand the building blocks of Natural Language Processing (NLP). NLP is the field of artificial intelligence where computers analyze and derive meaning from human language. Key concepts include:

Stemming and Lemmatization: Stemming reduces words to their root format (e.g., "branching" becomes "branch"), while Lemmatization uses dictionaries to normalize words (e.g., "was" becomes "be").
Parts of Speech (POS) Tagging: The task of labeling each word with its appropriate grammatical part of speech.
Named Entity Recognition (NER): Identifying and classifying entities like names, organizations, or locations.

When dealing with languages ignored by big tech, standardized models often fail because they lack the necessary training data or linguistic nuance. This is where custom development becomes crucial.

The Python Toolkit

Python remains the language of choice for the data science community due to its versatility and mature ecosystem. When starting your project, you will likely rely on powerful packages like:

Gensim: Excellent for analyzing large textual collections and implementing algorithms like word2vec to transform text into vector features.
Scikit-learn: A library essential for tasks like classification, regression, and clustering.
NumPy: For high-level mathematical functions and matrix computations.

Getting Started: A Simple Workflow

Before diving into complex neural networks, focus on the basics of text preprocessing. Vectorization, the process of converting text into numerical representation, is a vital first step. You can implement a simple stemming process to normalize your data using NLTK:

import nltk
from nltk.stem import PorterStemmer

stemmer = PorterStemmer()
words = ["branched", "branching", "branches"]

for word in words:
    print(f"{word} -> {stemmer.stem(word)}")

Thinking Like a Designer

Writing the "right" software requires more than just code; it requires understanding the human interface. Designers of ML systems must anticipate how users will interact with the system. When building for underrepresented languages, consider:

Data Scarcity: You may not have access to massive datasets. Use techniques like transfer learning or unsupervised learning for topic modeling to extract insights from smaller document collections.
Technical Debt: Avoid poor system design that accumulates interest over time. Focus on refactoring code to ensure it remains maintainable and scalable as your project grows.
Community Engagement: Leverage open-source knowledge bases and participate in the community to gather authentic, domain-specific data.

Conclusion

Building tools for ignored languages empowers creators and developers to bridge the digital divide. By utilizing Python's robust libraries and adhering to solid software engineering principles—like test-driven development and refactoring—you can create systems that truly serve diverse linguistic populations. Start small, focus on the essentials, and build a system that reflects the unique nuances of your target language.

The Invisible 99%: Why Low-Resource Languages Need More AI Research

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 06:10:13 +0000

In the current landscape of rapid AI development, large language models (LLMs) like GPT-4 and LLaMA have become standard tools for productivity and information access. However, this technological revolution is built on a foundation of "high-resource" languages—those with abundant digital data, standardized writing systems, and significant online presence. As these models become deeply integrated into societal functions, we face an urgent, often overlooked crisis: the marginalization of low-resource languages.

Understanding the Language Divide

Of the world's over 7,000 living languages, only a tiny fraction are classified as "high-resource". Low-resource languages are those that suffer from a lack of labeled training data, poor data quality, or the absence of standardized orthography. This data scarcity creates a "long-tail distribution" in machine learning, where the majority of global languages remain underserved by modern AI technology.

The technical disparity is exacerbated by the way current AI pipelines are constructed. Most models rely on massive, internet-scraped datasets that favor dominant languages. When developers build for "scale," they often ignore the nuanced, cultural, and linguistic specificities of smaller language communities.

Why This Matters

The consequences of this digital gap extend far beyond mere convenience. We are witnessing several critical impacts:

Socio-Economic Exclusion: Language barriers impede access to essential services like quality education, healthcare, and financial tools. If AI-driven government or commercial interfaces do not function in a user's native language, they effectively cut those populations off from participating in the modern economy.
Safety and Bias Risks: Studies have shown that models like GPT-4 are significantly more likely to produce harmful or unsafe content when prompted in low-resource languages compared to high-resource ones. This occurs because safety fine-tuning and guardrails are overwhelmingly optimized for English, failing to generalize to other linguistic contexts.
Cultural and Intellectual Loss: Language is a repository of human history and cultural identity. When these languages are excluded from AI advancements, the incentive for younger generations to maintain or use them diminishes, threatening their long-term survival.

A Path Forward: Rethinking Development

To bridge this gap, the AI research community must move away from the "bigger is always better" mentality. Addressing the language gap requires dedicated, interdisciplinary collaboration rather than just brute-force data collection.

One promising avenue is the development of specialized, smaller-scale models trained on curated, high-quality datasets rather than massive, noisy web scrapes. Additionally, adopting participatory design approaches—where native speakers are involved in every stage of the AI development cycle—ensures that models are culturally representative and accurate.

For developers interested in exploring this space, evaluating model performance across diverse linguistic tiers is a critical first step. Below is a simplified conceptual example of how researchers might implement a check for data distribution parity in a training pipeline:

def evaluate_language_parity(dataset_metrics):
    # Calculate representation scores for each language
    for language, count in dataset_metrics.items():
        if count < THRESHOLD:
            flag_for_augmentation(language)
            print(f"Priority Alert: {language} is underrepresented.")
    return "Optimization required for long-tail languages."

Conclusion

The inclusion of all languages is essential for the future of global AI. As we continue to advance LLM capabilities, it is our collective responsibility to ensure that this progress does not come at the cost of linguistic diversity. By subsidizing research, supporting data stewardship, and designing methods that "do more with less," we can build a future where AI empowers, rather than excludes, communities around the world.

Conquering Complexity: Building a Robust Bangla Proofreading API

Jehadur Rahman (Emran) — Wed, 24 Jun 2026 05:57:34 +0000

Unlocking Linguistic Precision: The Technical Challenges of Building a Bangla Proofreading API

Creating an automated proofreading tool for the Bangla language is a task that sits at the intersection of complex morphology and computational linguistics. Unlike English, Bangla presents distinct challenges that require custom engineering solutions to ensure accuracy and user satisfaction.

1. The Morphological Hurdle

Bangla is an agglutinative language, where prefixes and suffixes are frequently combined with roots to alter meaning. A simple dictionary lookup will inevitably fail to catch errors in conjugated verbs or complex compound words. Developers must focus on morphological analyzers and stemming algorithms to understand the root structure of words, rather than relying on static word lists.

2. Unicode Normalization

One of the most persistent issues in Bangla NLP is the inconsistency in Unicode character representation, particularly regarding the 'hasant' (্) and various vowel signs. Different keyboards and operating systems may produce visually identical text that is encoded differently, leading to massive indexing errors. A robust API must implement a rigorous normalization layer before any processing occurs.

Consider this simple example of a normalization pipeline:

import unicodedata

def normalize_bangla_text(text):
    # Convert input to normalized Unicode form (NFC)
    return unicodedata.normalize('NFC', text)

3. Data Scarcity and Quality

While languages like English enjoy vast, curated corpora, Bangla lacks the sheer scale of high-quality, annotated datasets for training grammar checkers. Building a deep learning model often requires vast amounts of labeled 'correct vs. incorrect' text. Developers often have to rely on synthetic data generation or limited open-source resources available on platforms like Hugging Face.

4. Contextual Nuance and Ambiguity

Bangla possesses a rich vocabulary where spelling variations—such as 'ওঠো' vs 'উঠো'—can depend heavily on regional dialects or formal versus informal usage. Building an API requires an N-gram or Transformer-based model capable of analyzing sentence structure to flag context-specific errors accurately. The model must be trained not just to spot spelling mistakes, but to understand the semantic intent of the sentence.

Conclusion

Building a Bangla proofreading API is more than just coding; it is about respecting the linguistic architecture of the language. By focusing on morphological analysis and high-quality Unicode normalization, we can bridge the digital divide for Bangla speakers and provide a tool that is both functional and culturally aware.

Algorithmic Logo Design: Building Numerical Integration into the CyArm SVG

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 07:15:52 +0000

When we approach logo design as a form of systemizing, we move beyond the limitations of manual vector tools and embrace the beauty of repeatable, algorithmic truths. Creating the CyArm SVG requires us to bridge the gap between abstract mathematical functions and concrete visual output—a practice reminiscent of Feynman's approach to physics, where internalizing the problem geometry leads to the most elegant solutions.

At its core, building this logo relies on numerical integration. By calculating the path segments of our design through iterative summation, we generate complex, organic shapes that are inherently structured. This process mirrors the emergence of complex patterns from simple feedback loops, where the system dictates the form through self-stabilization.

To implement this, we can use a JavaScript function that iterates through a defined range, calculating coordinates based on a function f(x) and appending them to an SVG path string.

function generateLogoPath(f, start, end, steps) {
  const width = (end - start) / steps;
  let d = M ${start} ${f(start)};
  for (let i = 1; i <= steps; i++) {
    let x = start + (i * width);
    let y = f(x);
    d +=  L ${x} ${y};
  }
  return d;
}

This technique allows for infinite variation. By simply tweaking the underlying mathematical function, we generate a logo that is not only visually striking but also mathematically consistent. It transforms the act of design from a subjective endeavor into a precise, exploratory process of defining systems.

The Art of CSS: Rendering a Chrysanthemum using only HTML and CSS

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 06:27:25 +0000

The Art of CSS: Rendering a Chrysanthemum using only HTML and CSS

CSS art is a fascinating intersection of design and technical precision. By leveraging powerful properties like border-radius, linear-gradient, box-shadow, and transform, you can create intricate illustrations without loading a single external image file. Today, we are exploring the process of rendering a Chrysanthemum—a flower defined by its dense, rhythmic petals—using nothing but pure HTML and CSS.

The Philosophy of CSS Art

When we build with CSS, we are essentially drawing shapes. A flower is simply a collection of layered div elements and pseudo-elements. The secret to rendering a complex, organic shape like a chrysanthemum is breaking it down into basic geometric components: petals, layers, and a central core.

Constructing the Petals

The signature 'rounded teardrop' shape of a chrysanthemum petal can be achieved using border-radius combined with transform: rotate(). By carefully rotating these shapes around a central point, we can mimic the bloom pattern. Check out this snippet for a single petal:

css
.petal {
width: 50px;
height: 100px;
background: linear-gradient(to bottom, #ff0, #f90);
border-radius: 50% 50% 0 0;
position: absolute;
transform: rotate(45deg);
transform-origin: bottom center;
}

Stacking and Layering

To achieve depth, you will want to use z-index and varied opacities. A chrysanthemum has hundreds of petals. To optimize this without cluttering your HTML, use CSS pseudo-elements (::before and ::after) as much as possible. This keeps your DOM tree clean while allowing for complex layering.

For more inspiration on CSS Art, check out the community work at CodePen or CSS-Tricks.

Why Create CSS Art?

Beyond the aesthetic challenge, CSS art is an excellent way to improve your understanding of the CSS box model, positioning, and animations. It forces you to think spatially and creatively about browser rendering.

Go ahead, open your favorite code editor and see if you can manifest a floral masterpiece today!

Implementing Premium Tech Typography in CSS: A shutdownX Case Study

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 06:10:57 +0000

Typography is the backbone of user experience in modern SaaS applications. When we set out to build the interface for https://shutdownx.com, we knew that legibility and a premium "tech-first" aesthetic were non-negotiable. While managing our infrastructure via Supabase and tracking user behavior through Microsoft Clarity, we realized that typography directly influences how users interact with our data-heavy dashboards.

The Challenge of Modern Readability

In a world of high-DPI displays, "premium" doesn't just mean a nice font family—it means responsive, fluid scale. We needed a system that looked as sharp on a mobile device as it did on a wide-screen monitor. Additionally, given that we have been actively monitoring our site performance and indexing status in Google Search Console, we understood that lean CSS was critical for reducing layout shifts and improving core web vitals.

Implementing Fluid Typography

Instead of relying on rigid media queries for font sizing, we implemented fluid typography using the CSS clamp() function. This allows the font size to scale smoothly between a defined minimum and maximum range without triggering layout breakpoints.

css
:root {
  --fluid-min-width: 320px;
  --fluid-max-width: 1440px;
  --fluid-min-size: 16px;
  --fluid-max-size: 20px;
}

body {
  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  font-size: clamp(
    var(--fluid-min-size),
    calc(var(--fluid-min-size) + (var(--fluid-max-size) - var(--fluid-min-size)) * ((100vw - var(--fluid-min-width)) / (var(--fluid-max-width) - var(--fluid-min-width)))),
    var(--fluid-max-size)
  );
}

Optimizing for the "Tech" Aesthetic

A premium tech feel often relies on hierarchy and contrast. For our headers, we utilized tabular figures (font-variant-numeric: tabular-nums) to ensure that data displayed in our Supabase-backed tables remained perfectly aligned. This is crucial for financial or metrics-heavy dashboards where visual consistency equals trust.

Performance Considerations

As noted in our recent Search Console reports, indexing issues such as "Page indexed without content" or "Duplicate, Google chose different canonical than user" can be exacerbated by poor site structure. By leveraging modern CSS variables and a system-font-first approach, we reduced our external font requests, contributing to faster FCP (First Contentful Paint) times. This keeps our site lightweight and ensures search engines can parse our content hierarchy efficiently.

Key Takeaways

Use clamp() for fluid typography to eliminate excessive media queries.
Leverage system font stacks to minimize network requests and improve performance.
Use tabular-nums for data-heavy components to maintain professional alignment.
Monitor your CSS impact on site performance using tools like Microsoft Clarity to ensure that your design choices aren't negatively impacting your SEO.

Building for the web requires balancing aesthetics with technical performance. By standardizing our typography, we have not only improved the look of https://shutdownx.com but also laid a stronger, more maintainable foundation for our frontend.

Have you implemented fluid typography in your projects? Let me know your favorite techniques in the comments!

Stop Nesting: How to Optimize Your Data Mapping Performance

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 05:31:45 +0000

Why You Should Stop Using Nested Loops for Data Mapping
Nested loops are a common pitfall in software development. They appear frequently when merging datasets, filtering lists, or finding relationships between two arrays. While they might seem intuitive at first, they often lead to performance bottlenecks as your data grows.

The Problem with Nested Loops
When you nest a loop inside another, you create quadratic time complexity, represented as O(n * m) in Big O Notation. For example, if you have two lists of 1,000 items each, a nested loop will perform 1,000,000 operations.

// The Slow Approach
const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
const orders = [{ userId: 1, item: 'Book' }, { userId: 2, item: 'Pen' }];

const result = users.map(user => {
const userOrder = orders.find(order => order.userId === user.id);
return { ...user, order: userOrder };
});
In this example, for every user, the code scans the entire orders array. If the orders list contains thousands of records, your application will slow down significantly.

The Solution: Lookups and Maps
The most efficient way to solve this is to reduce the time complexity from O(n * m) to O(n). You can achieve this by transforming one of the datasets into a dictionary or a Map structure for constant-time lookup.

// The Fast Approach
const orderMap = new Map(orders.map(order => [order.userId, order]));

const result = users.map(user => ({
...user,
order: orderMap.get(user.id)
}));
By creating the orderMap first, we traverse the orders array exactly once. When we map through the users array, looking up the associated order becomes an O(1) operation.

Why This Matters

Performance: Your application remains responsive even with large datasets.
Scalability: As your product grows, your code is less likely to become a performance bottleneck.
Maintainability: Cleaner, more efficient code is easier to debug and read. By avoiding nested loops in favor of hash maps or specialized lookup structures, you ensure your software scales gracefully. Optimize your data mapping early to build robust and performant applications.

Building an Apple Mail Channel Plugin for OpenClaw

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 03:12:42 +0000

Building an Apple Mail Channel Plugin for OpenClaw

I recently built and published a plugin that integrates Apple Mail with OpenClaw (an AI automation platform), allowing AI agents to monitor and respond to emails with per-thread session isolation.

🎯 The Problem

OpenClaw and Hermes are powerful AI automation platforms, but they lacked native Apple Mail integration on macOS. Users wanted to:

Monitor multiple email accounts
Have AI agents automatically respond to emails
Maintain conversation context across email threads
Keep different email conversations isolated

💡 The Solution

I built @jehadurre/openclaw-apple-mail - a channel plugin that:

Connects to Apple Mail via AppleScript
Creates isolated sessions per email thread
Processes HTML emails intelligently
Supports multi-account configuration
Includes security features like sender allowlists

🛠️ Technical Stack

TypeScript - Type-safe development
AppleScript - Native macOS Mail.app integration
HTML Processing - DOMPurify, jsdom, sanitize-html, marked
Schema Validation - Zod for configuration validation

📦 Key Features

1. Per-Thread Session Isolation

Each email conversation gets its own isolated session, preventing context mixing:

// Each thread gets unique session ID
const sessionId = `apple-mail:${threadId}`;

2. Multi-Account Support

Configure multiple email accounts with independent settings:

{
  "channels": {
    "apple-mail": {
      "accounts": {
        "work": {
          "email": "work@company.com",
          "pollIntervalMs": 15000,
          "archiveOnReply": true
        },
        "personal": {
          "email": "personal@gmail.com",
          "pollIntervalMs": 60000
        }
      }
    }
  }
}

3. Security Features

Sender allowlist per account
HTML sanitization
AppleScript sandboxing

4. Smart HTML Processing

Automatically converts HTML emails to clean markdown:

Table extraction and conversion
Removes tracking pixels
Sanitizes malicious content
Preserves formatting for AI agents

📚 Publishing Journey

I published this plugin to multiple platforms:

1. npm Registry

npm install @jehadurre/openclaw-apple-mail

2. GitHub

Full source code
Issue tracking
Contribution guidelines
MIT License

3. ClawHub

openclaw plugins install @jehadurre/openclaw-apple-mail

4. OpenClaw Skill

Created a comprehensive setup skill:

clawhub install apple-mail-setup

The skill includes:

Installation guide
5 configuration templates
Troubleshooting solutions
Best practices

🎓 Lessons Learned

1. Compiled Output Matters

ClawHub requires compiled JavaScript, not just TypeScript source. I had to:

Get compiled output from production deployment
Include index.js in the package
Update package.json to reference the compiled file

2. Skills Enhance Adoption

Creating a separate "skill" package that teaches users how to set up and use the plugin significantly improves the user experience.

3. Multi-Platform Publishing

Publishing to npm, GitHub, ClawHub, and creating documentation on GitHub Pages maximizes discoverability.

🚀 Usage Example

Here's how users set it up:

Step 1: Install

openclaw plugins install @jehadurre/openclaw-apple-mail
clawhub install apple-mail-setup

Step 2: Configure

Add to openclaw.json:

{
  "channels": {
    "apple-mail": {
      "enabled": true,
      "accounts": {
        "personal": {
          "email": "user@example.com",
          "mailboxAccount": "iCloud",
          "allowFrom": ["*"]
        }
      }
    }
  }
}

Step 3: Start

openclaw start

That's it! OpenClaw now monitors your email and can respond automatically.

📊 Architecture

User Email → Apple Mail.app
              ↓ (AppleScript)
           Plugin Monitor
              ↓
        Session Manager (per-thread isolation)
              ↓
         HTML Processor
              ↓
        OpenClaw/Hermes AI Agent
              ↓
          Response
              ↓ (AppleScript)
        Apple Mail.app → Send Reply

🔐 Security Considerations

Sender Allowlist: Only process emails from trusted senders
HTML Sanitization: Remove malicious content from HTML emails
AppleScript Sandboxing: Limited access to Mail.app APIs
No Credential Storage: Uses existing Apple Mail accounts

🌟 Future Enhancements

Planned features:

[ ] Smart reply suggestions
[ ] Attachment handling
[ ] Email categorization
[ ] Custom email templates
[ ] Integration with other channels

📖 Resources

GitHub: https://github.com/JehadurRE/openclaw-apple-mail
npm: https://www.npmjs.com/package/@jehadurre/openclaw-apple-mail
Documentation: https://openclaw-apple-mail.jehadurre.me
Skill: clawhub install apple-mail-setup

🤝 Contributing

Contributions welcome! Check out the Contributing Guide.

💬 Feedback

Have you used AI automation with email? What features would you like to see? Let me know in the comments!

About Me: I'm Md. Jehadur Rahman (Emran), a developer passionate about AI automation and productivity tools. Find me on GitHub and my website.

License: MIT - Free to use, modify, and redistribute!

I Built a Native Apple Mail Plugin for OpenClaw

Jehadur Rahman (Emran) — Mon, 22 Jun 2026 02:45:58 +0000

If you are running an OpenClaw agent on a Mac, you probably already know the headache of trying to get your agent to read your Apple Mail inbox.

Because Apple intentionally makes iCloud Mail access difficult for third-party clients, the standard advice is usually a messy workaround: set up auto-forwarding to a Gmail account, and then use the Gmail webhook integrations to let OpenClaw read it.

I got tired of the webhook bridge, so today I built and published a native solution.

Introducing the OpenClaw Apple Mail Plugin

Instead of routing your personal emails through third-party servers, this plugin runs strictly local. It gives your OpenClaw agent the ability to directly read from your local Apple Mail database right on your Mac.

You can find the official plugin on the Clawhub registry here:
🔗 openclaw-apple-mail Plugin on Clawhub

How to get it running

Because this interacts directly with Apple's local ecosystem, there are a few permissions you need to grant macOS first (specifically Automation and full disk access for the Mail directory).

I wrote up a quick step-by-step guide to get past Apple's security prompts without pulling your hair out:
📖 Apple Mail Setup Guide

If you are running OpenClaw locally and want your agent to finally clear out your Apple Mail inbox without relying on external webhooks, give it a try. Let me know if you hit any weird edge cases with specific Mail configurations!

sample2

Jehadur Rahman (Emran) — Sat, 16 Oct 2021 00:35:00 +0000

test 2 data

sample

Jehadur Rahman (Emran) — Sat, 16 Oct 2021 00:28:12 +0000

test one