Posts on Rafiul Alam

The AI Inflection Point: What's Happening, Why It Matters, and How to Prepare

Fri, 13 Mar 2026 00:00:00 +0000

A deep-dive into the most important AI developments of early 2026 — from GPT-5 and agentic systems to global regulation and the skills you need to stay relevant.

Advanced Data Structures: A Coffee Shop Guide

Wed, 19 Nov 2025 00:00:00 +0000

Understanding data structures can be challenging when they’re presented as abstract concepts. Let’s make them tangible by exploring them through something we all know: a coffee shop. From the order queue to delivery routes, every aspect of running a coffee shop mirrors fundamental computer science concepts.

In this comprehensive guide, we’ll explore 25+ data structures through the lens of coffee shop operations, complete with visualizations and Go implementations.

Part 1: The Basics Revisited

The Order Line - Queue

Every morning at the coffee shop, customers line up in order. First in, first out (FIFO). The person who arrives first gets served first. This is a queue.

Best AI Research Papers: A Curated List from Foundation to Frontier

Wed, 19 Nov 2025 00:00:00 +0000

The field of artificial intelligence has evolved rapidly over the past decades, driven by groundbreaking research papers that have fundamentally changed how we think about and build intelligent systems. Whether you’re a researcher, practitioner, or enthusiast, understanding these landmark papers is essential to grasping where AI is today and where it’s heading.

This curated list covers the most influential AI research papers from the foundational classics to cutting-edge 2024-2025 breakthroughs. I’ve organized them chronologically and by domain to help you navigate this fascinating journey through AI’s evolution.

Complete Guide to Go Concurrency Patterns: Visual Patterns & Code Examples

Tue, 18 Nov 2025 00:00:00 +0000

Master all essential Go concurrency patterns with mermaid visualizations and practical code examples. From basic goroutines to advanced patterns like worker pools, fan-in/out, pipelines, and more.

Complete Guide to Graph Algorithms in Go

Sun, 16 Nov 2025 00:00:00 +0000

Master graph algorithms in Go with complete implementations, complexity analysis, and practical use cases. Covers BFS, DFS, Dijkstra's, Bellman-Ford, Floyd-Warshall, Kruskal's, Prim's, topological sort, and more.

Building an MCP File Operations Tool in Go: A Complete Guide

Sat, 18 Oct 2025 00:00:00 +0000

The Model Context Protocol (MCP) is revolutionizing how AI assistants interact with tools and data sources. In this comprehensive guide, we’ll build a production-ready MCP server in Go that provides powerful file operations-think of it as the strings utility package, but for files and AI assistants.

What is MCP?

MCP (Model Context Protocol) is a standardized way for AI assistants to interact with external tools and data sources. Instead of custom integrations for each tool, MCP provides a universal protocol that works with any compliant server.

Building Scalable Event-Driven Microservices in Go: A User and Notes Service Example

Wed, 15 Oct 2025 00:00:00 +0000

Learn how to build scalable, resilient event-driven microservices in Go using NATS JetStream, Watermill, Bun ORM, and PostgreSQL with practical User and Notes service examples.

Building a Real-Time File Monitor with Goroutines and Channels

Fri, 03 Oct 2025 00:00:00 +0000

File monitoring is a common requirement in many applications: watching for configuration changes, processing uploads, syncing directories, or building development tools. In this post, we’ll build a production-ready file monitoring service that tracks word counts across all files in a directory using Go’s powerful concurrency primitives.

The Challenge

Build a service that:

Monitors a directory and all its subdirectories
Counts words in all files in real-time
Updates counts when files are modified, created, or deleted
Processes multiple files concurrently
Provides current statistics on demand
Handles errors gracefully

Why This Matters

Real-time file monitoring powers many production systems:

Building a Crash-Resistant Log Service in Go with Context Timeout

Mon, 15 Sep 2025 00:00:00 +0000

Building production-grade services requires more than just functionality-they need resilience, graceful degradation, and the ability to handle failures without crashing. In this post, we’ll build a robust logging service that demonstrates these principles using Go’s context package and proper error handling.

The Problem

Imagine your application sends logs to a remote logging service. What happens when:

The logging service is slow or unresponsive?
Network issues cause delays?
The logging service crashes entirely?

Without proper safeguards, your entire application could hang, crash, or become unresponsive just because logging failed. Logging should never bring down your application.

Option and Result: No More Nil Pointers

Tue, 29 Apr 2025 00:00:00 +0000

Go to Rust Series: ← String vs &str | Series Overview

The Problem: Nil and Errors

Tony Hoare (inventor of null references) called it his “billion-dollar mistake.”

Go’s approach: nil values and explicit error returns Rust’s approach: Option<T> for absence, Result<T, E> for errors

Go: Nil Pointers

Go:

func findUser(id int) *User {
    if id == 0 {
        return nil
    }
    return &User{ID: id, Name: "Alice"}
}

func main() {
    user := findUser(0)
    if user != nil {
        fmt.Println(user.Name)
    } else {
        fmt.Println("User not found")
    }
}

Problem: Easy to forget nil check:

String vs &str: Rust's Confusing String Types for Go Devs

Sat, 26 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Mut vs Immutable | Series Overview | Option and Result →

The Confusion

Go has one string type:

var s string = "hello"

Rust has two main string types:

let s1: String = String::from("hello");  // Owned string
let s2: &str = "hello";                  // String slice

Why two types? It’s one of the most confusing aspects for Go developers learning Rust.

Go: One String Type

Go:

package main

import "fmt"

func main() {
    // All of these are just "string"
    s1 := "hello"
    s2 := "world"
    s3 := s1 + " " + s2

    printString(s1)
    printString(s3)
}

func printString(s string) {
    fmt.Println(s)
}

Simple. Everything is string.

Mut vs Immutable: Why Rust Makes You Choose

Fri, 25 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Lifetimes Explained | Series Overview | String vs &str →

The Default Difference

Go: Everything is mutable by default Rust: Everything is immutable by default

This single difference shapes how you write code in each language.

Go: Mutable by Default

Go:

func main() {
    x := 10
    x = 20      // No problem
    x = x + 5   // No problem
    fmt.Println(x)  // 25
}

Variables are mutable unless you use const (which is very limited):

const PI = 3.14  // Compile-time constant only
PI = 3.14159     // Error

Rust: Immutable by Default

Rust:

Lifetimes Explained: The Annotation Go Developers Never Needed

Thu, 24 Apr 2025 00:00:00 +0000

Go to Rust Series: ← No Garbage Collector | Series Overview | Mut vs Immutable →

The Concept Go Doesn’t Need

Lifetimes are Rust’s way of tracking how long references are valid-all at compile time.

Go doesn’t need lifetimes because the garbage collector tracks reference validity at runtime. Rust needs them because there’s no GC.

Go: References Just Work

Go:

func getFirst(a, b string) string {
    if len(a) > len(b) {
        return a
    }
    return b
}

func main() {
    x := "short"
    y := "longer"
    result := getFirst(x, y)
    fmt.Println(result)
}

No annotations needed. GC ensures result stays valid.

No Garbage Collector: How Rust Manages Memory Without GC

Wed, 23 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Ownership and Borrowing | Series Overview | Lifetimes Explained →

The Fundamental Trade-Off

Go: Automatic memory management via garbage collection Rust: Compile-time memory management via ownership

Both approaches have profound implications for performance, predictability, and developer experience.

How Go’s GC Works

Go:

func allocateData() {
    for i := 0; i < 1000000; i++ {
        data := make([]byte, 1024)
        // Use data...
        // No explicit free needed
    }
}

Go’s GC:

Tracks all allocations
Periodically stops the world (STW)
Scans for reachable objects
Frees unreachable memory

GC pause times: Typically 1-10ms, but can spike higher.

Ownership and Borrowing: The Concept Go Doesn't Have

Tue, 22 Apr 2025 00:00:00 +0000

Go to Rust Series: ← The Rust Compiler | Series Overview | No Garbage Collector →

The Core Difference

Ownership is Rust’s most important concept-and the one Go completely lacks.

In Go, the garbage collector handles memory. In Rust, the ownership system handles memory at compile time, with zero runtime cost.

Go:

package main

import "fmt"

func main() {
    data := []int{1, 2, 3}

    // Pass to multiple functions
    printData(data)
    modifyData(data)
    printData(data)

    // Still usable
    fmt.Println(data)
}

func printData(d []int) {
    fmt.Println(d)
}

func modifyData(d []int) {
    d[0] = 999  // Modifies original
}

Output:

The Rust Compiler: Why It Yells at You (And Go Doesn't)

Sat, 19 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Setting Up Rust | Series Overview | Ownership and Borrowing →

The First Encounter

Week 1 with Go: I shipped features.

Week 1 with Rust: I fought the compiler.

This isn’t a bug-it’s Rust’s design. The compiler is strict, verbose, and often frustrating. But after fighting it for weeks, I realized: it’s actually trying to help me.

Compiler Philosophy

Go: Trust the Developer

Go’s compiler does basic checks and gets out of your way:

Setting Up Rust: Tooling Compared to Go's Simplicity

Fri, 18 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Hello World Comparison | Series Overview | The Rust Compiler →

Installation: First Impressions

Go: Download and Done

Installation:

Go to golang.org/dl
Download installer for your OS
Run installer
Done

Verify:

$ go version
go version go1.22.0 linux/amd64

That’s it. Go is installed. One binary, one version, ready to use.

Where it lives:

$ which go
/usr/local/go/bin/go

Single installation directory. Simple.

Rust: The Rustup Way

Installation:

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

This installs rustup, Rust’s toolchain manager (like nvm for Node or rbenv for Ruby).

Hello World in Rust: Why It's More Complex Than Go

Thu, 17 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Cargo vs Go Modules | Series Overview | Setting Up Rust →

The “Simple” Hello World

Every programming tutorial starts with “Hello, World!” It’s supposed to be trivial. But comparing Go and Rust versions reveals fundamental philosophical differences.

Go’s Hello World

main.go:

package main

import "fmt"

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

Compile and run:

go run main.go

Output:

Hello, World!

Done. Five lines. Zero surprises.

Rust’s Hello World

main.rs:

Cargo vs Go Modules: Package Management Face-Off

Wed, 16 Apr 2025 00:00:00 +0000

Go to Rust Series: ← Day 1 Impressions | Series Overview | Hello World Comparison →

First Impression: Cargo is Actually Great

After struggling with Rust’s ownership system on Day 1, I expected the tooling to be equally complex. I was wrong. Cargo is fantastic.

Coming from Go modules (which are already pretty good), Cargo feels like a spiritual successor with better UX.

Project Initialization

Go:

mkdir myproject
cd myproject
go mod init github.com/username/myproject

Creates go.mod:

Day 1 with Rust: A Gopher's First Impressions

Tue, 15 Apr 2025 00:00:00 +0000

Go to Rust Series: Series Overview | Cargo vs Go Modules →

The Setup

After years of writing Go, I decided to spend a few months learning Rust. Everyone kept talking about “fearless concurrency,” “zero-cost abstractions,” and “memory safety without garbage collection.” As a pragmatic developer, I wanted to see what the fuss was about.

Day 1 was… humbling.

First Shock: Everything Needs Annotations

Coming from Go, where types are inferred elegantly, Rust feels verbose. Here’s my first attempt at a simple function:

HTTP/3 & WebTransport in Go: Next-Generation Real-Time Communication

Wed, 19 Feb 2025 00:00:00 +0000

Master HTTP/3 (QUIC) and WebTransport with Go - UDP-based reliable transport, multiplexing without head-of-line blocking, unreliable datagrams, and building ultra-low-latency applications

GraphQL Subscriptions in Go: Data-Driven Real-Time Updates

Tue, 18 Feb 2025 00:00:00 +0000

Master GraphQL Subscriptions with Go - schema-driven subscriptions, WebSocket transport, resolver implementation, and building type-safe real-time APIs with gqlgen

Building Payment Gateway Integrations in Go: A Complete Guide

Mon, 17 Feb 2025 00:00:00 +0000

Learn how to design and implement robust payment gateway integrations with multiple providers, handling transactions, retries, atomicity, scheduling, and data persistence in both SQL and NoSQL databases.

Saga Pattern in Go: Managing Distributed Transactions

Sun, 16 Feb 2025 00:00:00 +0000

Learn how to implement the Saga pattern in Go to manage distributed transactions across microservices with compensating transactions and eventual consistency.

MQTT in Go: IoT & Low-Bandwidth Communication

Sat, 15 Feb 2025 00:00:00 +0000

Master MQTT protocol with Go - QoS levels, Last Will & Testament, retained messages, and building scalable IoT systems for millions of devices

CQRS Pattern in Go: Separating Reads and Writes

Fri, 14 Feb 2025 00:00:00 +0000

Learn how to implement Command Query Responsibility Segregation (CQRS) pattern in Go to optimize read and write operations independently for better scalability and performance.

RabbitMQ & AMQP in Go: Advanced Message Queueing Protocol

Thu, 13 Feb 2025 00:00:00 +0000

Master RabbitMQ with Go - exchanges, queues, bindings, routing patterns, dead letter queues, and reliable message delivery for robust async systems

Event-Driven Architecture in Go: Building Reactive Systems

Wed, 12 Feb 2025 00:00:00 +0000

Learn how to implement Event-Driven Architecture in Go for building loosely coupled, scalable systems that react to events asynchronously using message brokers and event buses.

Apache Kafka in Go: Distributed Event Streaming at Scale

Tue, 11 Feb 2025 00:00:00 +0000

Master Apache Kafka with Go - topics, partitions, consumer groups, offset management, and exactly-once semantics for building resilient event-driven systems

The 'System 2' LLM: How Models Learn to Reason (o1, R1)

Mon, 10 Feb 2025 00:00:00 +0000

Explore how reasoning-focused LLMs like OpenAI's o1 and DeepSeek's R1 perform multi-step thinking, self-correction, and deliberate problem-solving through internal thought processes.

Deconstructing the Mixture-of-Experts (MoE) Architecture

Sun, 09 Feb 2025 00:00:00 +0000

A deep dive into how Mixture-of-Experts models work, from token routing to sparse activation, with comprehensive visualizations of the architecture and data flow.

From Choreography to Durable Execution: Why Temporal Changes Everything

Sat, 08 Feb 2025 00:00:00 +0000

Discover how Temporal's durable execution model replaces hope-driven choreography with reliable, observable workflows. Learn the difference between event-driven choreography and durable execution with practical Go examples.

NATS & JetStream in Go: Cloud-Native Messaging at Scale

Fri, 07 Feb 2025 00:00:00 +0000

Master NATS and JetStream in Go: subject-based messaging, pub/sub patterns, at-most-once vs at-least-once delivery, stream processing, and high-throughput microservices orchestration.

Visualizing LLM Embeddings: The Geometry of Meaning

Thu, 06 Feb 2025 00:00:00 +0000

Explore how words, phrases, and documents are represented as vectors in high-dimensional space, and how their spatial relationships encode semantic meaning through clustering, analogies, and dimensionality reduction.

Go Concurrency Pattern: The Ticket Seller

Wed, 05 Feb 2025 00:00:00 +0000

← Bank Account Drama | Series Overview | Login Counter →

The Problem: Selling Tickets That Don’t Exist

A concert has 1,000 tickets. Multiple goroutines handle sales concurrently. Each seller checks if tickets remain, and if yes, decrements the count and sells one. Sounds simple, right?

Two sellers check simultaneously. Both see “1 ticket remaining.” Both sell. You’ve just sold ticket number -1. Congratulations, you’ve discovered the check-then-act race condition, one of the most common concurrency bugs in the wild.

Profitability Metrics: Beyond 'Are We Making Money?'

Tue, 04 Feb 2025 00:00:00 +0000

Master gross margin, contribution margin, EBITDA, the Rule of 40, and learn why profitable companies can still fail while loss-making companies thrive.

WebRTC in Go: Peer-to-Peer Real-Time Communication

Tue, 04 Feb 2025 00:00:00 +0000

Build WebRTC applications in Go: peer-to-peer audio/video streaming, data channels, NAT traversal with STUN/TURN, signaling with WebSockets, and scaling with SFU architecture.

The LLM Development Workflow: A Data-Centric View

Mon, 03 Feb 2025 00:00:00 +0000

Explore the complete lifecycle of developing large language models: data collection and curation, pre-training, fine-tuning (SFT, DPO, RLHF), evaluation, and the critical feedback loops that shape model behavior.

Go Concurrency Pattern: The Sieve of Eratosthenes Pipeline

Sun, 02 Feb 2025 00:00:00 +0000

← Monte Carlo Pi | Series Overview | Mandelbrot Set →

The Problem: Finding Primes with Filters

The Sieve of Eratosthenes is an ancient algorithm for finding prime numbers. The concurrent version creates a pipeline of filters: each prime spawns a goroutine that filters out its multiples.

The Algorithm:

Generate sequence: 2, 3, 4, 5, 6, 7, 8, 9, 10, …
Take first number (2), it’s prime, filter all multiples of 2
Take next number (3), it’s prime, filter all multiples of 3
Take next number (5), it’s prime, filter all multiples of 5
Repeat until desired count

The Beauty: Each prime creates its own filter. Numbers flow through a pipeline of increasingly selective filters. What passes through all filters must be prime.

Customer Economics: The LTV/CAC Framework That Predicts Success

Sat, 01 Feb 2025 00:00:00 +0000

Master the critical metrics of customer acquisition cost, lifetime value, and retention analysis to predict business success and avoid the $100M mistake that kills startups.

gRPC Streaming in Go: High-Performance Inter-Service Communication

Sat, 01 Feb 2025 00:00:00 +0000

Master gRPC streaming in Go: server, client, and bidirectional streaming over HTTP/2 with protobuf. Build typed microservices communication with gRPC-Web for browsers.

Unpacking KV Cache Optimization: MLA and GQA Explained

Fri, 31 Jan 2025 00:00:00 +0000

Deep dive into how Multi-Head Latent Attention (MLA) and Grouped Query Attention (GQA) reduce memory and computation for long context windows by optimizing the KV cache.

Go Concurrency Pattern: Monte Carlo Pi Estimation

Thu, 30 Jan 2025 00:00:00 +0000

← Login Counter | Series Overview | Sieve of Eratosthenes →

The Problem: Computing Pi by Throwing Darts

Imagine a square dartboard with a circle inscribed inside it. Throw random darts at the square. The ratio of darts landing inside the circle to total darts thrown approaches π/4.

Why? Mathematics:

Square side length: 2 (from -1 to 1)
Square area: 4
Circle radius: 1
Circle area: π × 1² = π
Ratio: π/4

Throw 1 million darts, multiply by 4, and you’ve estimated π. More darts = better estimate. This is Monte Carlo simulation: using randomness to solve deterministic problems.

WebSockets in Go: Building Real-Time Bidirectional Communication

Wed, 29 Jan 2025 00:00:00 +0000

Master WebSocket implementation in Go: connection pooling with Hub pattern, JWT authentication, ping/pong heartbeats, rate limiting, and horizontal scaling with Redis/NATS.

Hybrid Architectures: Marrying Transformers with Mamba (SSMs)

Tue, 28 Jan 2025 00:00:00 +0000

Explore how State Space Models like Mamba are being integrated with Transformers to overcome quadratic scaling and improve long-context handling through linear-time sequence processing.

Go Concurrency Pattern: The Mandelbrot Set

Mon, 27 Jan 2025 00:00:00 +0000

← Sieve of Eratosthenes | Series Overview | Collatz Explorer →

The Problem: Rendering Fractals in Parallel

The Mandelbrot set is defined by a simple iterative formula:

Start with z = 0
Repeatedly compute z = z² + c
If |z| exceeds 2, the point escapes (not in the set)
Color each pixel by iteration count

The beauty: Each pixel is completely independent. Perfect for parallelism!

The challenge: Some pixels escape in 5 iterations, others take 1000+. This creates load imbalance-some workers finish instantly while others grind away.

Server-Sent Events (SSE) in Go: Real-Time Server-to-Client Streaming

Sun, 26 Jan 2025 00:00:00 +0000

Build production-ready Server-Sent Events with Go: automatic reconnection, event types, Last-Event-ID handling, and horizontal scaling with Redis Pub/Sub.

Microservices Architecture in Go: Building Distributed Systems

Sat, 25 Jan 2025 00:00:00 +0000

Learn how to implement Microservices Architecture in Go for building scalable, independently deployable services with clear boundaries and distributed communication patterns.

Go Concurrency Pattern: The Login Counter

Fri, 24 Jan 2025 00:00:00 +0000

← Ticket Seller | Series Overview | Monte Carlo Pi →

The Problem: Counting What You Can’t See

Count concurrent users. On login: increment. On logout: decrement. Simple, right?

Now add reality:

The counter is distributed across multiple servers
A user’s session times out on one server but they’re active on another
The increment message arrives after the decrement message
Network partitions split your cluster
Servers crash mid-operation

Suddenly, this “simple” counter becomes a distributed systems nightmare. Welcome to distributed counting, where even addition is hard.

Release Management: From Semantic Versioning to Production Deployment

Fri, 24 Jan 2025 00:00:00 +0000

A comprehensive visual guide to release management practices including semantic versioning decisions, release trains, hotfix processes, deployment checklists, and environment promotion strategies with Mermaid diagrams.

CI/CD Pipeline: Git Push to Production Deployment