Forem: Md. Maruf Sarker

The real reason your code becomes messy and how DI fixes it

Md. Maruf Sarker — Thu, 19 Mar 2026 23:11:19 +0000

Most people think Dependency Injection (DI) is some advanced .NET magic or framework feature. It’s not. It’s actually a very simple idea, but once you understand it properly, it completely changes how you design systems.

Think about a real-life scenario. You’re building a Food Delivery App. There’s an OrderService that places orders, and after placing an order, it needs to notify the user. The most straightforward way (what most beginners do) is: inside OrderService, you directly create an EmailService and send an email. It works, no problem.

But then reality hits.

Product team comes and says:
“Users want SMS notifications.”
Then later: “Add push notifications.”
Then: “For some users, don’t notify at all.”

Now your OrderService starts growing like this messy switch-case or if-else jungle. Every new requirement means you go back and modify the same class again and again. This is where the real problem is - your core logic (placing orders) is now tightly coupled with notification logic.

This is exactly what DI tries to solve.

Instead of saying:
“I will send email from here”

You change your thinking to:
“I need something that can notify”

That’s it. You introduce a contract like INotificationService. Now you can have multiple implementations: Email, SMS, Push, whatever. Your OrderService doesn’t know or care which one is being used. It just calls “notify”.

Now comes the key idea.

Instead of creating the dependency inside the class (new EmailService()), you let something else provide it. That “something” is usually the DI container.

So when your application runs, the framework does something like:
“OrderService needs INotificationService? Cool, here’s an EmailService (or SMS, or anything you configured).”

Your class doesn’t decide anymore. It just uses.

This one change sounds small, but the impact is huge.

Now when requirements change, you don’t touch OrderService. You just change what gets injected. Today email, tomorrow SMS, next week maybe a third-party API. Your core logic stays clean and stable.

This also connects directly to how modern frameworks like ASP.NET Core work internally. When a request comes in, the framework creates your controller, sees what it needs in the constructor, and automatically provides those dependencies from the container. You never write new - the system wires everything together for you.

The deeper point here is not just “how to use DI”, but why it exists.

DI is about removing hardcoded decisions from your code. It separates “what you do” from “how it’s done”. That’s why your code becomes easier to change, easier to test, and much more scalable as the system grows.

Actual way to think about it:
Before DI → “I decide everything inside my class”
After DI → “I focus on my job, system decides the rest”

And honestly, in real-world projects, this is the difference between code that works today and code that survives after 6 months of changes.

So next time you see DI, don’t think about syntax or builder.Services.AddScoped. Think about this:

You are not injecting services.
You are injecting flexibility into your system.

Installing .NET 10 on Linux (Pop!_OS) — The Real Journey 🚀

Md. Maruf Sarker — Sat, 14 Mar 2026 11:37:11 +0000

So today I decided:
“Let’s install .NET 10 on my Pop!_OS dev machine.”

Simple, right?

Microsoft docs say:

sudo apt-get update && sudo apt-get install -y dotnet-sdk-10.0

Reality check from Linux:

E: Unable to locate package dotnet-sdk-10.0

Linux basically said:

“That package? Never heard of it bro.” 💀

So here’s the full A → Z journey of installing .NET 10 on Linux properly, without breaking your dev environment.

Step 0 — Read the Docs Completely 📚

Before running any command, read the entire documentation first.

Not just the command block.

Many times we jump straight to:

copy → paste → run

But docs often contain important notes like:

supported OS versions
repository limitations
architecture support
alternative installation methods

If I had read the whole doc first, I would have immediately seen that the Ubuntu 22.04 repo may not contain .NET 10 yet.

Lesson learned:

Always read the entire doc, not just the command snippet.

Step 1 — Understand the Problem 🧠

My machine:

OS: Pop!_OS (Ubuntu 22.04 base)
Repo: Microsoft Ubuntu repo
Installed SDKs:

dotnet --list-sdks

Output:

8.0.418
9.0.203

Meaning:

Version	Status
.NET 8	LTS
.NET 9	Latest
.NET 10	❌ Not in repo

So APT couldn’t install it.

Step 2 — Use Microsoft's install script

When the repo doesn’t have the SDK yet, Microsoft provides an official install script.

Download it:

wget https://dot.net/v1/dotnet-install.sh

Make it executable:

chmod +x dotnet-install.sh

Install .NET 10:

./dotnet-install.sh --channel 10.0

After installation the script said:

Installed version is 10.0.201

But when I checked:

dotnet --list-sdks

It still showed:

8.0
9.0

Wait… what?

Step 3 — The PATH Problem 🧩

The script installs .NET here:

~/.dotnet

But my system installation lives here:

/usr/share/dotnet

So Linux was still using the APT version of dotnet.

Fix:

export DOTNET_ROOT=$HOME/.dotnet
export PATH=$HOME/.dotnet:$PATH

Now the prompt changed instantly:

dotnet --version
10.0.201

Nice.

But there was another problem…

Now only .NET 10 appeared.

Step 4 — Two Different .NET Installations

My system now had two separate dotnet environments:

Location	Installed SDKs
`/usr/share/dotnet`	8.0, 9.0
`~/.dotnet`	10.0

Which is messy.

Best practice on Linux is to keep everything in:

/usr/share/dotnet

So I installed .NET 10 system-wide.

Step 5 — Install .NET 10 System-wide

Run the installer with sudo:

sudo ./dotnet-install.sh --channel 10.0 --install-dir /usr/share/dotnet

This installed:

/usr/share/dotnet/sdk/10.0.201

Step 6 — Remove the Old Local Installation

Since .NET was already installed in ~/.dotnet, the shell kept using it.

Remove it:

rm -rf ~/.dotnet

Reset bash cache:

hash -r

Step 7 — Verify Everything

Now run:

dotnet --list-sdks

Result:

8.0.418
9.0.203
10.0.201

And:

dotnet --version

Output:

10.0.201

Boom.

Clean setup.

Final Linux .NET Setup 💻

My machine now looks like this:

/usr/share/dotnet/sdk
├── 8.0.418
├── 9.0.203
└── 10.0.201

Meaning:

SDK	Purpose
.NET 8	LTS (production apps)
.NET 9	Current release
.NET 10	Latest development

Pro Tip — Use global.json

Real projects lock the SDK version.

Example:

{
  "sdk": {
    "version": "8.0.418"
  }
}

This ensures:

teammates use the same SDK
CI/CD builds correctly
no version mismatch

dotnet #linux #backend #softwareengineering #devlife

Pattern Matching vs Manual Casting in C#

Md. Maruf Sarker — Mon, 09 Mar 2026 08:52:41 +0000

When working with polymorphism in C#, you often deal with a base type that can represent many different derived types.

For example, in a payment system you might have a base class Payment, and several derived classes like CreditCardPayment, BankTransferPayment, and MobilePayment.

When you store these objects in a List<Payment>, the compiler only knows that each item is a Payment. But sometimes you need to access properties that exist only on the specific child types.

This is where type checking and casting come into play.

The Old Way: Manual Casting

Before modern pattern matching features were introduced, developers had to manually check the type and then cast the object.

Example:

if (payment is CreditCardPayment)
{
    var cc = (CreditCardPayment)payment;
    Console.WriteLine(cc.CardLastFour);
}

Here two steps are happening:

Check the type with is
Cast the object manually using (CreditCardPayment)

This works, but it has a few problems:

More boilerplate code
Easy to forget the type check
Harder to read when multiple types are involved

When you have several derived types, the code quickly becomes messy.

if (payment is CreditCardPayment)
{
    var cc = (CreditCardPayment)payment;
}
else if (payment is BankTransferPayment)
{
    var bt = (BankTransferPayment)payment;
}
else if (payment is MobilePayment)
{
    var mp = (MobilePayment)payment;
}

This pattern was very common in older C# codebases.

The Modern Way: Pattern Matching

C# introduced pattern matching to simplify type checks and casting.

Instead of two steps, you can do both in a single line.

if (payment is CreditCardPayment cc)
{
    Console.WriteLine(cc.CardLastFour);
}

What happens here?

The compiler:

Checks if payment is CreditCardPayment
If true, automatically casts it
Assigns the result to cc

Inside the block, cc is already strongly typed.

No manual casting required.

Switch Pattern Matching

Pattern matching becomes even more powerful when used with switch.

Example:

var details = payment switch
{
    CreditCardPayment cc   => $"Credit Card ending in {cc.CardLastFour}",
    BankTransferPayment bt => $"Bank Transfer via {bt.BankName}",
    MobilePayment mp       => $"{mp.Provider} | Phone: {mp.PhoneNumber}",
    _                      => "Unknown payment type"
};

Each branch automatically provides a typed variable.

So inside the first branch:

cc is a CreditCardPayment

Inside the second:

bt is a BankTransferPayment

Inside the third:

mp is a MobilePayment

No casting required anywhere.

Why Pattern Matching is Better

1. Less Code

Manual casting requires extra lines and repeated type checks.

Pattern matching compresses the logic into a single clean expression.

2. Safer

Manual casting can throw exceptions if you forget the type check.

Pattern matching only runs the block if the type matches.

3. More Readable

Compare these two:

Manual casting:

if (payment is CreditCardPayment)
{
    var cc = (CreditCardPayment)payment;
}

Pattern matching:

if (payment is CreditCardPayment cc)
{
}

The intent is much clearer.

4. Powerful with Switch Expressions

Pattern matching enables expressive switch logic that works very well with polymorphism.

It keeps the code structured and avoids large chains of if-else.

Real-World Use Case

In the payment system example, we store all payments in a single list:

List<Payment> payments

Each object could be a different type.

When generating a payment summary, we use pattern matching to safely access the correct properties for each payment type.

This allows the code to remain clean, type-safe, and maintainable.

When Should You Use Pattern Matching?

Use pattern matching when:

You have a base class with multiple derived types
You need to access properties specific to those types
You want safer and cleaner code than manual casting

It is especially useful when working with:

Polymorphism
Domain models
Event systems
Result types
API response handling

Final Thoughts

Manual casting was the standard approach for many years.
But modern C# encourages pattern matching because it is cleaner, safer, and easier to read.

Instead of writing extra checks and casts, you can let the language handle it for you.

Small improvements like this are why modern C# codebases feel significantly more expressive and maintainable.

YouTube Channel, Gmail, NID & Monetization: A Complete Guide for New Creators

Md. Maruf Sarker — Fri, 06 Mar 2026 17:55:38 +0000

Starting a YouTube channel today is easier than ever. However, many creators—especially beginners—have important questions about Gmail accounts, identity verification, NID requirements, AdSense, security, and monetization.

Common questions include:

Does my Gmail name have to match my National ID (NID)?
Can I use a different name for my YouTube channel?
When does identity verification matter?
How do I protect my channel from hackers?
What is the safest structure for managing a YouTube channel?
How can I reach monetization faster?

This guide answers all these questions in detail based on policies and guidelines from Google and YouTube.

1. Does Your Gmail Name Need to Match Your National ID (NID)?

The short answer is no.

When creating a channel on YouTube, the Gmail account used to create or manage the channel does not need to match your legal name or National ID (NID).

Creators are free to:

Use any Gmail username
Choose any YouTube channel name
Operate under a brand name or pseudonym

For example:

Gmail:
techcreatorbd@gmail.com

YouTube Channel Name:
Tech Creator BD

Legal Identity (NID):
Md. Maruf Sarker

This setup is completely valid.

Viewers will only see the channel name, not the Gmail address behind it.

2. When Does Identity Actually Matter?

Identity becomes important when you start earning money.

To monetize your channel through the YouTube Partner Program, you must connect a Google AdSense account.

This is where legal identity verification is required.

AdSense may request:

National ID card
Passport
Driving license
Address verification

The payment profile name must match your legal identity documents.

Example:

Payment Profile Name:
Md. Maruf Sarker

If the name on AdSense does not match your ID, verification may fail and payments could be delayed or blocked.

3. Relationship Between Gmail, YouTube Channel, and AdSense

Think of the system in three layers.

Gmail Account

Used for login and management.

No legal name required.

YouTube Channel

Public-facing identity.

Can be a brand name.

AdSense Account

Used for payments.

Must match your legal identity.

Example structure:

Gmail: techcreatorbd@gmail.com
Channel: Tech Creator BD
AdSense Payment Name: Md. Maruf Sarker

4. Common AdSense Mistakes That Cause Monetization Problems

Many creators face issues because of avoidable mistakes.

Using a Fake Name in AdSense

Some creators use:

Nicknames
Channel names
Random names

But AdSense requires legal identity verification.

Always use the exact name from your ID.

Using Someone Else’s AdSense Account

Some creators link their channel to:

Friend’s AdSense
Agency AdSense

Problems that can occur:

They legally control the revenue
Your payments depend on them
Tax details belong to them

It is always safer to create your own AdSense account.

Incorrect Address for PIN Verification

After earning $10, Google sends a PIN code by mail to verify your address.

If the address is wrong, verification may fail.

Example address format:

Name: Md. Maruf Sarker
Area: Kaliganj
District: Gazipur
Postal Code: 1720
Country: Bangladesh

Creating Multiple AdSense Accounts

Google allows only one AdSense account per person.

Creating multiple accounts can lead to suspension.

Selecting the Wrong Country

Always choose the country where you actually live.

For Bangladeshi creators:

Country: Bangladesh

5. The Safest Way to Structure a YouTube Channel

Many creators lose their channels due to poor account structure.

The safest setup uses a Brand Account.

Instead of:

Gmail → YouTube Channel

Use:

Gmail → Brand Account → YouTube Channel

Advantages:

Multiple owners allowed
Channel ownership transferable
Editors can upload videos without accessing your Gmail

6. The Two-Email Owner Security System

Professional creators often use two separate Google accounts.

Primary Owner Gmail
Backup Owner Gmail

Both are assigned as owners of the Brand Account.

Structure:

Primary Gmail
Backup Gmail
↓
Brand Account
↓
YouTube Channel

If one email is lost or hacked, the other owner can recover the channel.

7. Essential Security Settings

You should enable strong security on your Google account.

Important settings include:

Two-Factor Authentication (2FA)
Recovery email
Recovery phone number
Security alerts

Using an authenticator app is safer than SMS verification.

Some creators also use hardware security keys for maximum protection.

8. How Most YouTube Channels Get Hacked

Many channels are hacked through social engineering.

Fake Sponsorship Emails

Creators receive emails offering sponsorships.

These emails contain files such as:

ZIP archives
Fake contracts
Malware disguised as documents

Opening these files can steal login cookies and session tokens.

Fake Copyright Emails

Attackers send emails pretending to be YouTube support.

The email contains a fake login page.

Entering your password allows attackers to access your account.

Malicious Browser Extensions

Some extensions promise:

Subscriber growth
Analytics tools
Automation features

But secretly steal account data.

Always install extensions from trusted developers.

Pirated Software

Cracked editing software or plugins often contain malware.

These can steal browser cookies and bypass 2FA.

Team Member Security Risks

If an editor’s Gmail account is hacked, attackers may gain channel access.

Always give editors limited permissions.

9. What to Do if Your Channel Is Hacked

If your channel is compromised:

Secure your Google account immediately
Remove unknown devices
Reset your password
Contact YouTube Creator Support

Acting quickly can help recover the channel.

10. Step-by-Step Guide to Creating a Secure YouTube Channel

Here is a simple setup process.

Step 1: Create a Dedicated Owner Gmail

Use this account only for channel ownership.

Example:

owner.maruf@gmail.com

Step 2: Create a Backup Gmail

Example:

maruf.backup@gmail.com

This account will be your secondary owner.

Step 3: Enable Security Settings

Activate:

Two-Factor Authentication
Recovery email
Security alerts

Step 4: Create a Brand Account Channel

Create your channel under a Brand Account instead of your personal Gmail.

Example:

Channel Name: Tech Creator BD

Step 5: Add the Backup Owner

Add your second Gmail as Owner in channel permissions.

Step 6: Add Editors

Editors can upload videos without accessing your Gmail.

Step 7: Connect AdSense When Eligible

When you meet the requirements for monetization, connect your AdSense account.

Payment profile name must match your legal identity.

11. Monetization Requirements

To join the YouTube Partner Program you must meet one of these:

Standard Path

1,000 subscribers
4,000 watch hours in the last 12 months

Shorts Path

1,000 subscribers
10 million Shorts views in 90 days

Early Fan Funding Access

500 subscribers
3 uploads in 90 days
3,000 watch hours or 3 million Shorts views

12. Strategy to Reach Monetization Faster

Many creators grow faster using a Shorts + Long Video strategy.

Shorts

Purpose: discoverability

Length: 10–30 seconds

Goal:
1–2 Shorts per day

Long Videos

Purpose: watch time

Length: 6–12 minutes

Goal:
2–3 long videos per week

13. Focus on One Niche

Channels grow faster when focused on one topic.

Examples:

Programming
Technology
Education
Finance
Productivity

Consistency helps the algorithm recommend your content.

14. Improve Titles and Thumbnails

Bad title:

C++ Tutorial

Better title:

Learn C++ in 15 Minutes – The Fastest Beginner Guide

Thumbnails should include:

Large readable text
Strong contrast
Clear visual focus

15. Use Trending Topics

Combining your niche with trending topics helps growth.

Example topics for programming channels:

AI tools for developers
Coding interview tips
LeetCode strategies

Trending topics bring new viewers through search and recommendations.

16. Upload Consistently

Recommended schedule:

Daily
1–2 Shorts

Weekly
2–3 long videos

Consistency increases algorithm visibility.

17. Analyze YouTube Analytics

Important metrics include:

Click-through rate: 6–10%

Audience retention: 40–60%

Improving these metrics increases recommendations.

Final Thoughts

Building a YouTube channel is not just about uploading videos.

Success requires understanding:

Account structure
Identity verification
AdSense requirements
Security practices
Content strategy

A secure and well-structured channel protects your work and ensures that when monetization arrives, you can receive payments smoothly.

By combining proper account setup, strong security, and consistent content creation, creators can grow their channels safely and sustainably.

Nil Pointer Panic at 3 AM: Choosing the Right Go Database Tool to Save Your Sleep

Md. Maruf Sarker — Tue, 26 Aug 2025 16:30:03 +0000

It’s a familiar horror story for backend developers: a frantic alert wakes you up, and you trace the production error back to a nil pointer dereference.

The culprit? A simple typo in a raw SQL query string that went unnoticed until it was too late.

This isn't just a bug; it's a symptom of the tools we use.

In Go, how we talk to our database can mean the difference between compile-time confidence and runtime nightmares.

So, how do we choose the right tool for the job?

Let's explore four popular approaches—database/sql, SQLX, GORM, and SQLC—by looking at what they are, why you'd use them, and how they handle a simple, real-world task: fetching a user account from a database.

The Foundation: database/sql

What is it?

This is Go's built-in, standard library for database access. It provides a lightweight, no-frills interface for executing raw SQL queries.

It's not a driver itself but defines the standard interface that drivers for databases like PostgreSQL or MySQL must implement.

Why use it?

You use database/sql when you need maximum performance and direct control.

There are no abstractions between you and your SQL, meaning no hidden overhead.

How does it work?

Let's fetch an account. Notice the manual, error-prone process of scanning each column into a struct field.

// Assume db is an initialized *sql.DB

type Account struct {
    ID        int64
    Owner     string
    Balance   int64
    Currency  string
    CreatedAt time.Time
}

func GetAccount(db *sql.DB, id int64) (Account, error) {
    var account Account
    row := db.QueryRow("SELECT id, owner, balance, currency, created_at FROM accounts WHERE id = $1", id)

    // Manually scan each column into the struct's fields.
    // A mismatch in order or a new column will break this at runtime.
    err := row.Scan(
        &account.ID,
        &account.Owner,
        &account.Balance,
        &account.Currency,
        &account.CreatedAt,
    )
    if err != nil {
        return Account{}, err
    }
    return account, nil
}

The Verdict:
Powerful and fast, but verbose and risky for anything complex.
A typo in the SELECT statement or changing the column order will only be caught when row.Scan fails in production.

The Convenient Extension: SQLX

What is it?

sqlx is a popular library that builds directly on top of database/sql.
It doesn't change the fundamentals but adds a set of extensions to make common tasks dramatically easier, especially scanning query results into structs.

Why use it?

You want the performance and control of raw SQL but hate the boilerplate of manual scanning.
sqlx is the perfect middle ground.

How does it work?

sqlx uses struct tags and reflection to automatically map column names to struct fields. Look how much cleaner our function becomes.

// Assume db is an initialized *sqlx.DB

type Account struct {
    ID        int64     `db:"id"`
    Owner     string    `db:"owner"`
    Balance   int64     `db:"balance"`
    Currency  string    `db:"currency"`
    CreatedAt time.Time `db:"created_at"`
}

func GetAccount(db *sqlx.DB, id int64) (Account, error) {
    var account Account
    // No more manual scanning! sqlx handles it.
    err := db.Get(&account, "SELECT * FROM accounts WHERE id = $1", id)
    if err != nil {
        return Account{}, err
    }
    return account, nil
}

The Verdict:
A fantastic quality-of-life improvement over database/sql.
It's still executing raw SQL, so query typos are a runtime problem, but the data mapping is much safer and less tedious.

The Full Abstraction: GORM

What is it?

GORM is a full-featured Object-Relational Mapper (ORM).
It abstracts away SQL entirely, allowing you to interact with your database using Go code and structs.

Why use it?

You want to develop quickly. GORM handles the SQL generation for common CRUD (Create, Read, Update, Delete) operations, saving you from writing repetitive queries.
It's great for rapid prototyping and standard application development.

How does it work?

With GORM, you call Go methods that the library translates into SQL. Our GetAccount function no longer contains any SQL.

// Assume db is an initialized *gorm.DB

// GORM uses struct tags for table and column mapping.
type Account struct {
    ID        int64 `gorm:"primaryKey"`
    Owner     string
    Balance   int64
    Currency  string
    CreatedAt time.Time
}

func GetAccount(db *gorm.DB, id int64) (Account, error) {
    var account Account
    // GORM generates the "SELECT * FROM accounts WHERE id = ?" query.
    result := db.First(&account, id)
    if result.Error != nil {
        return Account{}, result.Error
    }
    return account, nil
}

The Verdict:
Incredibly fast for development, but it comes with trade-offs.
You're learning GORM's API instead of SQL, and the generated queries might not be as performant as hand-written ones.
It can feel like "magic," which can be difficult to debug on high-load systems.

The Compile-Time Guardian: SQLC

What is it?

SQLC is a modern marvel. It's not an ORM or a library; it's a code generator.
You write raw SQL queries in .sql files, and sqlc generates fully type-safe, idiomatic Go code that you can call in your application.

Why use it?

You want the performance of raw SQL and the safety of a compiler.
sqlc catches errors in your SQL before your application ever runs.

How does it work?

It's a two-step process. First, you write the SQL.

-- file: query.sql
-- name: GetAccount :one
SELECT * FROM accounts
WHERE id = $1 LIMIT 1;

Then, you run the sqlc generate command. It creates a Go file with this function:

// file: query.sql.go (auto-generated by sqlc)

// ... (structs and db connection setup)

func (q *Queries) GetAccount(ctx context.Context, id int64) (Account, error) {
    row := q.db.QueryRowContext(ctx, getAccount, id)
    var i Account
    // The generated code is guaranteed to match your query.
    err := row.Scan(
        &i.ID,
        &i.Owner,
        &i.Balance,
        &i.Currency,
        &i.CreatedAt,
    )
    return i, err
}

If you had a typo in query.sql (e.g., SELEC *), sqlc would fail to generate code, giving you an immediate error.

The Verdict:
The best of all worlds for many applications.
It gives you the full power of SQL, the performance of database/sql, and the safety of compile-time checks.
The initial setup is slightly more involved, but it pays for itself by preventing entire classes of runtime bugs.

Conclusion: Which Tool Should You Use?

For ultimate control and micro-optimizations: Stick with database/sql.
For a simple, ergonomic boost over the standard library: sqlx is your go-to.
For rapid development and CRUD-heavy apps: GORM will get you moving the fastest.
For building robust, performant, and type-safe applications: sqlc is the modern, superior choice that will save you from those 3 AM production alerts.

Choose wisely, and happy coding!

What's Really Powering Your Computer? Meet the Daemons

Md. Maruf Sarker — Wed, 02 Jul 2025 10:13:14 +0000

Hey everyone!

You know that feeling when you hit "print" and your document just… prints? Or click a web link and, boom, there's a page? It feels like magic, right? But behind all that instant gratification, lurking just out of sight, is a whole silent army making it happen. And no, I'm not talking about mythical beasts (though the name might suggest it!). I'm talking about something called a daemon.

In the tech world, a daemon (pronounced "DAY-mon" or "DEE-mon," depending on who you ask!) is simply a computer program that chills out in the background, doing its job without you ever needing to click on it. Think of them as your computer's dedicated, always-on personal assistants.

Why Do These "Invisible Helpers" Even Exist?

Seriously, why can't everything just have a window I can click? Well, imagine the chaos:

Printer Panic: Every time you wanted to print, you'd have to manually open a "printer manager" app, find your file, hit print, and then keep the app open until it finished! What a nightmare.
Web Server Woes: Your website would only be online when you had its server application open and actively running on your screen. Close the window? Website's down!

See? Totally impractical. Daemons solve this by being:

Always On, Always Ready: They're like that 24/7 convenience store of your operating system – always open for business.
Set It and Forget It: Once they're running, they handle their tasks independently. You don't need to babysit them.
The Unsung System Stewards: Many daemons manage critical system resources and low-level functionalities that regular user applications typically don't directly control.
Efficiency Experts: By having one dedicated helper for a task, it's way more efficient than every app trying to do the same thing at once.

Meet the Daemons: You Use Them Every Day!

You probably interact with daemons constantly without even realizing it. They're that good at being invisible!

The SSH Daemon (sshd): Ever logged into a remote server from your terminal? That's sshd on the server-side, patiently listening for your connection and making sure you're allowed in.
Web Server Daemons (httpd or nginx): Every single website you visit is served up by one of these guys, listening for your browser's request and sending back the web page.
The Print Daemon (cupsd): If you've ever printed from your Linux machine, this daemon is responsible for managing your print queue and sending documents to the printer.
systemd (The Daemon Overlord): This one's the big boss. When your Linux machine boots up, systemd is the very first thing to run, and its job is to launch, manage, and oversee almost all the other daemons and services. Talk about a full-time job!
The Docker Daemon (dockerd): For anyone working with containers, dockerd is the central figure. When you type a docker command (like docker run or docker build), your command-line tool actually just sends a message to the dockerd daemon, and the daemon then handles all the heavy lifting of creating and managing your containers, images, networks, and volumes.

Wrapping It Up

So, the next time you marvel at your internet speed popping up in the corner of your screen (thanks, GNOME extensions!) or a massive software project compiles smoothly, take a moment to appreciate the unsung heroes – the daemons. They're the invisible, dedicated workhorses that keep your digital life running smoothly, and understanding them helps us appreciate the clever engineering behind our favorite operating systems.

What are your favorite "silent heroes" on your system? Let me know in the comments!

Docker Buildx: Build Multi-Platform Images Like a Pro

Md. Maruf Sarker — Tue, 01 Jul 2025 05:16:22 +0000

When building Docker images, developers often face platform compatibility issues — especially when deploying to different architectures like amd64 or arm64 (used in newer Macs, Raspberry Pi, cloud servers, etc.). Thankfully, Docker Buildx is here to solve that problem.

In this post, you’ll learn what Buildx is, why it matters, and how to use it with real examples.

🔍 What Is Docker Buildx?

Docker Buildx is an extended build command that provides advanced features powered by BuildKit, including:

Multi-platform image builds (e.g., linux/amd64, linux/arm64)
Faster builds with cache
Cross-platform CI/CD pipelines
Export options for Docker Hub, tar files, and more

🤔 Why Use Docker Buildx?

Imagine building a Docker image on your Mac (which runs on ARM64) and trying to deploy it to a cloud server (which runs on AMD64). Without Buildx, this mismatch often breaks your app.

With Buildx, you can build a single image that works on multiple platforms like so:

docker buildx build --platform linux/amd64,linux/arm64 ...

No compatibility issues. No surprises.

🛠️ How to Use Docker Buildx

1. Set Up Buildx

Docker Buildx is built into Docker 19.03 and above.

Run this to create and use a new builder:

docker buildx create --use

(Optional) Bootstrap and inspect:

docker buildx inspect --bootstrap

2. Build a Multi-Platform Docker Image

Let’s say you have a simple Dockerfile:

# Dockerfile
FROM node:20-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Now build and push a multi-arch image:

docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t yourusername/yourimage:latest \
  --push .

3. Automate with GitHub Actions

You can integrate Buildx into CI/CD pipelines like this:

name: Docker Image CI

on:
  push:
    branches: [ "main" ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Log in to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Build and Push Multi-Platform Image
        run: |
          docker buildx build \
            --platform linux/amd64,linux/arm64 \
            -t yourusername/yourimage:latest \
            --push .

Set your Docker Hub credentials as GitHub Secrets named DOCKER_USERNAME and DOCKER_PASSWORD.

4. Inspect Image Platform Support

Check what platforms your Docker image supports:

docker buildx imagetools inspect yourusername/yourimage:latest

Bonus: Clean Up

Clean unused resources:

docker system prune -af          # Remove all unused data
docker builder prune             # Clean up Buildx cache

Final Thoughts

Docker Buildx is a must-have tool for modern DevOps workflows. Whether you’re building locally or automating in CI/CD, it ensures your images are compatible across different environments.

If you want your Docker images to “just work” anywhere — use Buildx!

Quick Reference

# Enable Buildx
docker buildx create --use

# Multi-arch build & push
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t your/image:latest \
  --push .

# Inspect the image
docker buildx imagetools inspect your/image:latest

What Can In-Browser JavaScript Do and What are its Limitations?

Md. Maruf Sarker — Wed, 18 Dec 2024 12:25:12 +0000

JavaScript is a powerful and versatile programming language primarily designed for use in web browsers. It allows developers to create dynamic and interactive web experiences. However, its capabilities are deliberately restricted to ensure user safety and privacy. Here’s a closer look at what in-browser JavaScript can and cannot do.

What Can In-Browser JavaScript Do?

In-browser JavaScript enables developers to interact with and manipulate web pages, users, and servers. Here are some of its key capabilities:

Webpage Manipulation:
- JavaScript can add new HTML elements to a webpage, modify existing content, and change styles dynamically.
- This is used for creating interactive features like dynamic menus, image sliders, and live content updates.
User Interaction:
- It can respond to user actions such as mouse clicks, pointer movements, and key presses.
- For example, JavaScript can validate form inputs, show tooltips, or handle drag-and-drop actions.
Network Communication:
- JavaScript can send and receive data from servers without requiring a page reload.
- This is done using technologies like AJAX (Asynchronous JavaScript and XML) and COMET, enabling seamless interactions like live chat or real-time notifications.
Working with Cookies and Local Storage:
- JavaScript can read, set, and delete browser cookies.
- It can also store data on the client side using local storage or session storage, which is useful for remembering user preferences or temporarily storing form data.
User Notifications and Prompts:
- It can display messages to users, such as alerts or confirmation boxes.
- JavaScript can also ask for input or notify users through browser notifications.
Device Interaction (With Permissions):
- JavaScript can interact with hardware devices like cameras, microphones, and GPS, but only with explicit user consent.
- This is commonly used for video conferencing apps or location-based services.

What Can’t In-Browser JavaScript Do?

JavaScript's in-browser limitations exist to protect users from malicious websites. Here are some key restrictions:

Access to Local Files and System Functions:
- JavaScript cannot read, write, or execute files on the user’s hard drive.
- File access is limited to scenarios where the user explicitly selects or uploads files, such as through an <input> element or drag-and-drop actions.
Unauthorized Hardware Access:
- JavaScript cannot enable or use devices like cameras, microphones, or sensors without the user’s explicit permission.
- For example, a malicious webpage cannot secretly activate your webcam or microphone.
Cross-Tab and Cross-Domain Restrictions:
- By default, JavaScript cannot access data from other tabs or browser windows, even if they are open simultaneously.
- This is enforced by the Same Origin Policy, which blocks JavaScript from accessing content from a different domain, protocol, or port.
- Cross-origin communication is possible but requires explicit permissions through mechanisms like CORS (Cross-Origin Resource Sharing).
Restricted Network Communication:
- While JavaScript can send requests to servers, it is limited to the domain the current webpage originated from unless the target domain explicitly allows cross-origin requests.
- This prevents unauthorized data exchange between websites.
System-Level Operations:
- JavaScript cannot interact directly with the operating system, such as modifying system settings, installing software, or running external programs.

Why Are These Limitations in Place?

The restrictions on in-browser JavaScript are designed with user safety and privacy in mind. Without these limitations, malicious websites could:

Access sensitive information from other browser tabs, such as login sessions or personal data.
Execute harmful actions on the user’s device, such as deleting files or stealing data.
Spy on users through unauthorized hardware access.

By enforcing these boundaries, browsers create a secure environment where JavaScript can be safely executed without compromising user trust.

Conclusion

In-browser JavaScript is a versatile tool that forms the backbone of modern web development. It enables dynamic webpage content, interactive user interfaces, and seamless server communication. However, it operates within strict security boundaries to ensure user safety. Understanding what JavaScript can and cannot do is crucial for developers aiming to build secure and efficient web applications.

Job Interview Preparation as a Programmer

Md. Maruf Sarker — Wed, 18 Dec 2024 12:07:59 +0000

Step 1: Understand the Interview Process

What to Do:
- Learn about the interview stages and the expectations for your target roles and companies.
- Research interview experiences on platforms like Glassdoor.
Resources:
- Glassdoor: Company-specific interview questions.
- Levels.fyi: Compensation and role expectations.

Step 2: LeetCode and DSA Mastery

Beginner Level:
- Solve easy problems and understand how to approach coding questions.
- Focus on basic DSA concepts.

Resources:

NeetCode Roadmap: Free curated playlists for DSA.
LeetCode Explore: Beginner-friendly study plans.

Intermediate Level:
- Progress to medium problems and implement common patterns.

Resources:

Blind 75: Top 75 problems covering key patterns.
Books:
- "Cracking the Coding Interview" by Gayle Laakmann McDowell.

Advanced Level:
- Tackle hard problems and mock interviews.

Resources:

Codeforces: Competitive programming for advanced problem-solving.
InterviewBit: Coding practice tailored for interviews.

Step 3: Strengthen CS Fundamentals

Operating Systems:
- Learn processes, threads, concurrency, and memory management.

Resources:

Operating Systems: Three Easy Pieces: Free textbook.
MIT OpenCourseWare: Operating Systems: Lecture videos.

Databases:
- Focus on SQL, database normalization, indexing, and transactions.

Resources:

SQLZoo: Hands-on practice for SQL queries.
DBMS by Gate Smashers: In-depth video tutorials.

Computer Networks:
- Study networking protocols, TCP/IP, and HTTP basics.

Resources:

Computer Networking: Principles, Protocols, and Practice: Free book.
Stanford Lecture Series on Networking: Practical approach.

OOP Principles:
- Master design patterns, inheritance, and polymorphism.

Resources:

Refactoring Guru: Visual guide to design patterns.
Books:
- "Head First Design Patterns" by Eric Freeman.

System Design:
- Learn to build scalable systems.

Resources:

Grokking the System Design Interview: Paid course.
System Design Primer: Free GitHub repository.

Step 4: Develop Practical Coding Skills

Projects:
- Build full-stack projects and deploy them.

Resources:

freeCodeCamp: Full-stack project tutorials.
The Odin Project: Beginner-friendly resources.

Version Control:
- Learn Git for collaboration.

Resources:

Pro Git: Free book.
GitHub Learning Lab: Interactive Git tutorials.

Open Source:
- Contribute to repositories.

Resources:

GitHub Explore: Find open-source projects.
First Contributions: Beginner-friendly open-source guide.

Step 5: Behavioral and Soft Skills

STAR Method:
- Structure answers for behavioral questions.

Resources:

Big Interview: Behavioral interview tips.
YouTube: STAR Method Explained: Free video explanations.

Communication:
- Practice explaining code out loud during mock interviews.

Resources:

Mock Interview Platforms: Free mock interviews.

Step 6: Mock Interviews

Simulate Real Interviews:
- Pair up with peers or use platforms.

Resources:

Pramp: Free peer-to-peer mock interviews.
Interviewing.io: Mock interviews with professionals.

AI-Based Feedback:
- Use platforms providing AI-driven feedback.

Resources:

HackerRank Interview Preparation Kit: Comprehensive prep resources.

Step 7: Job-Specific Skills

Cloud Computing (if relevant):
- Learn AWS, Azure, or Google Cloud basics.

Resources:

AWS Free Tier: Practice cloud tools.
A Cloud Guru: Paid courses.

Domain-Specific Knowledge:
- Learn AI/ML, DevOps, or cybersecurity based on interests.

Resources:

Coursera: Domain-specific courses.
Kaggle: AI/ML practice.

Step 8: Final Preparations

Revise Key Topics:
- Review solved problems and core concepts.

Resources:

[Your Notes]: Keep a concise summary of key concepts.
Anki: Use flashcards for quick revision.

Mock Interviews:
- Conduct technical and behavioral mock interviews.

Resources:

GeeksforGeeks Interview Experiences: Company-specific prep.

Step 9: Relax and Build Confidence

Take breaks, exercise, and ensure you’re mentally prepared for interviews.

Summary Table of Resources

Topic	Resource Link
DSA Practice	LeetCode, NeetCode
System Design	System Design Primer
Computer Networks	CS144, Networking Book
SQL	SQLZoo, LeetCode SQL
Behavioral Questions	Big Interview, Glassdoor
Mock Interviews	Pramp, Interviewing.io
Full-Stack Projects	freeCodeCamp, The Odin Project