DEV Community: Ukasha Mahir

Unlocking the Power of Go: A Hands‑On Guide for Modern Developers

Ukasha Mahir — Wed, 14 Oct 2026 16:32:57 +0000

Introduction

Go (often called Golang) has been gaining momentum since its release by Google in 2009. It blends the performance of compiled languages with the simplicity of scripting languages, making it ideal for cloud services, micro‑architectures, and command‑line tools. In this post we’ll explore why Go matters, walk through a quick setup, and dive into core language features with practical code samples.

Why Choose Go?

Speed – Native compilation produces fast binaries with a tiny runtime.
Simplicity – A small, orthogonal syntax reduces cognitive load.
Concurrency – Goroutines and channels let you write safe concurrent code without the headaches of locks.
Static Typing & Tooling – The built‑in go vet, go fmt, and go test make codebases maintainable.
Cross‑Compilation – One command can target Windows, macOS, Linux, and even ARM devices.

Getting Started

Install Go from the official site or your package manager:

# macOS (Homebrew)
brew install go
# Ubuntu/Debian
sudo apt-get install golang

After installation, verify the version:

go version

You should see something like go version go1.22 linux/amd64.

Create a workspace:

mkdir -p ~/go/src/hello
cd ~/go/src/hello

Create main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Run it:

go run main.go

You’ll see Hello, Go! printed to the console.

Language Basics

Variables & Types

Go is statically typed, but you can let the compiler infer types using :=.

var explicit int = 42          // explicit type
inferred := "Go is fun!"      // type inferred as string

Control Flow

Standard if, for, switch work as you’d expect, but Go eliminates the classic while keyword. A for loop without a condition behaves like a while.

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// while‑style loop
n := 10
for n > 0 {
    fmt.Println(n)
    n--
}

Concurrency Made Easy

The hallmark of Go is its lightweight concurrency model.

Goroutines

A goroutine is a function that runs concurrently with other goroutines.

func say(message string) {
    for i := 0; i < 3; i++ {
        fmt.Println(message)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go say("goroutine 1") // runs concurrently
    say("main function")   // runs in the main goroutine
}

The go keyword launches a new goroutine. Note that the program may exit before goroutines finish; we’ll address coordination next.

Channels

Channels provide a safe way to communicate between goroutines.

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // start 3 workers
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // send jobs
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // collect results
    for a := 0; a < numJobs; a++ {
        fmt.Println("result", <-results)
    }
}

Channels block until the other side is ready, eliminating race conditions without explicit locks.

Building a Simple Web Server

Go’s standard library includes a powerful net/http package. Let’s create a tiny JSON API.

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

type Message struct {
    Text string `json:"text"`
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    msg := Message{Text: "Hello from Go!"}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(msg)
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    log.Println("Server listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Run go run server.go and visit http://localhost:8080/hello – you’ll receive {"text":"Hello from Go!"}.

Testing & Benchmarking

Go treats testing as a first‑class citizen.

package mathutil

import "testing"

func Add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5
    if got != want {
        t.Fatalf("Add(2,3) = %d; want %d", got, want)
    }
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(i, i)
    }
}

Run tests with go test ./... and benchmarks with go test -bench=..

Best Practices

Format before you commit – go fmt ./... ensures a consistent style.
Prefer interfaces over concrete types – they enable mocking and flexible APIs.
Avoid global variables – pass dependencies explicitly.
Use context for cancellation – especially in HTTP servers and long‑running goroutines.
Leverage modules – go.mod isolates dependencies and supports reproducible builds.

Conclusion

Go strikes a sweet spot between performance, developer productivity, and reliable concurrency. Its batteries‑included standard library lets you spin up web services, CLIs, and system tools with minimal ceremony. Whether you’re building microservices, data pipelines, or dev‑ops utilities, Go offers a pragmatic path to production‑grade software.

Give it a try: install the toolchain, write a few functions, and let the compiler do the heavy lifting. Happy coding!

Mastering Regular Expressions: From Basics to Advanced Patterns

Ukasha Mahir — Wed, 14 Oct 2026 16:32:28 +0000

Mastering Regular Expressions: From Basics to Advanced Patterns

Regular expressions (often abbreviated as regex or regexp) are a powerful tool for searching, validating, and transforming text. Whether you are cleaning CSV files, building a syntax highlighter, or writing a URL router, a solid grasp of regex can dramatically reduce boilerplate code and improve readability. In this post we’ll explore the fundamentals, dive into intermediate techniques, and finish with a few advanced tricks that can make you feel like a regex wizard.

Why Regex?

At its core a regular expression is a pattern that describes a set of strings. The pattern language is compact yet expressive, allowing you to express complex matching rules in a single line of code. Compare these two snippets that extract email addresses from a block of text:

# Without regex (naïve approach)
import re
text = "Contact us at alice@example.com or bob@domain.org"
words = text.split()
emails = []
for w in words:
    if "@" in w and "." in w:
        emails.append(w.strip('.,'))
print(emails)

# With regex (concise and robust)
import re
text = "Contact us at alice@example.com or bob@domain.org"
pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
emails = re.findall(pattern, text)
print(emails)

The regex version is shorter, handles edge cases (multiple dots, hyphens, plus signs) and is far easier to maintain. That is the primary promise of regex: expressive power with minimal code.

The Building Blocks

Literals and Metacharacters

A literal matches itself – the character a matches the character a. Metacharacters give regex its special abilities. Some of the most common ones are:

. – matches any character except a newline.
^ – asserts the start of a line.
$ – asserts the end of a line.
* – matches zero or more of the preceding token.
+ – matches one or more of the preceding token.
? – makes the preceding token optional (zero or one).
| – logical OR between two alternatives.
[] – character class, matches any one character inside the brackets.
() – grouping, also captures the matched substring.

Quantifiers in Detail

Quantifiers can be greedy (the default) or lazy (non‑greedy). Greedy quantifiers consume as much text as possible while still allowing the overall pattern to match. Append a ? to make them lazy.

# Greedy vs lazy
"<div>First</div><div>Second</div>"
# Greedy: <.*>
#   matches the whole string: <div>First</div><div>Second</div>
# Lazy: <.*?>
#   matches only the first tag: <div>

Character Classes

Character classes let you match a set of characters.

[0-9]      # any digit
[abc]      # a, b, or c
[^xyz]     # any character except x, y, z (negated class)
[\w\-]    # word characters or hyphen

You can also define ranges: [a-f] matches a through f. Combining ranges and literals is common: [A-Za-z0-9_] is equivalent to \w.

Practical Examples

1. Validating an IPv4 Address

import re
ipv4_pattern = r"^((25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)$"

def is_ipv4(addr):
    return bool(re.match(ipv4_pattern, addr))

print(is_ipv4('192.168.0.1'))   # True
print(is_ipv4('256.0.0.1'))    # False

The pattern breaks down as:

25[0-5] matches 250‑255
2[0-4]\d matches 200‑249
1\d{2} matches 100‑199
[1-9]?\d matches 0‑99 (no leading zero unless the whole number is zero)
The whole group is repeated three times followed by the final octet.

2. Extracting Hashtags from a Tweet

import re
text = "Loving the new features in #Python3.10! #regex #devcommunity"
hashtags = re.findall(r"#\w+", text)
print(hashtags)  # ['#Python3', '#regex', '#devcommunity']

\w+ matches one or more word characters (letters, digits, underscore). The leading # is outside the character class to keep it part of the match.

3. Reformatting Dates (MM/DD/YYYY → YYYY‑MM‑DD)

import re
raw = "Report generated on 04/15/2023."
converted = re.sub(r"(\d{2})/(\d{2})/(\d{4})", r"\3-\1-\2", raw)
print(converted)  # Report generated on 2023-04-15.

The pattern captures month, day, and year in three groups. The replacement string rearranges them using backreferences (\1, \2, \3).

Intermediate Techniques

Lookahead and Lookbehind

Lookarounds let you assert context without consuming characters.

Positive lookahead (?=…) – the following text must match.
Negative lookahead (?!…) – the following text must not match.
Positive lookbehind (?<=…) – the preceding text must match.
Negative lookbehind (?<!…) – the preceding text must not match.

# Find a digit that is *not* followed by another digit
\d(?!\d)
# Match "cat" only when it is preceded by "black "
(?<=black )cat

Named Capture Groups

Instead of numeric backreferences, you can give groups meaningful names, which improves readability.

import re
pattern = r"(?P<area>\d{3})-(?P<exchange>\d{3})-(?P<number>\d{4})"
match = re.search(pattern, "Call 415-555-1234 now")
print(match.groupdict())  # {'area': '415', 'exchange': '555', 'number': '1234'}

Conditional Expressions (PCRE/PCRE‑like engines)

Some flavors support conditionals based on whether a group has participated.

# If group 1 matched, use \d+, otherwise use \w+
^(?:(\d+)|(\w+))$\n(?(1)\d+|\w+)

While not universally supported, this can simplify patterns that would otherwise require separate branches.

Advanced Tricks

1. Recursive Patterns (PCRE, Ruby, .NET)

Recursive regex lets you match nested structures such as balanced parentheses.

# PCRE syntax – matches balanced parentheses of any depth
\((?:[^()]*|(?R))*\)

(?R) invokes the entire pattern recursively. This is extremely useful for parsing simple expression languages without a full parser.

2. Atomic Groups and Possessive Quantifiers

Atomic groups ((?>…)) and possessive quantifiers (*+, ++, ?+) prevent backtracking, which can dramatically improve performance on pathological inputs.

# Catastrophic backtracking example
(.*a){2}
# Adding an atomic group solves it
(?>.*a){2}

3. Unicode Property Escapes

Modern engines (JavaScript, Python 3.7+, .NET) support \p{...} to match characters by Unicode properties.

# Match any emoji (simplified)
\p{Emoji_Presentation}
# Match any letter from any script
\p{L}

These escapes make internationalization far easier than manually enumerating ranges.

Common Pitfalls and How to Avoid Them

Over‑greedy quantifiers – Always test with edge cases. Adding ? to make quantifiers lazy often fixes unexpected captures.
Escaping metacharacters – If you need to match a literal dot, use \.; forgetting to escape leads to silent bugs.
Performance – Complex alternations (a|ab|abc) can cause backtracking explosions. Prefer longer literals first or use atomic groups.
Readability – A single monstrous regex is hard to maintain. Break it into named groups or compose multiple simpler regexes.

Tooling Tips

Regex101.com – Interactive editor with real‑time explanation, debugger, and flavor selector.
RexEgg.com – Great reference for advanced features and cross‑engine quirks.
VS Code – Built‑in search supports PCRE‑compatible syntax and shows matches inline.
Python's regex module – A drop‑in replacement for re that adds recursive patterns, fuzzy matching, and full Unicode support.

Closing Thoughts

Regular expressions are a double‑edged sword: they can condense weeks of string‑manipulation code into a few lines, but they can also become unreadable if abused. The key is balance – start with a clear specification, write a small pattern, add tests, and refactor using named groups or helper functions when complexity grows.

With the fundamentals covered, you now have a toolbox that includes:

Basic literals, character classes, and quantifiers.
Lookarounds, named groups, and conditional logic.
Advanced recursion, atomic groups, and Unicode properties.

Apply these techniques to your next project, and you’ll find that tasks like validation, extraction, and transformation become dramatically smoother. Happy pattern crafting!

Supercharging Your JavaScript Projects: A Deep Dive into TypeScript

Ukasha Mahir — Wed, 14 Oct 2026 03:57:03 +0000

Introduction

If you’ve been building JavaScript applications for a while, you’ve probably run into the classic "It works on my machine" debugging nightmare. Dynamic typing gives you flexibility, but it also leaves you vulnerable to subtle runtime errors that can surface weeks after deployment. Enter TypeScript – a statically‑typed superset of JavaScript that compiles down to clean, standards‑compliant ES code. In this post we’ll explore why TypeScript has become the de‑facto choice for modern web development, walk through its core features, and sprinkle in practical code samples you can copy‑paste into your own projects.

Why TypeScript?

Early‑catch errors – The compiler spots type mismatches before you even run the code.
Self‑documenting APIs – Types serve as living documentation, improving onboarding and code reviews.
Tooling power‑ups – IDEs like VS Code provide autocompletion, refactoring, and inline docs based on type information.
Gradual adoption – You can add TypeScript to an existing JavaScript codebase file‑by‑file, thanks to its optional typing system.
Future‑proof syntax – TypeScript implements upcoming ECMAScript proposals early, letting you use features like optional chaining (?.) and nullish coalescing (??) today.

Setting Up a TypeScript Project

# 1️⃣ Initialize npm (if you haven’t already)
npm init -y

# 2️⃣ Install TypeScript as a dev dependency
npm install --save-dev typescript

# 3️⃣ Generate a default tsconfig.json
npx tsc --init

The generated tsconfig.json is the heart of your compilation pipeline. Here’s a minimal but opinionated configuration for a Node + React stack:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "Node",
    "strict": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "skipLibCheck": true,
    "jsx": "react-jsx",
    "outDir": "dist"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Pro tip: Enable "noImplicitAny": true (part of strict) to force you to annotate ambiguous values instead of silently falling back to any.

Basic Types and Interfaces

TypeScript’s type system starts simple:

// Primitive types
let id: number = 42;
let username: string = "alice";
let active: boolean = true;

// Arrays & tuples
let scores: number[] = [10, 20, 30];
let point: [number, number] = [10, 20]; // fixed‑length tuple

Interfaces – Shaping Objects

Interfaces let you describe the shape of objects, making them perfect for API contracts.

interface User {
  id: number;
  name: string;
  email?: string; // optional property
  roles: Role[];
}

enum Role {
  ADMIN = "admin",
  USER = "user",
}

const bob: User = {
  id: 1,
  name: "Bob",
  roles: [Role.USER]
};

If you try to assign a property that isn’t in the interface, the compiler will scream:

// ❌ Error – 'age' does not exist in type 'User'
const invalidUser: User = { id: 2, name: "Eve", age: 30, roles: [] };

Advanced Types: Union, Intersection, and Generics

Union Types

A variable can hold one of several types.

function formatId(id: number | string): string {
  return id.toString().padStart(8, "0");
}

Intersection Types

Combine multiple types into one.

interface Timestamped {
  createdAt: Date;
  updatedAt: Date;
}

type Post = User & Timestamped & {
  title: string;
  content: string;
};

Generics – Write Reusable, Type‑Safe Code

function mapArray<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}

const numbers = [1, 2, 3];
const strings = mapArray(numbers, n => n.toString()); // inferred as string[]

Generics become especially powerful when building data‑access layers, UI component libraries, or utility functions.

Practical Example: A Typed Fetch Wrapper

Most real‑world apps talk to REST APIs. Let’s craft a tiny wrapper that infers response types.

// src/api.ts
export async function apiGet<T>(url: string, init?: RequestInit): Promise<T> {
  const response = await fetch(url, { method: "GET", ...init });
  if (!response.ok) {
    const err = await response.text();
    throw new Error(`GET ${url} failed: ${err}`);
  }
  const data = (await response.json()) as T;
  return data;
}

Usage with a concrete interface:

interface Todo {
  userId: number;
  id: number;
  title: string;
  completed: boolean;
}

async function loadTodos() {
  const todos = await apiGet<Todo[]>("https://jsonplaceholder.typicode.com/todos?_limit=5");
  console.log(todos[0].title); // ✅ Type‑safe, autocomplete works
}

loadTodos();

If the API contract changes, the compiler will flag mismatches wherever Todo is used, preventing subtle bugs.

Working with React & TypeScript

React’s JSX syntax already aligns well with TypeScript because components are just functions returning JSX. Here’s a simple typed component:

// src/components/Counter.tsx
import { useState } from "react";

interface CounterProps {
  start?: number; // optional prop with a default value
}

export const Counter: React.FC<CounterProps> = ({ start = 0 }) => {
  const [count, setCount] = useState<number>(start);

  return (
    <div>
      <p>Current count: {count}</p>
      <button onClick={() => setCount(c => c + 1)}>Increment</button>
    </div>
  );
};

Notice the explicit <number> generic on useState. Without it, TypeScript would infer number from the initial value, but adding the generic protects you when you later call setCount("oops") – the compiler will error.

Common Pitfalls & How to Avoid Them

Pitfall	Symptom	Fix
Implicit `any`	Variable appears as `any` in IDE, no compile‑time safety	Enable `noImplicitAny` (part of `strict`)
Overly‑broad types (`any`, `unknown`)	You lose the benefits of static typing	Prefer `unknown` for external data, then narrow with type guards
Forgetting to `export` types	Import errors, duplicated interfaces	Keep a dedicated `types/` folder and export from an index file
Mis‑aligned `tsconfig` and build tool	Types compile but runtime fails (e.g., missing polyfills)	Align `target`/`module` with your bundler (Webpack, Vite, etc.)

Debugging Type Errors – The “Why?” Mindset

When the compiler throws TS2322: Type 'X' is not assignable to type 'Y', ask yourself:

Is the source type too narrow? – Perhaps you need a union (string | number).
Am I missing an optional property? – Add ? or provide a default.
Do I need a type guard? – Narrow the type inside a conditional.

Example of a guard:

function isUser(obj: unknown): obj is User {
  return (
    typeof obj === "object" &&
    obj !== null &&
    "id" in obj &&
    "name" in obj &&
    typeof (obj as any).id === "number"
  );
}

const data: unknown = await apiGet<any>("/profile");
if (isUser(data)) {
  console.log(data.name); // ✅ safe access
}

Deploying TypeScript – From Dev to Production

Compile with --sourceMap – Keeps stack traces readable.
Run tsc --noEmit in CI – Guarantees type safety before merge.
Tree‑shake with bundlers – Modern bundlers drop unused code even after compilation.
Monitor runtime errors – Tools like Sentry still matter; type safety isn’t a silver bullet.

Conclusion

TypeScript is more than a “type checker” – it’s a productivity catalyst that scales with your codebase. By introducing static types, you gain early error detection, richer IDE support, and clearer contracts between modules. The learning curve is modest, especially if you start with any‑free strict mode and gradually annotate the most critical parts of your app. Once you’ve experienced the confidence boost of catching bugs at compile‑time, going back to plain JavaScript will feel… well, risky.

Ready to give TypeScript a spin? Install it, enable strict, and start refactoring a single file today. Your future self (and your teammates) will thank you.

Happy coding!

Rust in 2024: Why This Systems Language Is the Future of Safe, Fast Development

Ukasha Mahir — Wed, 14 Oct 2026 03:51:00 +0000

Introduction

Rust has quietly become the darling of systems programming, and 2024 is the year it steps into the mainstream. From embedded devices to cloud services, developers are choosing Rust for its unique blend of performance, memory safety, and modern tooling. In this post we’ll explore why Rust is worth learning today, walk through a few idiomatic code examples, and point you to resources that can accelerate your journey.

1. Memory Safety Without a Garbage Collector

One of Rust’s headline features is its ownership model. Unlike C/C++, Rust guarantees that references are always valid at compile time, eliminating use‑after‑free and data races.

fn main() {
    let mut v = vec![1, 2, 3];
    // Borrow v immutably to compute a sum
    let sum: i32 = v.iter().sum();
    println!("Sum: {}", sum);

    // Borrow v mutably to modify it
    for x in &mut v {
        *x *= 2;
    }
    println!("Doubled: {:?}", v);
}

The compiler checks that the immutable borrow (v.iter()) ends before the mutable borrow (&mut v). If you try to mix them, you’ll get a clear compile‑time error.

2. Zero‑Cost Abstractions

Rust’s abstractions compile down to the same machine code you’d write by hand in C. Traits, iterators, and async/await are all “zero‑cost” – you pay only for what you use.

fn fibonacci(limit: usize) -> Vec<u64> {
    (0..limit)
        .scan((0u64, 1u64), |state, _| {
            let next = state.0;
            *state = (state.1, state.0 + state.1);
            Some(next)
        })
        .collect()
}

fn main() {
    println!("{:?}", fibonacci(10));
}

The scan iterator builds the Fibonacci sequence lazily, yet the generated assembly is as efficient as a hand‑rolled loop.

3. Concurrency Made Easy

Because the borrow checker knows which threads own which data, writing safe concurrent code is straightforward.

use std::sync::Arc;
use std::thread;

fn parallel_sum(data: &[i32]) -> i32 {
    let chunk_size = data.len() / 4;
    let data = Arc::new(data.to_vec());
    let mut handles = Vec::new();

    for i in 0..4 {
        let slice = Arc::clone(&data);
        let start = i * chunk_size;
        let end = if i == 3 { slice.len() } else { start + chunk_size };
        handles.push(thread::spawn(move || {
            slice[start..end].iter().copied().sum::<i32>()
        }));
    }

    handles.into_iter().map(|h| h.join().unwrap()).sum()
}

fn main() {
    let nums: Vec<i32> = (1..=1000).collect();
    println!("Parallel sum: {}", parallel_sum(&nums));
}

No unsafe blocks, no data races – the compiler guarantees that each thread works on a distinct slice.

4. Tooling That Boosts Productivity

Cargo – the built‑in package manager handles dependencies, builds, and tests with a single command.
rustfmt – automatically formats code to the community style guide.
Clippy – a linter that catches common mistakes and suggests idiomatic alternatives.
rust-analyzer – a language server that provides instant diagnostics, refactorings, and in‑editor documentation.

Running cargo new hello_rust && cd hello_rust && cargo run gives you a working project in seconds.

5. A Growing Ecosystem

The crates.io registry now hosts over 100k libraries. Whether you need a web framework (actix-web, warp), a database driver (sqlx, diesel), or a game engine (bevy), there’s a crate ready for you. The community also maintains excellent documentation, tutorials, and a Discord channel where newcomers get fast help.

6. Real‑World Success Stories

Mozilla – continues to power components of Firefox.
Amazon Web Services – uses Rust for performance‑critical services like Firecracker.
Dropbox – rewrote parts of its sync engine in Rust, seeing a 30 % latency reduction.
Microsoft – integrated Rust into Windows drivers to mitigate memory safety bugs.

These adopters prove that Rust scales from tiny microcontrollers to massive cloud workloads.

7. Getting Started: A Mini Project

Let’s build a tiny command‑line utility that reads a CSV file, filters rows, and writes JSON. This showcases file I/O, error handling, and third‑party crates.

use std::error::Error;
use std::fs::File;
use std::io::{BufReader, BufWriter};

use csv::Reader;
use serde::Serialize;
use serde_json::to_writer_pretty;

#[derive(Debug, Serialize)]
struct Record {
    name: String,
    age: u8,
    city: String,
}

fn filter_age(path: &str, min_age: u8) -> Result<(), Box<dyn Error>> {
    let file = File::open(path)?;
    let mut rdr = Reader::from_reader(BufReader::new(file));
    let out = File::create("filtered.json")?;
    let mut writer = BufWriter::new(out);

    let mut results = Vec::new();
    for result in rdr.deserialize() {
        let rec: Record = result?;
        if rec.age >= min_age {
            results.push(rec);
        }
    }
    to_writer_pretty(&mut writer, &results)?;
    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
    filter_age("people.csv", 30)?;
    println!("Filtered data written to filtered.json");
    Ok(())
}

Add the dependencies to Cargo.toml:

[dependencies]
csv = "1.1"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Compile with cargo run. The example demonstrates how Rust’s strong type system and explicit error handling make data pipelines robust and easy to reason about.

Conclusion

Rust isn’t a niche language anymore; it’s a pragmatic choice for anyone building fast, reliable software. Its compile‑time guarantees, zero‑cost abstractions, and vibrant ecosystem lower the barrier to writing safe code at scale. If you haven’t tried Rust yet, pick a small project, follow the official "The Book", and let the compiler guide you toward a new way of thinking about ownership and concurrency.

Happy coding!

Unlocking Android Power: A Deep Dive into Termux for Mobile Development

Ukasha Mahir — Wed, 14 Oct 2026 03:50:32 +0000

Introduction

Termux is a terminal emulator and Linux environment that runs on Android without rooting. It gives you access to a powerful package manager (pkg), a full Bash shell, and a curated collection of Linux tools—all from your phone or tablet. For developers, Termux turns a mobile device into a portable dev workstation: you can write scripts, run Python or Node.js, compile C programs, manage Git repos, and even SSH into remote servers.

Getting Started

Installation

Open the Google Play Store or F-Droid and install the Termux app.
Launch Termux. The first run will populate the $HOME directory and set up the default package repositories.
Update the package index:

apt update && apt upgrade -y

Tip: Use apt or its wrapper pkg interchangeably; pkg adds colour and shortcuts.

Core Package Management

Termux uses the same apt backend as Debian/Ubuntu, but packages are compiled for Android's ARM or x86_64 architectures.

Installing Common Tools

pkg install git python nodejs curl wget neovim tmux openssh

git – version control
python – scripting and data work
nodejs – JavaScript runtime
neovim – lightweight editor
tmux – terminal multiplexer for persistent sessions
openssh – SSH client/server

Searching and Removing

pkg search <keyword>
pkg uninstall <package>

All packages live under $PREFIX, which resolves to /data/data/com.termux/files/usr.

Writing Your First Script

Create a file called hello.sh:

echo "#!/data/data/com.termux/files/usr/bin/bash" > hello.sh
chmod +x hello.sh
cat >> hello.sh <<'EOF'
echo "Hello from Termux!"
EOF
./hello.sh

The shebang points to the Bash binary inside Termux, ensuring the script runs regardless of the Android shell.

Python Development

Termux’s Python package ships with pip. Install a virtual environment to keep dependencies tidy:

pip install --upgrade pip setuptools wheel
pip install virtualenv
virtualenv venv
source venv/bin/activate
pip install requests beautifulsoup4

Now you can write a quick scraper:

cat > scraper.py <<'PY'
import requests, bs4, sys
url = sys.argv[1]
resp = requests.get(url)
soup = bs4.BeautifulSoup(resp.text, 'html.parser')
print(soup.title.string)
PY
python scraper.py https://dev.to

All of this runs on a phone with the same speed you’d expect from a low‑end laptop.

Node.js and npm

Node.js works out of the box. Install a project globally or locally:

npm init -y
npm install express
cat > index.js <<'JS'
const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Hello from Termux!'));
app.listen(3000, () => console.log('Listening on 3000'));
JS
node index.js &

You can reach the server from the same device via http://127.0.0.1:3000 or from another device on the same Wi‑Fi network using the phone’s IP address.

Using SSH

As a Client

ssh user@remote-host.com

The first time you connect, accept the host key and you’re in.

As a Server

apt install openssh
passwd   # set a password for the Termux user
sshd

Find your device’s IP with ip addr show wlan0. Then from a laptop:

ssh $(whoami)@<phone-ip>

You now have a full remote shell on your Android device.

Persistent Sessions with tmux

tmux lets you detach from a session and re‑attach later, perfect for long builds or monitoring logs.

tmux new -s dev
# work inside the session
Ctrl‑b d   # detach
tmux attach -t dev   # re‑attach

Even if Termux is killed in the background, the tmux server stays alive as long as the process isn’t killed.

GUI Apps via XServer XSDL

Termux can launch X11 programs that display on an external X server app like XServer XSDL.

Install XServer XSDL from the Play Store.
In Termux, set the display:

export DISPLAY=:0
apt install x11-repo
pkg install xorg-xhost xfce4-terminal

Start XSDL, note the display number (usually :0), then launch a GUI app:

xfce4-terminal &

You now have a full desktop‑style terminal on your phone screen.

Advanced Tips & Tricks

Storage Access: Run termux-setup-storage to create a ~/storage symlink to shared media directories (Downloads, DCIM, etc.).
Git Credential Helper: Cache your credentials for faster pushes:

git config --global credential.helper 'cache --timeout=3600'

Compile Native Code: Install clang and make to build C/C++ projects directly on the device:

pkg install clang make

Battery Optimizations: Add Termux to the Battery optimization whitelist, otherwise Android may kill the process when the screen is off.
Backup Packages: Export the list of installed packages with:

dpkg --get-selections > pkg-list.txt

Later, restore with dpkg --set-selections < pkg-list.txt && apt-get dselect-upgrade.

Real‑World Use Cases

On‑the‑Go CI Runner – Use Termux to run lightweight CI jobs (e.g., linting, unit tests) while commuting.
Network Diagnostics – Tools like nmap, tcpdump, and wireshark (via tshark) work directly on the mobile network interface.
Learning Linux – Students can practice Bash scripting without a dedicated laptop.
Remote Development – Pair Termux with VS Code’s Remote SSH extension to edit files on your phone from a desktop IDE.

Conclusion

Termux bridges the gap between mobile and desktop development. By leveraging a familiar Debian‑style package manager, a full Bash environment, and support for languages like Python, Node.js, and C, you can turn any Android device into a capable dev workstation. Whether you’re debugging on a remote site, need a quick scripting sandbox, or want to run a persistent SSH server, Termux has you covered. Install it, explore the packages, and start hacking on the go – the only limit is your imagination.

Mastering Modern JavaScript: From ES6 to Async Patterns

Ukasha Mahir — Wed, 14 Oct 2026 03:45:36 +0000

Introduction

JavaScript has evolved dramatically since the early days of alert('Hello World'). Today's JavaScript powers everything from tiny widgets to massive server‑side applications, thanks to ECMAScript 6 (ES6) and the ecosystem that grew around it. In this post we’ll walk through the most impactful language features introduced in the last decade, show how they simplify real‑world code, and explore async patterns that every modern developer should master.

1. Let, Const, and Block Scope

Before ES6, var was the only way to declare variables, leading to hoisting surprises.

function legacyScope() {
  var i = 0;
  for (var i = 0; i < 3; i++) {
    // i is function‑scoped, not block‑scoped
  }
  console.log(i); // 3, not 0
}

let and const fix that:

function blockScope() {
  const arr = [];
  for (let i = 0; i < 3; i++) {
    arr.push(i);
  }
  // console.log(i); // ReferenceError: i is not defined
  return arr;
}

let – mutable, block‑scoped.
const – immutable binding, block‑scoped. The value can still be mutable if it’s an object.

2. Arrow Functions and Lexical `this`

Arrow functions give you a concise syntax and capture the surrounding this value.

// Traditional callback
setTimeout(function() {
  console.log(this); // Window (or undefined in strict mode)
}, 1000);

// Arrow version – inherits lexical this
class Timer {
  constructor() {
    this.start = Date.now();
  }
  log() {
    setTimeout(() => {
      console.log('Elapsed:', Date.now() - this.start);
    }, 1000);
  }
}
new Timer().log();

Because the arrow function does not create its own this, you avoid the common var self = this pattern.

3. Template Literals

String interpolation, multi‑line strings, and embedded expressions are now a breeze.

const user = { name: 'Ada', points: 42 };
const message = `
  Hello ${user.name}!
  You have earned ${user.points} points.
  Keep it up!
`;
console.log(message);

No more cumbersome concatenation or \n escapes.

4. Destructuring & Rest/Spread

Pull values out of arrays or objects directly in the declaration.

// Array destructuring
const [first, second, ...rest] = [10, 20, 30, 40];
// Object destructuring with renaming
const { title: postTitle, author = 'Anonymous' } = { title: 'JS Tips' };

Rest (...rest) gathers the remaining items, while spread (...obj) expands them:

const defaults = { theme: 'light', layout: 'grid' };
const userPrefs = { layout: 'list' };
const config = { ...defaults, ...userPrefs }; // { theme: 'light', layout: 'list' }

5. Modules (ESM)

Node.js and browsers now support native ES modules (import/export).

// utils.mjs
export function sum(a, b) {
  return a + b;
}
export const PI = Math.PI;

// app.mjs
import { sum, PI } from './utils.mjs';
console.log(`Area of circle: ${PI * sum(3, 4)}`);

No more bundler‑only require/module.exports—you can write clean, tree‑shakable code directly.

6. Classes & Inheritance

Classes are syntactic sugar over prototypal inheritance, making OOP feel familiar.

class Shape {
  constructor(name) {
    this.name = name;
  }
  area() {
    throw new Error('area() must be implemented');
  }
}

class Circle extends Shape {
  constructor(radius) {
    super('circle');
    this.radius = radius;
  }
  area() {
    return Math.PI * this.radius ** 2;
  }
}

const c = new Circle(5);
console.log(`${c.name} area = ${c.area().toFixed(2)}`);

Static methods, getters/setters, and private fields (#value) are also part of the class spec.

7. Async/Await – Writing Asynchronous Code Like Synchronous Code

Promises turned callback hell into manageable chains, but async/await makes the flow even clearer.

async function fetchUser(id) {
  const response = await fetch(`https://api.example.com/users/${id}`);
  if (!response.ok) throw new Error('Network error');
  const user = await response.json();
  return user;
}

(async () => {
  try {
    const alice = await fetchUser(1);
    console.log('User:', alice);
  } catch (e) {
    console.error(e);
  }
})();

7.1 Parallel Execution with `Promise.all`

When tasks are independent, run them concurrently:

async function loadDashboard() {
  const [stats, recent, alerts] = await Promise.all([
    fetch('/api/stats').then(r => r.json()),
    fetch('/api/recent').then(r => r.json()),
    fetch('/api/alerts').then(r => r.json())
  ]);
  return { stats, recent, alerts };
}

7.2 Cancelable Fetches (AbortController)

Modern APIs let you abort long‑running requests:

async function fetchWithTimeout(url, ms) {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), ms);
  try {
    const resp = await fetch(url, { signal: controller.signal });
    return await resp.json();
  } finally {
    clearTimeout(timeout);
  }
}

8. Optional Chaining & Nullish Coalescing

Safely access deep properties without repetitive guards.

const config = { db: { host: 'localhost' } };
const port = config.db?.port ?? 5432; // 5432 if undefined or null

The ?. operator short‑circuits when a value is null/undefined, while ?? only falls back on nullish values (not 0 or '').

9. TypeScript Integration (A Quick Note)

While this post focuses on vanilla JavaScript, most production teams pair it with TypeScript for static typing. The features we covered today map one‑to‑one in TS, giving you compile‑time safety without sacrificing runtime performance.

10. Putting It All Together – A Real‑World Mini‑Project

Let’s build a tiny Todo API client using the modern features we’ve discussed.

// todoClient.mjs
export class TodoClient {
  #baseUrl;
  constructor(baseUrl) {
    this.#baseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
  }

  async #request(path, options = {}) {
    const url = `${this.#baseUrl}${path}`;
    const resp = await fetch(url, { headers: { 'Content-Type': 'application/json' }, ...options });
    if (!resp.ok) {
      const err = await resp.text();
      throw new Error(`HTTP ${resp.status}: ${err}`);
    }
    return resp.json();
  }

  getAll() {
    return this.#request('/todos');
  }

  add(todo) {
    return this.#request('/todos', { method: 'POST', body: JSON.stringify(todo) });
  }

  delete(id) {
    return this.#request(`/todos/${id}`, { method: 'DELETE' });
  }
}

// usage.mjs
import { TodoClient } from './todoClient.mjs';

(async () => {
  const api = new TodoClient('https://jsonplaceholder.typicode.com');
  const todos = await api.getAll();
  console.log('First 3 todos:', todos.slice(0, 3));

  const newTodo = await api.add({ userId: 1, title: 'Learn async/await', completed: false });
  console.log('Created:', newTodo);

  await api.delete(newTodo.id);
  console.log('Deleted newly created todo');
})();

Notice:

Private fields (#baseUrl, #request).
async/await for clear flow.
Spread operator for request options.
Template literals for URL construction.
export/import for modularity.

Conclusion

JavaScript’s rapid evolution has turned it from a quirky browser scripting language into a robust, full‑stack powerhouse. Mastering let/const, arrow functions, destructuring, modules, and async/await equips you to write cleaner, more maintainable code today. Keep experimenting with the newest proposals (e.g., Array.prototype.at, Temporal) and remember that the language’s flexibility is both its strength and its responsibility—use the right tool for the right job.

Happy coding! 🚀

Mastering Regular Expressions: From Basics to Advanced Patterns

Ukasha Mahir — Wed, 14 Oct 2026 03:45:05 +0000

Introduction

Regular expressions (often shortened to regex or regexp) are a powerful tool for pattern matching and text manipulation. Whether you are cleaning CSV files, validating user input, or building a syntax highlighter, mastering regex can save you hours of manual coding. In this post we’ll walk through the fundamentals, explore intermediate concepts, and finish with a few advanced techniques that are frequently asked about on Stack Overflow.

1. The Building Blocks

At its core, a regex is a string that describes a set of possible text strings. The simplest patterns are literal characters:

import re
pattern = r"cat"
print(bool(re.search(pattern, "concatenate")))  # True – "cat" appears inside the word

Special characters give regex its expressive power. Here are the most common ones:

. – matches any single character except a newline.
^ – anchors the match to the start of a line.
$ – anchors the match to the end of a line.
[] – defines a character class.
| – logical OR between alternatives.
*, +, ? – quantifiers (zero-or-more, one-or-more, zero-or-one).

Understanding how these symbols combine is the key to unlocking regex.

2. Character Classes & Shorthand Tokens

A character class matches any one character from a set. For example, [aeiou] matches any vowel. Ranges simplify the syntax: [a-z] matches any lowercase letter, [0-9] any digit.

Python (and many other languages) provide shorthand classes that are easier to read:

pattern = r"\d{3}-\d{2}-\d{4}"  # US Social Security Number format
print(re.fullmatch(pattern, "123-45-6789"))  # <re.Match object; span=(0, 11), match='123-45-6789'>

Shorthand	Meaning
`\d`	Digit (0‑9)
`\D`	Non‑digit
`\w`	Word character (letters, digits, underscore)
`\W`	Non‑word character
`\s`	Whitespace (space, tab, newline)
`\S`	Non‑whitespace

You can also negate a class with ^ inside the brackets: [^0-9] matches any non‑digit.

3. Quantifiers – Controlling Repetition

Quantifiers tell the engine how many times a token should repeat.

Quantifier	Description
`*`	0 or more times
`+`	1 or more times
`?`	0 or 1 time
`{n}`	Exactly n times
`{n,}`	n or more times
`{n,m}`	Between n and m times

Greedy vs. lazy quantifiers are an important nuance. By default, quantifiers are greedy – they consume as much text as possible while still allowing the overall pattern to match. Append a ? to make them lazy:

text = "<div>First</div><div>Second</div>"
greedy = re.search(r"<div>.*</div>", text)
print(greedy.group())  # <div>First</div><div>Second</div>

lazy = re.search(r"<div>.*?</div>", text)
print(lazy.group())   # <div>First</div>

4. Grouping, Capturing, and Back‑References

Parentheses () serve two purposes: they create a group for applying quantifiers and they capture the matched substring for later use.

date_pat = r"(\d{4})-(\d{2})-(\d{2})"
match = re.search(date_pat, "2023-08-15")
print(match.groups())  # ('2023', '08', '15')

Captured groups can be referenced in the replacement string:

text = "John Doe (john@example.com)"
obfuscate = re.sub(r"(\w+)@(\w+\.\w+)", r"\1@***.***", text)
print(obfuscate)  # John Doe (john@***.***)

If you only need grouping without capturing, use a non‑capturing group (?:...):

pattern = r"(?:cat|dog)s?"  # matches "cat", "cats", "dog", "dogs"

5. Look‑Around Assertions – Zero‑Width Magic

Look‑arounds let you assert that a pattern is (or isn’t) preceded or followed by another pattern, without including that surrounding text in the match.

Positive look‑ahead (?=…) – the following text must match.
Negative look‑ahead (?!…) – the following text must not match.
Positive look‑behind (?<=…) – the preceding text must match.
Negative look‑behind (?<!…) – the preceding text must not match.

Example: find all words that end with "ing" but are not preceded by "non".

text = "running, nonrunning, swimming, nonswimming"
pat = r"(?<!non)\b\w+ing\b"
print(re.findall(pat, text))  # ['running', 'swimming']

Look‑behinds have a historical limitation: many engines require fixed‑width patterns. Modern engines (Python ≥3.8, PCRE, .NET) now support variable‑width look‑behinds, expanding their usefulness.

6. Performance Tips & Testing Strategies

Regexes can become a performance bottleneck when applied to large logs or real‑time streams. Here are a few practical tips:

Prefer anchored patterns – ^ or $ reduce the search space.
Avoid catastrophic backtracking – patterns like (a+)+ on a long string of as can explode. Use atomic groups or possessive quantifiers (++) when supported.
Compile once – re.compile() caches the pattern and avoids reparsing on each call.
Use the appropriate engine – Python's re is fine for most tasks, but for ultra‑fast matching consider the regex third‑party module or compiled languages like Rust’s regex crate.

Testing regexes is crucial. Tools such as regex101.com provide a live editor with explanations, a debugger, and a quick‑reference cheat sheet. Within Python, the re module offers re.fullmatch, re.search, re.findall, and re.finditer – each serving a distinct purpose.

7. Real‑World Example: Log Parsing

Suppose you need to extract IP addresses, timestamps, and HTTP status codes from an Apache access log line:

127.0.0.1 - - [12/Oct/2026:14:23:45 +0000] "GET /index.html HTTP/1.1" 200 1024

A readable yet efficient pattern:

log_pat = (
    r"(?P<ip>\d{1,3}(?:\.\d{1,3}){3}) "   # IP address
    r"- - "
    r"\[(?P<time>[^\]]+)\] "               # Timestamp inside []
    r'"(?P<method>GET|POST|PUT|DELETE) "   # HTTP method (simplified)
    r"(?P<path>[^\s]+) "                     # Requested path
    r'"(?P<proto>HTTP/\d\.\d)" "          # Protocol version
    r"(?P<status>\d{3}) "                    # Status code
    r"(?P<size>\d+)"                         # Response size
)

line = "127.0.0.1 - - [12/Oct/2026:14:23:45 +0000] \"GET /index.html HTTP/1.1\" 200 1024"
match = re.search(log_pat, line)
print(match.groupdict())

Output:

{"ip": "127.0.0.1", "time": "12/Oct/2026:14:23:45 +0000", "method": "GET", "path": "/index.html", "proto": "HTTP/1.1", "status": "200", "size": "1024"}

Named groups (?P<name>) make the resulting dictionary self‑documenting, which is especially helpful when the same pattern is reused across many log files.

Conclusion

Regular expressions are a concise, expressive language for text processing. By mastering literals, character classes, quantifiers, grouping, and look‑arounds, you can solve a wide range of problems with just a few lines of code. Remember to keep performance in mind, write unit tests for complex patterns, and use online debuggers to visualize the engine’s decision tree.

Armed with the concepts in this post, you should feel confident tackling everything from simple validation (email, phone numbers) to sophisticated parsing tasks (log analysis, code linting). Happy pattern hunting!

Mastering Regular Expressions: From Basics to Advanced Patterns

Ukasha Mahir — Tue, 13 Oct 2026 21:04:11 +0000

Introduction

Regular expressions (regex) are the Swiss‑army knife of string processing. Whether you’re validating email addresses, extracting data from logs, or building a syntax highlighter, a well‑crafted regex can replace dozens of lines of imperative code with a single, declarative pattern. In this post we’ll walk through the fundamentals, explore common pitfalls, and dive into advanced techniques that will make you a regex power user on Dev.to and beyond.

1. The Building Blocks

1.1 Literals

A literal matches itself. The pattern cat matches the exact substring "cat".

1.2 Metacharacters

Symbol	Meaning
`.`	Any single character except newline
`^`	Start of the string (or line with multiline flag)
`$`	End of the string (or line with multiline flag)
`*`	Zero or more repetitions
`+`	One or more repetitions
`?`	Zero or one repetition (also makes quantifiers lazy)
`[]`	Character class
`	`
`()`	Capturing group
`\`	Escape character

1.3 Quantifiers

Greedy: a+ matches as many as as possible.
Lazy (non‑greedy): a+? matches the fewest possible.
Possessive (supported in some engines): a++ never backtracks.

2. Practical Examples in JavaScript

2.1 Email Validation (quick and dirty)

const emailRegex = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
console.log(emailRegex.test('dev@example.com')); // true

Note: Full RFC‑5322 validation is far more complex; this example demonstrates the typical trade‑off between brevity and strictness.

2.2 Extracting URLs from Text

const urlPattern = /https?:\/\/[^\s"']+/g;
const text = "Visit https://dev.to and http://example.org for more info.";
const urls = text.match(urlPattern);
console.log(urls); // ['https://dev.to','http://example.org']

The pattern uses a negated character class to stop at whitespace, quotes, or line breaks.

2.3 Reformatting Dates (DD/MM/YYYY → YYYY‑MM‑DD)

const date = "23/09/2024";
const reformatted = date.replace(/(\d{2})\/(\d{2})\/(\d{4})/, "$3-$2-$1");
console.log(reformatted); // 2024-09-23

Capture groups ($1, $2, $3) let us rearrange the parts.

3. Common Pitfalls and How to Avoid Them

3.1 Forgetting to Escape Metacharacters

If you need to match a literal dot, use \. instead of .. Failing to escape leads to over‑matching.

3.2 Catastrophic Backtracking

Patterns like /(a+)+b/ can cause exponential runtime on strings that don’t match. Prefer atomic groups or possessive quantifiers when possible.

// Bad – may hang on a long string of 'a's
const bad = /(a+)+b/;
// Safer – use lazy quantifier with a lookahead
const good = /a+?(?=b)/;

3.3 Ignoring Unicode

JavaScript’s regex engine treats characters as UTF‑16 code units. For full Unicode support, add the u flag:

const emoji = /\p{Emoji}/u;

This matches any emoji defined by Unicode property escapes.

4. Advanced Techniques

4.1 Named Capture Groups (ES2018+)

const log = "[INFO] 2024-09-13 12:34:56 – Server started";
const pattern = /\[(?<level>\w+)]\s+(?<date>\d{4}-\d{2}-\d{2})\s+(?<time>\d{2}:\d{2}:\d{2})/;
const {groups} = log.match(pattern);
console.log(groups); // { level: 'INFO', date: '2024-09-13', time: '12:34:56' }

Named groups make the result self‑documenting and eliminate reliance on index numbers.

4.2 Lookaheads and Lookbehinds

Positive lookahead (?=…) asserts that a pattern follows.
Negative lookahead (?!…) asserts that a pattern does not follow.
Positive lookbehind (?<=…) (supported in modern browsers) asserts what precedes.
Negative lookbehind (?<!…) asserts what does not precede.

Example: Password Complexity

const strongPwd = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$/;
console.log(strongPwd.test('P@ssw0rd')); // true

Each lookahead checks a separate requirement without consuming characters.

4.3 Recursive Patterns (PCRE, Ruby, .NET)

JavaScript doesn’t support true recursion, but languages like PHP (PCRE) do. For matching nested parentheses:

$pattern = '/\((?:[^()]|(?R))*\)/';

Understanding that such power exists in other ecosystems broadens your regex toolbox.

5. Performance Tips

Anchor when possible – ^ and $ dramatically reduce the search space.
Pre‑compile – In long‑running Node processes, compile once and reuse the RegExp object.
Avoid backtracking traps – Prefer character classes over alternations when they overlap.
Benchmark – Use console.time or the benchmark npm package to compare alternatives.

6. Testing Your Regex

A robust test suite prevents regressions. Tools you can embed in a CI pipeline:

regex101.com – interactive debugging with explanation.
re2 – a safe, linear‑time engine for Node (use re2 npm package).
jest – write unit tests:

test('extract URLs', () => {
  const pattern = /https?:\/\/[^\s"']+/g;
  const input = "Docs: https://dev.to/docs";
  expect(input.match(pattern)).toEqual(['https://dev.to/docs']);
});

7. Conclusion

Regular expressions are deceptively simple at the surface but hide a depth that rewards careful study. Master the fundamentals, respect performance considerations, and leverage modern features like named groups and Unicode property escapes. With practice, you’ll be able to read, write, and maintain regexes confidently—turning a once‑intimidating tool into a daily ally.

Happy pattern matching! 🚀

Mastering TypeScript: From Zero to Hero in Modern Web Development

Ukasha Mahir — Tue, 13 Oct 2026 21:03:41 +0000

Introduction

If you’ve been building JavaScript applications for a while, you’ve probably heard the buzz around TypeScript. It’s more than a trendy superset of JavaScript – it’s a productivity engine that catches bugs before they reach the browser, improves IDE assistance, and scales gracefully as your codebase grows. In this post we’ll walk through the core concepts, showcase practical code snippets, and outline a migration path so you can start reaping the benefits today.

Why TypeScript?

Static typing – Detect mismatched types at compile‑time rather than runtime.
Rich IntelliSense – Autocompletion, refactoring, and inline documentation become far more accurate.
Gradual adoption – You can add TypeScript to an existing JavaScript project file‑by‑file.
Future‑proof syntax – TypeScript ships experimental ECMAScript features early (e.g., private fields, decorators).
Ecosystem support – All major frameworks (React, Angular, Vue, Svelte) have first‑class TypeScript templates.

Getting Started

# Install the compiler globally (or use npx)
npm install -g typescript

# Initialise a tsconfig.json with sensible defaults
tsconfig --init

The generated tsconfig.json is your command center. A minimal setup for a Node.js project looks like this:

{ "compilerOptions": { "target": "es2020", "module": "commonjs", "strict": true, "outDir": "dist", "esModuleInterop": true } }

The strict flag enables the full suite of type‑checking features – we’ll rely on it throughout the examples.

Basic Types

TypeScript ships with a rich set of primitive types:

let isReady: boolean = true;
let count: number = 42;
let username: string = "dev_user";
let ids: number[] = [1, 2, 3];
let tuple: [string, number] = ["age", 30];

// Union types – a value can be one of several types
let identifier: string | number = "abc123";
identifier = 987; // still valid

The compiler will flag any assignment that violates these contracts, saving you from subtle runtime errors.

Interfaces & Type Aliases

When your data shapes become more complex, you’ll want reusable contracts. Both interfaces and type aliases can describe object structures, but they have subtle differences.

interface User {
  id: number;
  name: string;
  email?: string; // optional property
}

// Using the interface
const alice: User = { id: 1, name: "Alice" };

// Type alias – can also compose unions or primitives
type APIResponse<T> = {
  data: T;
  error?: string;
};

const success: APIResponse<User> = { data: alice };

Interfaces are open‑ended (they can be merged across files), making them ideal for library augmentation, while type aliases excel at expressing unions, tuples, and conditional types.

Functions & Generics

Adding type information to functions is straightforward. When you need a function to work with any type while preserving that type, generics are the answer.

function greet(name: string): string {
  return `Hello, ${name}!`;
}

// Generic utility – shallow clone of an array
function cloneArray<T>(arr: T[]): T[] {
  return [...arr];
}

const nums = cloneArray([1, 2, 3]); // inferred as number[]
const strs = cloneArray(["a", "b"]); // inferred as string[]

Generics become powerful when combined with constraints:

function pluck<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { id: 10, name: "Bob" };
const userName = pluck(user, "name"); // type is string

Advanced Types

Conditional Types

Conditional types let you express type relationships that depend on other types.

type IsString<T> = T extends string ? true : false;
type Test1 = IsString<string>; // true
type Test2 = IsString<number>; // false

Mapped Types

Transform existing types into new shapes:

type ReadonlyUser = Readonly<User>;
type PartialUser = Partial<User>;

Template Literal Types (TS 4.1+)

Create string unions based on patterns:

type Event = "click" | "hover" | "focus";
type EventHandler = `on${Capitalize<Event>}`;

// Result: "onClick" | "onHover" | "onFocus"

Working with React

TypeScript shines in component libraries. Here’s a concise functional component with props typed via an interface:

import React from "react";

interface CardProps {
  title: string;
  content: React.ReactNode;
  footer?: string;
}

const Card: React.FC<CardProps> = ({ title, content, footer }) => (
  <div className="card">
    <h2>{title}</h2>
    <div>{content}</div>
    {footer && <footer>{footer}</footer>}
  </div>
);

export default Card;

Because props are typed, any misuse (e.g., passing a number to title) is highlighted instantly in the editor.

Migration Strategies

1. Rename Files Incrementally

Start by renaming a few .js files to .ts (or .tsx for JSX). The compiler will immediately surface any type errors.

2. Enable `allowJs` & `checkJs`

In tsconfig.json you can keep JavaScript files in the project while still type‑checking them:

{ "compilerOptions": { "allowJs": true, "checkJs": true } }

Gradually add JSDoc annotations until the file can be converted to TypeScript.

3. Leverage `// @ts-ignore`

When you encounter a stubborn third‑party library without type definitions, you can temporarily silence errors with // @ts-ignore. Use sparingly and replace with proper typings later.

4. Adopt `strict` Mode Early

Turning on strict forces you to address null/undefined pitfalls, implicit anys, and other common bugs from day one.

Tooling & Ecosystem

VS Code – Built‑in TypeScript language service provides real‑time diagnostics and refactors.
ESLint + @typescript-eslint – Linting rules tailored for TypeScript.
ts-node – Run TypeScript files directly without a separate compile step.
Webpack / Vite – Both have first‑class TypeScript loaders; Vite’s dev server even skips type‑checking for faster hot‑module reloads (use vite-plugin-checker for background checks).

Best Practices

✅ Do	❌ Don’t
Enable `strict` and keep it on.	Rely on `any` to “just make it work”.
Prefer interfaces for public API contracts.	Over‑use complex union types that obscure intent.
Write type‑only imports (`import type { Foo } from "./foo"`).	Import values just for type information – it can increase bundle size.
Use readonly for immutable data structures.	Mutate objects that should be immutable; leverage `as const` for literal inference.

Conclusion

TypeScript is no longer a “nice‑to‑have” add‑on; it’s become the de‑facto standard for large‑scale JavaScript applications. By introducing static types, you gain early error detection, self‑documenting code, and a smoother developer experience. The migration curve is gentle—thanks to incremental adoption and powerful tooling—so you can start with a single file and scale up.

Give it a try: set up a tsconfig.json, rename a module, and watch the compiler guide you toward safer, more maintainable code. Your future self (and your teammates) will thank you.

Happy typing!

Unleashing Modern JavaScript: Tips, Tricks, and Real‑World Patterns

Ukasha Mahir — Tue, 13 Oct 2026 20:50:10 +0000

Introduction

JavaScript has evolved from a quirky scripting language for the browser into a full‑stack powerhouse. Whether you’re building a single‑page app, a serverless function, or a CLI tool, mastering the latest language features can make your code more expressive, safer, and faster. In this post we’ll explore practical patterns, modern syntax, and performance tricks that you can drop into production today. All examples run in Node 18+ and modern browsers.

1. Embrace Typed JavaScript with JSDoc

While TypeScript is fantastic, many teams adopt it incrementally. JSDoc offers a lightweight way to add type hints without a build step. Editors like VS Code will infer types, giving you autocomplete and error checking.

/**
 * Fetches a JSON payload and parses it.
 * @param {string} url The endpoint to request.
 * @returns {Promise<Record<string, any>>}
 */
async function fetchJson(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

// Usage – IDE now knows the return shape
fetchJson('https://api.example.com/data')
  .then(data => console.log(data.title));

Notice how a few comments give us the same developer experience as TypeScript while keeping the file plain .js.

2. Destructuring & Rest/Spread – Write Less, Read More

Destructuring shines when handling API responses or function arguments. Pair it with the rest operator to filter out unwanted fields.

const user = {
  id: 42,
  name: 'Ada Lovelace',
  role: 'admin',
  token: 'secret',
  createdAt: '2024-01-01',
};

// Pull only what we need for the UI
const { id, name, ...meta } = user;
console.log(id, name); // 42 "Ada Lovelace"
console.log(meta); // { role: 'admin', token: 'secret', createdAt: '2024-01-01' }

When combined with function parameters, you can enforce a clear contract:

/** @type {(opts:{url:string,method?:string,headers?:object})=>Promise<any>} */
async function request({url, method = 'GET', headers = {}}) {
  const res = await fetch(url, {method, headers});
  return res.json();
}

3. Optional Chaining & Nullish Coalescing – Guard Against "undefined"

The ?. operator short‑circuits when a property is null or undefined. Coupled with ??, you can provide sensible defaults without noisy if blocks.

const config = {
  api: { endpoint: 'https://api.example.com' },
};

const timeout = config.api?.timeout ?? 5000; // 5000 because timeout is undefined
console.log(timeout);

These operators reduce boilerplate and make intent crystal clear.

4. Private Class Fields – True Encapsulation

ES2022 introduced # private fields, giving you true encapsulation without closures.

class Counter {
  #count = 0; // private field

  increment() {
    this.#count++;
    return this;
  }

  get value() {
    return this.#count;
  }
}

const c = new Counter();
console.log(c.increment().value); // 1
// console.log(c.#count); // SyntaxError: Private field '#count' must be declared in an enclosing class

Because the field is truly private, accidental external mutation is impossible.

5. Async Iteration – Stream Large Data Sets

When dealing with paginated APIs or large file streams, for await … of lets you process data lazily, keeping memory usage low.

/** Simulate a paginated endpoint */
async function* pages() {
  for (let i = 1; i <= 5; i++) {
    // Simulate network latency
    await new Promise(r => setTimeout(r, 200));
    yield Array.from({length: 3}, (_, k) => `Item ${i}-${k+1}`);
  }
}

(async () => {
  for await (const batch of pages()) {
    batch.forEach(item => console.log(item));
  }
})();

The generator yields each batch only when the loop requests it, making it ideal for server‑side rendering or background jobs.

6. Top‑Level Await – Simplify Scripts

Node 14+ and modern browsers support top‑level await, eliminating the need for an IIFE wrapper.

// fetch-data.mjs – run with `node fetch-data.mjs`
const response = await fetch('https://api.github.com/repos/javascript-tutorial/en.javascript.info/commits');
const commits = await response.json();
console.log(`Latest commit SHA: ${commits[0].sha}`);

This feature is a game‑changer for quick scripts, configuration files, or test harnesses.

7. Performance Tip: Use `Map` for Frequent Look‑ups

Objects are great for static dictionaries, but Map offers O(1) look‑ups with any key type and preserves insertion order.

const cache = new Map();
function memoize(fn) {
  return function(arg) {
    if (cache.has(arg)) return cache.get(arg);
    const result = fn(arg);
    cache.set(arg, result);
    return result;
  };
}

const fib = memoize(n => (n < 2 ? n : fib(n-1) + fib(n-2)));
console.log(fib(40)); // fast thanks to memoization

When you need to store objects as keys (e.g., DOM nodes), Map is the only safe choice.

8. Modular CSS with Tagged Template Literals – Styled Components Lite

If you’re not using a framework, you can still get component‑scoped styles with a tiny helper.

function css(strings, ...values) {
  const style = document.createElement('style');
  style.textContent = strings.reduce((acc, str, i) => acc + str + (values[i] || ''), '');
  document.head.append(style);
  return style.sheet;
}

// Usage
css`
  .card {
    background: #fff;
    border-radius: 8px;
    box-shadow: 0 2px 6px rgba(0,0,0,0.1);
    padding: 1rem;
  }
  .card h2 { margin-top: 0; }
`;

The tagged template literal compiles CSS at runtime, avoiding a separate build step while still keeping styles close to the component logic.

9. Deploy‑Ready Example: A Minimal Serverless Function

Below is a complete, production‑ready handler you can drop into Vercel, Netlify, or Cloudflare Workers.

// api/hello.js – Vercel Serverless Function
export default async function handler(req, res) {
  const { name = 'World' } = req.query;
  const now = new Date().toISOString();

  // Use optional chaining & nullish coalescing for safety
  const ip = req.headers['x-forwarded-for']?.split(',')[0] ?? req.socket.remoteAddress;

  res.setHeader('Cache-Control', 's-maxage=60, stale-while-revalidate');
  res.status(200).json({
    greeting: `Hello, ${name}! 🎉`,
    timestamp: now,
    clientIP: ip,
  });
}

Key takeaways:

Destructuring query parameters with defaults.
Graceful fallback for the client IP using optional chaining.
Cache headers that let the CDN serve stale content while revalidating.

Deploy in seconds and you have a performant, typed‑friendly endpoint.

Conclusion

JavaScript’s ecosystem moves fast, but the language itself now offers a rich, expressive toolbox that reduces boilerplate, improves safety, and boosts performance. By integrating JSDoc, private fields, async iteration, and top‑level await, you can write cleaner code without pulling in heavy frameworks. Pair these patterns with pragmatic data structures like Map and lightweight styling helpers, and you’ll be equipped to ship modern web experiences faster.

Happy coding!

Mastering Git: From Basics to Pro‑Level Workflows

Ukasha Mahir — Tue, 13 Oct 2026 20:36:37 +0000

Git has become the de‑facto version‑control system for modern software development. Whether you’re a solo coder, a startup founder, or part of a multinational engineering team, mastering Git can dramatically improve code quality, collaboration speed, and deployment confidence. In this post we’ll walk through the essential concepts, showcase practical workflows, and sprinkle in a few advanced tricks that most beginners miss. Grab your terminal, and let’s dive.

1. Why Git?

Git isn’t just another tool – it’s a distributed VCS that gives every developer a full copy of the repository history. This design provides:

Speed – most operations are local, so commits, diffs, and branch switches happen in milliseconds.
Safety – the reflog and object database act as an accidental‑delete safety net.
Flexibility – you can rewrite history, cherry‑pick commits, or rebase without breaking the shared code base.

2. Getting Started

# Install Git (macOS, Linux, Windows)
# macOS (brew)
brew install git
# Ubuntu/Debian
sudo apt-get update && sudo apt-get install git
# Windows – use the installer from git-scm.com

After installation, configure your identity – Git embeds this metadata into each commit.

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

You can verify everything with:

git --version
git config --list --show-origin | grep user

3. Core Concepts

3.1 Repository

A repository is a .git directory that stores objects, refs, and configuration. Create one with:

git init my‑project
cd my‑project

3.2 Staging & Committing

Git separates staging (the index) from the actual commit. This lets you craft precise snapshots.

echo "Hello, Git!" > README.md
git add README.md   # stage
git status           # see staged changes
git commit -m "Add initial README"

3.3 Branches

Branches are lightweight pointers to commits. The default branch is usually main (or master).

git branch            # list branches
git checkout -b feature/login   # create + switch to new branch

3.4 Merging vs. Rebasing

Merging creates a new commit that ties histories together.
Rebasing rewrites the base of a branch, yielding a linear history.

# Merge example
git checkout main
git merge feature/login   # fast‑forward or three‑way merge

# Rebase example
git checkout feature/login
git rebase main             # replay commits on top of main

Pro tip: Use git pull --rebase for a clean history when pulling remote changes.

4. A Practical Feature‑Branch Workflow

Sync with remote – always start from the latest main.

   git checkout main
   git pull --rebase origin main

Create a feature branch.

   git checkout -b feat/payment‑gateway

Commit often – small, logical commits make reviews easier.

   git add src/payments.js
   git commit -m "Implement payment API client"

Push for a Pull Request.

   git push -u origin feat/payment‑gateway

Open a PR on GitHub/GitLab/Bitbucket. Request reviews, add labels, and let CI run.
Address feedback – add more commits or amend existing ones.
Squash & merge – keep main tidy.

   git checkout main
   git pull --rebase origin main   # ensure up‑to‑date
   git merge --squash feat/payment‑gateway
   git commit -m "feat: payment gateway integration"
   git push origin main

Delete the branch locally and remotely.

   git branch -d feat/payment‑gateway
   git push origin --delete feat/payment‑gateway

5. Advanced Tips & Tricks

5.1 Stashing Temporary Work

When you need to switch context without committing:

git stash push -m "WIP: refactor auth"
git stash list               # view saved states
git stash apply stash@{0}    # restore

5.2 Bisect – Find the Bad Commit

Git can binary‑search through history to locate a regression.

git bisect start
git bisect bad            # current HEAD is bad
git bisect good v1.2.0    # known good tag/commit
# Git checks out a midpoint; test, then mark good/bad
# Repeat until the culprit is identified

5.3 Reflog – Recover Lost Commits

Even after git reset --hard, the reflog retains a record.

git reflog               # show recent moves of HEAD
git checkout <commit‑sha> # recover

5.4 Hooks – Automate Checks

Git hooks are scripts that run at specific points. A simple pre‑commit hook to enforce eslint:

# .git/hooks/pre-commit (make executable)
#!/bin/sh
npm run lint
if [ $? -ne 0 ]; then
  echo "Linting failed – commit aborted"
  exit 1
fi

Place it in the repo or use a tool like husky for cross‑platform support.

6. Git in CI/CD Pipelines

Most CI systems clone the repo shallowly for speed:

# Example GitHub Actions snippet
actions/checkout@v3:
  with:
    fetch-depth: 1   # shallow clone

When you need the full history for version bumping or changelog generation, set fetch-depth: 0.

7. Common Pitfalls & How to Avoid Them

Pitfall	Symptom	Fix
Accidentally committing large files	Repository size balloons, CI slows	Add a `.gitignore` and use `git rm --cached <file>`
Merge conflicts proliferate	Team spends hours resolving	Rebase feature branches onto `main` frequently
History becomes noisy	`git log` hard to read	Squash commits before merging, or use `git commit --amend` for tiny fixes
Lost work after reset	“Oops, I reset too far”	Run `git reflog` immediately and checkout the desired SHA

8. Conclusion

Git is more than a set of commands – it’s a mindset about incremental, reversible development. By mastering the basics, adopting a disciplined feature‑branch workflow, and sprinkling in a few advanced techniques, you’ll unlock a smoother collaboration experience and a cleaner project history. Keep experimenting with rebasing, hooks, and bisect; the more you explore, the more Git will feel like an extension of your brain rather than a separate tool.

Happy coding!

Mastering Git: From Basics to Pro Tips for Everyday Developers

Ukasha Mahir — Tue, 13 Oct 2026 19:28:38 +0000

Introduction

Git is the de‑facto version control system for modern software development. Whether you're a solo coder or part of a massive open‑source community, mastering Git can dramatically improve your workflow, collaboration, and code quality. In this post we'll walk through the essentials—cloning, branching, merging, rebasing, and some pro‑level tricks—while keeping the examples short and practical.

1. Getting Started: The First Commit

# Initialize a new repository
mkdir my‑project && cd my‑project
git init

# Create a README and commit it
printf "# My Project\n\nA brief description." > README.md
git add README.md
git commit -m "Initial commit"

Why git add?

Stages files for the next commit.
Allows you to commit a subset of changes (useful for partial work).

2. Cloning & Remote Workflows

# Clone an existing repo
git clone https://github.com/your‑org/awesome‑app.git
cd awesome‑app

# List configured remotes
git remote -v

Typical remote names:

origin – the default remote created by clone.
upstream – a second remote pointing to the original upstream repository (common for forks).

Adding a New Remote

git remote add upstream https://github.com/original/awesome‑app.git

Now you can fetch upstream changes without affecting your origin branches.

3. Branching: The Core of Parallel Development

# Create and switch to a new feature branch
git checkout -b feature/login

# Do some work, then commit
git add src/login.js
git commit -m "Add login component"

Branch Naming Conventions

feature/* – new functionality.
bugfix/* – bug repairs.
hotfix/* – urgent production patches.
release/* – preparation for a release.

Keeping branches short‑lived reduces merge conflicts and simplifies history.

4. Merging vs. Rebasing

Merging (preserves history)

git checkout main
git merge feature/login   # Creates a merge commit

Rebasing (linear history)

git checkout feature/login
git rebase main           # Replay commits on top of main

When to rebase?

Before opening a Pull Request (PR) to keep the PR tidy.
Never rebase shared branches that teammates have already pulled.

When to merge?

For long‑running branches where you want to retain the original context.

5. Interactive Rebase: Cleaning Up Commits

Suppose you have three messy commits and want to squash them into a single coherent one.

git log --oneline   # Identify the commit hash before the three
# Assume the hash is abc123

git rebase -i abc123

An editor opens:

pick e1a2b3 Add login UI
pick f4c5d6 Fix login typo
pick a7b8c9 Add unit tests

Change pick to squash (or s) for the second and third lines, save, and edit the combined commit message.

6. Stashing: Save Work in Progress

When you need to switch branches but aren't ready to commit:

git stash push -m "WIP: login UI"
# Switch branches, work, then restore
git stash list
git stash apply stash@{0}

You can also git stash pop to apply and drop the stash in one step.

7. Resolving Conflicts

A conflict occurs when Git can't automatically merge changes. After a merge or rebase that hits a conflict:

# Open the conflicted file; you'll see markers like:
<<<<<<< HEAD
// code from current branch
=======
// code from incoming branch
>>>>>>> feature/login

# Edit to keep the correct version, then:

git add conflicted-file.js
# Continue the operation

git merge --continue   # or git rebase --continue

Tip: Use git diff --conflict to see a side‑by‑side view.

8. Tagging Releases

# Annotated tag (recommended for releases)
git tag -a v1.0.0 -m "First stable release"
# Push tags to remote
git push origin v1.0.0

Annotated tags store the tagger name, email, date, and a message—perfect for release notes.

9. Pro Tips & Lesser‑Known Commands

Command	What It Does
`git log --graph --oneline --decorate`	Visualize branch structure in the terminal
`git reflog`	Recover lost commits by viewing the reference log
`git cherry-pick <hash>`	Apply a single commit from another branch
`git bisect start` … `git bisect bad/good`	Binary search to locate a bug introduction
`git filter-branch` (or `git filter-repo`)	Rewrite history (e.g., remove large files)

Example: Using `git bisect` to Find a Bug

# Start bisect on the range where bug appeared
git bisect start
git bisect bad               # Current HEAD is bad
git bisect good v1.2.3       # Tag known good version
# Git checks out a mid‑point; test, then tell Git:
# If bad:
git bisect bad
# If good:
git bisect good
# Repeat until Git pinpoints the offending commit

10. Automating with Hooks

Git hooks let you run scripts at key points. For example, enforce commit messages:

# .git/hooks/commit-msg (make it executable)
#!/usr/bin/env bash
msg=$(cat "$1")
if ! grep -qE "^JIRA-[0-9]+:" <<< "$msg"; then
  echo "Commit message must start with a JIRA ticket (e.g., JIRA-123: ...)" >&2
  exit 1
fi

Now any git commit that doesn't start with a ticket ID aborts.

Conclusion

Git is a powerful toolbox, not just a single command. By mastering the basics—cloning, branching, merging/rebasing—and sprinkling in advanced techniques like interactive rebasing, bisect, and hooks, you can keep your repository clean, your history readable, and your team productive.

Start applying these patterns today, and watch your development workflow become faster, safer, and far more enjoyable.

Happy coding!