DEV Community: Md Abu Musa

cURL: The Swiss Army Knife of Data Transfer

Md Abu Musa — Mon, 26 Jan 2026 06:30:13 +0000

Introduction

curl (Client URL) is one of the most powerful and widely used command-line tools in software engineering. It enables data transfer between a client and a server using various network protocols. From testing REST APIs to downloading files, debugging HTTP requests, and automating workflows, curl is an essential tool for developers, system administrators, and DevOps engineers.

This blog explores what curl is, how it works, its most common use cases, and practical examples that you can apply in real-world scenarios.

What Is cURL?

curl is an open-source command-line tool and library (libcurl) used to transfer data to or from a server using URLs. It supports a wide range of protocols, including:

HTTP / HTTPS
FTP / FTPS
SCP / SFTP
SMTP / POP3 / IMAP
LDAP
MQTT
FILE

The tool is available by default on most Linux and macOS systems and can be installed easily on Windows.

Why cURL Is Important

curl is popular because it is:

Lightweight and fast
Scriptable (perfect for automation)
Protocol-agnostic
Widely supported
Ideal for API testing and debugging

In backend development and DevOps, curl is often the first tool used to verify whether a service or endpoint is working correctly.

Basic cURL Syntax

curl [options] URL

Example:

curl https://example.com

This sends a basic HTTP GET request and prints the response body to the terminal.

Common HTTP Operations with cURL

1. GET Request

curl https://api.example.com/users

Used to retrieve data from a server.

2. POST Request

curl -X POST https://api.example.com/users \
     -H "Content-Type: application/json" \
     -d '{"name":"Musa","email":"musa@example.com"}'

Used to send data to the server, commonly for creating resources.

3. PUT Request

curl -X PUT https://api.example.com/users/1 \
     -H "Content-Type: application/json" \
     -d '{"name":"Updated Name"}'

Used to update existing resources.

4. DELETE Request

curl -X DELETE https://api.example.com/users/1

Used to delete a resource.

Working with Headers

Send Custom Headers

curl -H "Authorization: Bearer TOKEN" \
     -H "Accept: application/json" \
     https://api.example.com/profile

View Response Headers

curl -i https://example.com

Authentication with cURL

Basic Authentication

curl -u username:password https://api.example.com

Bearer Token Authentication

curl -H "Authorization: Bearer YOUR_TOKEN" https://api.example.com

Handling JSON Responses

To pretty-print JSON responses, combine curl with jq:

curl https://api.example.com/users | jq

This is extremely useful when debugging APIs.

File Upload and Download

Download a File

curl -O https://example.com/file.zip

Upload a File

curl -F "file=@image.png" https://api.example.com/upload

Debugging and Verbose Mode

Verbose Output

curl -v https://example.com

This shows:

Request headers
Response headers
TLS handshake details

Very useful for debugging network issues.

Timeouts and Retries

Set Timeout

curl --max-time 10 https://example.com

Retry on Failure

curl --retry 3 https://example.com

Following Redirects

curl -L https://example.com

By default, curl does not follow redirects unless explicitly told.

Using cURL in Automation and Scripts

curl is commonly used in:

CI/CD pipelines
Health checks
Cron jobs
Shell scripts
Server monitoring

Example health check:

curl -f https://api.example.com/health || exit 1

Security Best Practices

Avoid exposing tokens in terminal history
Use environment variables for credentials
Prefer HTTPS over HTTP
Validate SSL certificates (avoid -k in production)

cURL vs Postman

Feature	cURL	Postman
Command-line	✅	❌
Automation	✅	Limited
GUI	❌	✅
Lightweight	✅	❌
CI/CD friendly	✅	❌

Best practice: Use Postman for exploration and curl for automation and production debugging.

Conclusion

curl is an indispensable tool for modern software engineering. Its simplicity, flexibility, and power make it ideal for API testing, system administration, and automation tasks. Mastering curl significantly improves your ability to debug, test, and interact with network services efficiently.

Whether you are a backend engineer, DevOps professional, or software architect, curl deserves a permanent place in your toolkit.

Ubuntu Server Resource Monitoring via Command Line

Md Abu Musa — Sat, 13 Dec 2025 14:52:54 +0000

Monitoring system resources is a critical responsibility for backend engineers, DevOps engineers, and system administrators. Whether you are running a Laravel API, Node.js app, Docker containers, or an AWS EC2 instance, understanding how your Ubuntu server consumes CPU, memory, disk, and network resources helps you:

Detect performance bottlenecks early
Prevent unexpected downtime
Optimize application performance
Make informed scaling decisions

This blog provides a professional, practical, and production-oriented guide to checking system resource usage on an Ubuntu Server using only command-line tools.

1. Why Resource Monitoring Matters

In real-world production environments, issues like:

Slow API responses
Sudden 504 Gateway Timeout errors
Random application crashes
Server freeze or reboot

are often symptoms of resource exhaustion rather than application bugs.

Regular monitoring helps answer critical questions:

Is CPU overloaded?
Is RAM exhausted or swapping?
Is disk space full?
Is disk I/O causing delays?
Which process is consuming the most resources?

2. Quick System Health Overview

Command

uptime

What it shows

System running time
Number of logged-in users
Load average (1, 5, 15 minutes)

How to interpret load average

If your server has 4 CPU cores:

Load average ≈ 4 → normal
Load average > 4 → CPU under pressure
Load average >> 4 → serious performance issue

This is the fastest health check command you should use first.

3. Real-Time CPU and Memory Monitoring

Using `top`

top

Key metrics

%CPU → CPU usage per process
%MEM → Memory usage per process
load average → overall CPU load

Useful shortcuts

Shift + P → sort by CPU usage
Shift + M → sort by memory usage
q → quit

top is available by default on all Ubuntu servers.

Using `htop` (Recommended)

sudo apt install htop
htop

Why `htop` is better

Color-coded CPU and memory bars
Easy process killing
Tree view of processes
Mouse support

For daily production monitoring, htop is strongly recommended.

4. Memory (RAM) Usage Analysis

Command

free -h

Key fields explained

total → Total RAM
used → Used memory
available → Memory available for new processes

⚠️ Important: Always focus on available, not free. Linux uses free memory for caching, which is normal and healthy.

If available memory is very low, your server may start swapping or killing processes.

5. Disk Usage Monitoring

Overall disk usage

df -h

Shows:

Total disk size
Used space
Available space
Mount points

⚠️ If disk usage reaches 90%+, services like MySQL, Redis, or Docker may fail.

Directory-wise disk usage

du -sh /path/to/directory

Example:

du -sh /var/www
du -sh /var/log

This helps identify which folders are consuming disk space.

6. CPU Information and Core Count

Command

lscpu

Provides:

CPU architecture
Number of cores
Threads per core
CPU model

Knowing the core count is essential for correctly interpreting load average.

7. Network Usage Monitoring

Basic network statistics

ip -s link

Shows transmitted and received packets per network interface.

Real-time network monitoring

sudo apt install nload
nload

Useful when:

APIs feel slow
Upload/download speed is suspicious
External service calls timeout

8. Disk I/O Performance (Often Overlooked)

High disk I/O wait can slow down applications even when CPU and RAM look normal.

Command

sudo apt install sysstat
iostat

Look for:

High %iowait
Slow read/write rates

This is critical for database-heavy applications.

9. Identify Resource-Hungry Processes

Top memory-consuming processes

ps aux --sort=-%mem | head

Top CPU-consuming processes

ps aux --sort=-%cpu | head

This is extremely useful during production incidents.

10. One-Command Live Summary

Command

vmstat 1

Updates every second and shows:

CPU usage
Memory usage
Swap activity
Disk I/O

A powerful command for advanced troubleshooting.

11. Recommended Monitoring Workflow (Production)

uptime → Quick health check
htop → Live CPU & memory monitoring
free -h → Memory availability
df -h → Disk usage
iostat → Disk I/O issues
ps aux → Identify problematic processes

12. Conclusion

Command-line monitoring tools are lightweight, fast, and reliable, making them perfect for Ubuntu servers in production.

By mastering these commands, you can:

Debug performance issues confidently
Reduce downtime
Communicate system health clearly to your team
Grow from a backend engineer into a strong DevOps-aware professional

Regular monitoring is not optional — it is a core engineering habit.

[Boost]

Md Abu Musa — Fri, 12 Dec 2025 03:32:21 +0000

Md Abu Musa

Dec 9 '25

Why Your EC2 Server Suddenly Stops Responding — And How to Bulletproof Laravel & Node Apps

#devops #node #performance #aws

Comments

3 min read

Why Your EC2 Server Suddenly Stops Responding — And How to Bulletproof Laravel & Node Apps

Md Abu Musa — Tue, 09 Dec 2025 16:50:34 +0000

Managing multiple Laravel and Node.js applications on a single EC2 instance is common in small and mid-sized teams. However, when several applications share the same resources, one heavy operation can freeze the entire server — causing all domains to go down at the same time.

Recently, we faced a similar issue:
all test and development domains stopped responding simultaneously, even though no code changes were deployed on some of them. The root cause was not immediately clear.

After detailed inspection, the problem turned out to be resource exhaustion caused by a Node build process running directly on the server.

This article explains why this happens, how to diagnose it, and what steps you should take to prevent it permanently.

What Actually Happened?

According to the internal investigation, the issue was caused by:

“The server was unable to load the build and hung the system.”

When someone runs npm run build or yarn build directly inside an EC2 instance — especially an instance with limited RAM (1–2GB) — Node consumes a large amount of memory to compile and optimize frontend assets.

As memory usage increases, the server begins to:

Swap aggressively
Kill processes
Freeze PHP-FPM
Stall Nginx worker processes
Hang SSH access
Stop responding to all HTTP requests

Because all Laravel apps, Node apps, queue workers, and socket services run under the same OS, the entire system becomes unresponsive.

Why a Node Build Freezes Small EC2 Instances

Node.js build tools like Vite, Webpack, or Next.js require high memory to:

Minify large JS bundles
Optimize images
Handle TypeScript
Perform tree-shaking
Build multiple targets

On servers with low memory, this triggers:

1. 100% CPU consumption

Node compilers go full throttle.

2. RAM exhaustion

Node often needs 512 MB – 2 GB per build.
This is too heavy for small EC2 instances.

3. Out-of-Memory (OOM) kills

The kernel automatically kills PHP-FPM or MySQL first instead of Node.

4. Nginx stops responding

Since PHP-FPM dies, Nginx returns 502/504 or hangs completely.

5. SSH becomes slow

If swap memory also fills up, the OS stops scheduling tasks.

This chain reaction brings down every domain hosted on the server.

How to Prevent This Problem in the Future

Here are practical and immediate measures to avoid similar outages.

1. Never Build Frontend Code on Production or Test Servers

Instead:

Build locally
Build in CI/CD
Upload only the final dist/ or build/ folder
Deploy the compiled assets

This alone prevents 80% of such incidents.

2. Add a 2GB Swap File

If you're using a small EC2 instance (t2.micro, t3.small, etc.), create a swap file:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo "/swapfile swap swap defaults 0 0" | sudo tee -a /etc/fstab

Swap helps the OS avoid crashing when memory runs out.

3. Limit Node.js Memory Usage (PM2 Protection)

If apps are running under PM2, apply memory protection:

pm2 restart <app> --max-memory-restart=300M

Or apply to all:

pm2 restart all --max-memory-restart=300M

This prevents any single Node app from consuming all memory.

4. Restart PHP-FPM & Nginx During High Load

If the server slows down or freezes:

sudo systemctl restart php8.1-fpm
sudo systemctl restart nginx

This often restores service instantly.

5. Monitor Real-Time Resource Usage with htop

Install:

sudo apt install htop

Run:

htop

This lets you identify:

Which process is consuming CPU
Which service is consuming RAM
Stuck or zombie processes

6. Use PM2 Startup to Ensure Node Apps Auto-Restart on Reboot

pm2 startup
pm2 save

This ensures Node apps come back automatically after a server reboot.

7. Use a Deployment Pipeline

The most reliable long-term solution:

GitHub Actions
GitLab CI
Bitbucket Pipelines
Jenkins

Build assets before deploying, not on the server.

Conclusion

When multiple applications share a single EC2 instance, one heavy task — such as a Node build — can overload system resources and freeze the entire machine. This can bring down all domains and services at once.

To prevent this, teams should:

Avoid running builds directly on servers
Add swap memory
Limit Node memory usage
Monitor resource consumption
Use CI/CD pipelines

By applying these preventive measures, you ensure stable performance and avoid sudden downtime in development, test, or even production environments.

[Boost]

Md Abu Musa — Thu, 02 Oct 2025 13:04:28 +0000

Md Abu Musa

Oct 2 '25

How I Optimized a Laravel API 287x Faster: From 27s to Under 100ms

#laravel #performance #productivity #mysql

Comments

3 min read

How I Optimized a Laravel API 287x Faster: From 27s to Under 100ms

Md Abu Musa — Thu, 02 Oct 2025 13:01:22 +0000

Transforming a sluggish patient list API into a lightning-fast, production-ready endpoint through strategic database optimization and response streamlining.

The Problem: A Performance Nightmare

Picture this: You're working on a healthcare application with a patient list API that's taking 27+ seconds to load just 600 patients. Users are frustrated, the database is overwhelmed, and your server costs are skyrocketing. This was the reality I faced when analyzing our patientList API.

Initial Performance Metrics (The Bad News)

Response Time: 27.43 seconds 😱
Database Queries: 4,440+ queries
Model Instantiations: 5,320+ objects
Memory Usage: 20MB
User Experience: Completely unusable

The API was suffering from the classic N+1 query problem on steroids, with additional issues like unnecessary data transfer and missing database indexes.

The Investigation: Root Cause Analysis

1. The N+1 Query Monster

// The problematic code (simplified)
foreach($patientData as $key => $pd) {
    $pd->userInfo->user_uuid;           // Query 1 per patient
    $pd->officeInfo->office_name;       // Query 2 per patient
    $this->findPatientDefaultData(...); // Query 3 per patient
    $this->findPatientInsurance(...);   // Query 4 per patient
    // ... and so on
}

For 600 patients, this meant 4,440+ individual database queries just in the foreach loop!

2. Unnecessary Data Transfer

The API was returning 27+ fields per patient, including:

Personal details (SSN, addresses, BMI, weight)
Insurance information
Questionnaire data
Profile assets
Referral information

Most of this data wasn't being used by the frontend.

3. Missing Database Indexes

Critical columns lacked proper indexing, causing full table scans on every query.

The Solution: A Multi-Layered Optimization Strategy

Phase 1: Eliminate N+1 Queries with Eager Loading

// Before: N+1 queries
foreach($patientData as $key => $pd) {
    $pd->userInfo->user_uuid; // Individual query per patient
}

// After: Batch loading with eager loading
$query = PatientUnderOffice::with([
    'userInfo:id,user_uuid,email,type',
    'officeInfo:id,office_name'
])->where('dentist_office_id', $dentist_office_id);

// Only load clinical visits in batch (for last_clinical_visit field)
$clinicalVisits = VisitFormMiscellaneousNote::select('patient_profile_id', 'date')
    ->whereIn('patient_profile_id', $patientProfileIds)
    ->whereIn('id', function($query) use ($patientProfileIds) {
        $query->select(DB::raw('MAX(id)'))
            ->from('visit_form_miscellaneous_notes')
            ->whereIn('patient_profile_id', $patientProfileIds)
            ->groupBy('patient_profile_id');
    })->get()->keyBy('patient_profile_id');

Phase 2: Streamline Response Structure

I identified that the frontend only needed 15 essential fields out of 42 total fields. Here's what I removed:

// Removed 27 unnecessary fields:
$removedFields = [
    'referred_by', 'assets', 'referral_type', 'referred_time', 'referred_note',
    'dentist_office', 'gender', 'marital_status', 'height', 'ssn',
    'address_one', 'address_two', 'city', 'state', 'zipCode', 'email',
    'bmi', 'weight', 'self_pay_status', 'created_at', 'updated_at',
    'employer_details', 'questionnaire_id', 'symptoms', 'epworth',
    'treatment', 'history', 'insurance', 'temp_updated_value'
];

// Kept only essential fields:
$essentialFields = [
    'id', 'user_id', 'user_uuid', 'patient_profile_id', 'dentist_office_id',
    'title', 'first_name', 'middle_name', 'last_name', 'preferred_name',
    'type', 'dob', 'phone_numbers', 'status', 'last_clinical_visit'
];

Phase 3: Add Strategic Database Indexes

// Migration: Add performance indexes
Schema::table('patient_under_offices', function (Blueprint $table) {
    $table->index('dentist_office_id');
    $table->index('status');
    $table->index('created_at');
    $table->index(['first_name', 'last_name']);
    $table->index(DB::raw('phone_numbers(50)'));
    $table->index('patient_profile_id');
});

Schema::table('users', function (Blueprint $table) {
    $table->index('email');
    $table->index('user_uuid');
});

// ... and more strategic indexes

Phase 4: Optimize Model Relationships

// Optimized relationships with selective field loading
public function userInfo()
{
    return $this->belongsTo('App\Models\User', 'user_id', 'id')
        ->select('id', 'user_uuid', 'email', 'type');
}

public function officeInfo()
{
    return $this->belongsTo('App\Models\DentistOfficeProfile', 'dentist_office_id', 'id')
        ->select('id', 'office_name');
}

The Results: From Nightmare to Dream

Performance Transformation

Metric	Before	After	Improvement
Response Time	27.43s	95.72ms	99.7% faster
Database Queries	4,440+	10	99.8% reduction
Model Instantiations	5,320+	1,796	66% reduction
Memory Usage	20MB	8MB	60% reduction
Response Size	Large	~2KB	70% smaller

Real-World Impact

User Experience: From completely unusable to instant loading
Server Costs: Massive reduction in database load
Scalability: Can now handle 10x more concurrent users
Maintenance: Cleaner, more focused codebase

Key Lessons Learned

1. Always Profile Before Optimizing

Use Laravel Debugbar or similar tools to identify the real bottlenecks. Don't guess!

2. N+1 Queries Are Performance Killers

Eager loading and batch queries should be your first optimization targets.

3. Less Data = Better Performance

Only return what the frontend actually needs. Every unnecessary field costs bandwidth and processing time.

4. Database Indexes Are Critical

Proper indexing can make the difference between a query taking 1ms vs 1000ms.

5. Measure Everything

Before and after metrics are crucial for proving the value of your optimizations.

Tools and Techniques Used

Laravel Debugbar: For performance profiling
Eager Loading: with() method for relationship optimization
Batch Queries: whereIn() for bulk data loading
Selective Field Loading: select() to limit data transfer
Database Indexes: Strategic indexing for query optimization
Response Streamlining: Removing unnecessary data fields

Conclusion

This optimization transformed a completely unusable API into a lightning-fast, production-ready endpoint. The key was taking a systematic approach:

Profile to identify bottlenecks
Eliminate N+1 queries with eager loading
Streamline the response structure
Index the database properly
Measure the results

The result? An API that's 287x faster and uses 99.8% fewer database queries. Sometimes the biggest performance wins come from the simplest optimizations.

Deploy Laravel on AWS EC2 with RDS MySQL and NGINX

Md Abu Musa — Tue, 05 Aug 2025 16:50:13 +0000

Setting up a Laravel application on AWS is a powerful way to scale your web applications in a secure and cloud-native environment. This guide walks you through deploying Laravel on an Ubuntu-based EC2 instance, connecting it to an Amazon RDS MySQL database, and using NGINX as the web server.

Prerequisites

Make sure you have the following:

✅ AWS EC2 instance (Ubuntu 22.04+ recommended)
✅ Amazon RDS MySQL database (accessible to EC2)
✅ Security Groups properly configured (EC2 <-> RDS: port 3306)
✅ NGINX installed on EC2
✅ SSH terminal access to EC2 (e.g., Termius)
✅ Laravel knowledge (Composer installed)

Step 1: Update Your Server & Install PHP and Required Extensions

sudo apt update && sudo apt upgrade -y
sudo apt install php php-fpm php-mysql php-xml php-mbstring php-curl php-zip unzip curl git -y

Step 2: Install Composer (PHP Dependency Manager)

cd ~
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
composer --version

Step 3: Create Laravel Project

cd /var/www/
sudo composer create-project laravel/laravel myapp
sudo chown -R ubuntu:ubuntu myapp

Tip: Replace myapp with your desired app folder name.

Step 4: Configure Laravel to Use Amazon RDS

Edit the .env file:

nano /var/www/myapp/.env

Update the DB connection settings:

DB_CONNECTION=mysql
DB_HOST=your-rds-endpoint.amazonaws.com
DB_PORT=3306
DB_DATABASE=yourdbname
DB_USERNAME=yourdbuser
DB_PASSWORD=yourdbpassword

Step 5: Generate Laravel App Key & Run Migration

Ensure the Laravel CLI (artisan) has permission to write logs:

sudo chown -R ubuntu:ubuntu /var/www/myapp

Then run:

cd /var/www/myapp
php artisan key:generate
php artisan migrate

✅ You should see success messages for both.

Step 6: Stop Apache (If Installed) & Configure NGINX

Apache often comes pre-installed — stop and disable it:

sudo systemctl stop apache2
sudo systemctl disable apache2

Create a new NGINX config:

sudo nano /etc/nginx/sites-available/laravel

Paste the following (replace <your-ip> and php8.3 if needed):

server {
    listen 80;
    server_name <your-ec2-public-ip>;

    root /var/www/myapp/public;

    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.ht {
        deny all;
    }
}

Enable the Laravel site:

sudo ln -s /etc/nginx/sites-available/laravel /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

Test and restart NGINX:

sudo nginx -t
sudo systemctl restart nginx

Step 7: Set Folder Permissions for Runtime

sudo chown -R www-data:www-data /var/www/myapp
sudo chmod -R 775 /var/www/myapp/storage
sudo chmod -R 775 /var/www/myapp/bootstrap/cache

Step 8: Visit Your Application

Go to your EC2 public IP in a browser:

http://<your-ec2-public-ip>

You should see the Laravel welcome page.

Escape Analysis in Go: Stack vs Heap Allocation Explained

Md Abu Musa — Sun, 13 Apr 2025 01:44:46 +0000

When writing Go code, performance matters. One of the less obvious performance factors is how variables are allocated in memory. Go manages memory automatically, but understanding escape analysis gives you the power to write more efficient code.

In this post, we’ll dive into:

What escape analysis is
Why it matters
How the Go compiler uses it
Real-world examples
How to inspect escape analysis in your code

🧠 What is Escape Analysis?

Escape analysis is a technique the Go compiler uses to determine whether a variable:

Stays within the current function → can be safely allocated on the stack
Escapes the current function → must be allocated on the heap

🪜 Stack vs Heap

Stack: Fast, automatically cleaned up when a function returns
Heap: Slower, needs garbage collection

Efficient programs aim to maximize stack allocations.

🚀 Why Does It Matter?

Heap allocations:

Are slower than stack allocations
Add pressure on the garbage collector
Can impact latency and memory usage

Knowing what causes a variable to "escape" helps you write high-performance code.

🧪 Basic Example: Stack vs Heap

func stackAlloc() {
    name := "Musa"
    fmt.Println(name)
}

Here, name is only used inside the function. It doesn’t escape, so Go allocates it on the stack.

Now look at this:

func heapAlloc() *string {
    name := "Musa"
    return &name
}

In this case, we’re returning a pointer to a local variable. The compiler sees that name escapes the function, so it moves it to the heap.

🔍 How to Check Escape Analysis

Run the Go compiler with the -gcflags=-m flag:

go build -gcflags="-m" main.go

Or, if you just want to compile without building:

go run -gcflags="-m" main.go

Example output:

main.go:6:6: moved to heap: name

This tells you which variables escape.

🧩 More Examples

1. Interface Conversion Causes Escape

func logMessage(msg string) interface{} {
    return msg
}

The string msg escapes because it's converted to an interface{}, which could be used outside the current scope.

2. Passing Address to Another Function

func takePointer(p *int) {
    fmt.Println(*p)
}

func escapeByPassing() {
    num := 42
    takePointer(&num)
}

Even though num is not returned, passing its address to another function may cause it to escape, depending on whether that function stores the pointer.

3. Closures Can Cause Escape

func closureEscape() func() int {
    x := 10
    return func() int {
        return x
    }
}

Here, x escapes because it is captured by the returned closure.

✅ Best Practices

Tip	Explanation
Avoid unnecessary pointer returns	Return values instead of pointers if not needed
Be cautious with interface{}	It often causes escape
Limit closure usage over variables	Closures capture outer variables which can escape
Profile and test	Use `-gcflags="-m"` and memory profilers to inspect impact

📦 Final Thoughts

Escape analysis is one of those compiler-level features that silently affects your program's performance and memory efficiency. As a developer, understanding this concept helps you make better decisions, especially in high-performance applications, such as web servers, system tools, and large-scale data processing.

By mastering escape analysis, you’ll write cleaner, faster, and more memory-efficient Go code.

Slices in Go: A Deep Dive with Examples

Md Abu Musa — Thu, 10 Apr 2025 12:23:35 +0000

When writing Go programs, you’ll find that arrays are often too rigid to be practical. That’s where slices come into play. Slices are Go’s built-in abstraction over arrays that offer flexibility, power, and performance.

In this blog, we’ll explore:

What slices are
How they work internally
How to create and use them
Common pitfalls
Best practices with examples

📌 What is a Slice?

A slice is a dynamically-sized, flexible view into the elements of an array. It doesn't store data itself — it points to an underlying array.

Slice Structure (Internally)

A slice in Go is a small struct with 3 fields:

type slice struct {
    ptr *T   // pointer to the underlying array
    len int  // number of elements in the slice
    cap int  // total capacity (from ptr to end of array)
}

✅ Creating Slices

1. From an Array

arr := [5]int{10, 20, 30, 40, 50}
slice := arr[1:4] // [20 30 40]

Here:

slice references the array arr from index 1 to 3 (excluding index 4).
len(slice) = 3
cap(slice) = 4 (from index 1 to end of the array)

2. Using Slice Literal

numbers := []int{1, 2, 3}

This creates both a slice and its underlying array.

3. Using `make()`

s := make([]int, 3)        // [0 0 0]
s := make([]int, 3, 5)     // len=3, cap=5

🔁 Slicing a Slice

data := []int{100, 200, 300, 400}
sub := data[1:3] // [200 300]

This sub-slice shares memory with the original slice. Changing sub affects data:

sub[0] = 999
fmt.Println(data) // [100 999 300 400]

➕ Appending Elements

nums := []int{1, 2}
nums = append(nums, 3, 4) // [1 2 3 4]

If the slice’s capacity is full, Go automatically allocates a new underlying array.

⚠️ Shared Memory Behavior

arr := []int{1, 2, 3, 4}
s1 := arr[0:2]    // [1 2]
s2 := arr[1:3]    // [2 3]

s1[1] = 999
fmt.Println(arr) // [1 999 3 4]
fmt.Println(s2)  // [999 3]

Tip:

To avoid this, use copy():

original := []int{1, 2, 3}
clone := make([]int, len(original))
copy(clone, original)

📈 Capacity Growth with `append()`

Go typically doubles the capacity when appending exceeds the current capacity.

s := make([]int, 0, 2)
s = append(s, 1, 2, 3)

fmt.Println(s) // [1 2 3]

If the capacity is exceeded, a new array is allocated behind the scenes.

📦 Built-in Functions

Function	Description
`len(slice)`	Returns number of elements
`cap(slice)`	Returns total capacity
`append(slice, elems...)`	Appends elements
`copy(dst, src)`	Copies elements

🧪 Complete Example

func main() {
    original := []int{10, 20, 30, 40, 50}

    slice1 := original[1:4]
    fmt.Println("Slice1:", slice1) // [20 30 40]

    slice2 := append(slice1, 99)
    fmt.Println("Original:", original)
    fmt.Println("Slice2:", slice2)

    slice1[0] = 777
    fmt.Println("Modified Slice1:", slice1)
    fmt.Println("Modified Original:", original)
}

Output (May vary based on capacity reuse):

Slice1: [20 30 40]
Original: [10 20 30 40 99]
Slice2: [20 30 40 99]
Modified Slice1: [777 30 40]
Modified Original: [10 777 30 40 99]

❗ Common Mistakes

🔹 Assuming slices are independent:

a := []int{1, 2, 3}
b := a
b[0] = 999
fmt.Println(a) // [999 2 3]

Use copy() to truly clone a slice.

🔹 Forgetting that `append()` might create a new array

Always check whether your slice is still pointing to the original memory if you rely on shared behavior.

✅ Best Practices

Use slices for most collections — they’re more idiomatic and dynamic than arrays.
Use copy() when independence is needed.
Avoid unnecessary slicing inside performance-critical loops.
Use make([]T, len, cap) if you know the size ahead of time.

🧠 Summary

Feature	Array	Slice
Size	Fixed	Dynamic
Memory Sharing	Yes	Yes
Append Support	No	Yes
Preferred Use	Rare	Always

🔚 Final Thoughts

Slices are a cornerstone of Go’s design, combining performance with flexibility. Understanding how slices share memory with arrays, grow, and interact with built-in functions is essential for writing idiomatic and safe Go code.

Once you master slices, you’ll write cleaner, more efficient programs — and avoid some tricky bugs!

Mastering Pointers in Go: A Complete Beginner-to-Advanced Guide

Md Abu Musa — Tue, 08 Apr 2025 00:38:30 +0000

Go (Golang) is a powerful, statically typed language built for simplicity, performance, and scalability. One of the key features that sets Go apart from many high-level languages is its support for pointers, which allow you to directly reference memory addresses.

In this blog, you’ll learn everything you need to know about pointers in Go — from what they are and why they matter, to how they’re used in real-world applications.

📌 What is a Pointer?

A pointer is a variable that holds the memory address of another variable.

👉 Analogy:

Think of a variable as a house and its value as a person living inside. A pointer is like the house’s address written on a note. You don’t carry the person — you carry the address.

🧪 Basic Pointer Syntax in Go

var x int = 10
var p *int = &x

x is an int variable.
&x gives the memory address of x.
p is a pointer to int (*int) that stores that address.

🔍 Dereferencing

To get the value stored at the pointer address:

fmt.Println(*p) // Output: 10

⚙️ Why Use Pointers?

🔁 Avoid copying large values (performance gain).
🧠 Modify values inside functions.
⚒️ Work with dynamic data structures (like linked lists, trees).
🚀 Share state between functions or goroutines.

🧑‍💻 Example: Modify Value via Pointer

func update(val *int) {
    *val = 99
}

func main() {
    num := 50
    update(&num)
    fmt.Println(num) // Output: 99
}

✅ *val = 99 changes the original num since we're working with its memory address.

🆚 Value vs Pointer

Feature	Value (Copy)	Pointer (Reference)
Memory usage	More (copies value)	Less (copies address)
Modify original?	❌ No	✅ Yes
Performance	Slower with large data	Faster

🆕 The `new()` Keyword

ptr := new(int)
*ptr = 77
fmt.Println(*ptr) // Output: 77

new(int) allocates memory for an int and returns a pointer to it.
The pointer’s default value is zero.

👤 Pointers with Structs

type User struct {
    Name string
}

func rename(u *User) {
    u.Name = "Alice"
}

func main() {
    user := User{Name: "Bob"}
    rename(&user)
    fmt.Println(user.Name) // Output: Alice
}

✅ Modifications inside the function persist outside because we pass a pointer.

🧠 Common Pitfalls

❌ Dereferencing a nil pointer

   var p *int
   fmt.Println(*p) // panic: runtime error: invalid memory address

✅ Always check for nil:

   if p != nil {
       fmt.Println(*p)
   }

🔄 Passing by Value vs Pointer (Recap)

Case	Use Pointer?
Modify original data	✅ Yes
Pass large structs	✅ Yes
Read-only small values	❌ No

🔚 Conclusion

Pointers are a core concept in Go that unlock performance, control, and flexibility. By mastering pointers, you gain a deeper understanding of how data flows and memory works under the hood — critical skills for any serious Go developer.

✨ Remember: With great power (pointers), comes great responsibility (memory safety)!

Webhook vs API: Key Differences and Use Cases

Md Abu Musa — Wed, 05 Mar 2025 14:57:29 +0000

Introduction

In modern web development, communication between different systems and services is essential. Two common methods for this are Webhooks and APIs. While both enable data exchange, they function differently. In this blog, we'll explore their differences, working mechanisms, and real-world use cases.

What is an API?

An API (Application Programming Interface) is a request-response mechanism where a client requests data from a server, and the server responds with the requested data. This means that the client (e.g., a web app or mobile app) must explicitly ask for information whenever needed.

How API Works (Pull-Based Communication)

The client sends a request (e.g., HTTP GET or POST) to the server.
The server processes the request and returns a response.
The client receives the response and processes the data.

Example of API

Consider a weather application that fetches real-time weather data.

The app sends an API request to a weather service (e.g., OpenWeather API) asking for the weather in New York.
The server processes the request and responds with data like temperature, humidity, and conditions.
The app displays this information to the user.

📌 Key Takeaway: APIs work in a request-driven (pull-based) manner, meaning data is retrieved only when the client requests it.

What is a Webhook?

A Webhook is an event-driven mechanism where the server automatically sends data to a predefined URL when a specific event occurs. Instead of the client making requests repeatedly, the server pushes data in real-time whenever an event happens.

How Webhooks Work (Push-Based Communication)

The client registers a webhook URL with the server.
When an event occurs (e.g., payment success, order placed), the server automatically sends (pushes) the data to the webhook URL.
The client receives and processes the data instantly.

Example of Webhook

Imagine an e-commerce website integrated with a payment gateway (e.g., Stripe or PayPal).

A customer makes a successful payment.
Stripe automatically sends a webhook notification to the e-commerce system with transaction details.
The system processes the payment and updates the order status.

📌 Key Takeaway: Webhooks work in an event-driven (push-based) manner, meaning data is sent automatically when an event occurs.

Key Differences Between Webhook and API

Feature	API	Webhook
Trigger Mechanism	Client requests data	Server pushes data automatically
Communication Type	Request-response (Pull)	Event-driven (Push)
Efficiency	Requires periodic polling	More efficient, as data is sent only when needed
Real-time Updates	Not real-time unless polling is frequent	Real-time notifications
Use Case Example	Fetching weather data	Getting a notification when a payment is completed

When to Use API vs Webhook?

Use API When:

✔️ You need on-demand data (e.g., fetching user details, retrieving reports).

✔️ The client decides when to request information.

✔️ You want more control over requests and responses.

📌 Example: A user logs into an app, and the system fetches their profile data via API.

Use Webhooks When:

✔️ You need real-time updates (e.g., receiving notifications on status changes).

✔️ You want to avoid continuous polling to reduce API load.

✔️ The event occurs outside the client’s control (e.g., payment confirmations, new GitHub commits).

📌 Example: A payment gateway (Stripe) sends a webhook when a payment is successful.

Combining API and Webhooks

In some cases, using both API and Webhooks together provides the best solution.

🔹 Example: A food delivery app:

Uses API to fetch restaurant menus when the user opens the app.
Uses Webhooks to notify the user when the food is out for delivery.

Conclusion

Both APIs and Webhooks play vital roles in modern applications. The choice between them depends on whether you need real-time event-driven updates (Webhooks) or on-demand request-response interactions (API). Understanding their differences helps developers build more efficient and scalable systems.

🚀 Pro Tip: If your system requires frequent updates but you don’t want to overload it with API requests, consider using Webhooks for real-time notifications and APIs for fetching additional data when needed.

Understanding Higher-Order Functions in Go

Md Abu Musa — Tue, 25 Feb 2025 01:07:15 +0000

What is a Higher-Order Function?

A Higher-Order Function (HOF) is a function that either takes another function as an argument or returns a function as its result.

This makes functions in Go more flexible and powerful by enabling concepts like callbacks, function composition, and functional programming patterns.

Characteristics of Higher-Order Functions

✅ Takes a function as an argument

✅ Returns a function as a result

✅ Enhances code reusability and modularity

✅ Common in functional programming patterns

Examples of Higher-Order Functions in Go

1️⃣ Passing a Function as an Argument

A function that accepts another function as a parameter and applies it to two integers.

package main

import "fmt"

// Higher-order function: Takes a function as an argument
func operate(a int, b int, op func(int, int) int) int {
    return op(a, b)
}

// Function to add two numbers
func add(x, y int) int {
    return x + y
}

func main() {
    result := operate(4, 5, add)
    fmt.Println("Result:", result) // Output: Result: 9
}

✅ Why Higher-Order?

operate takes another function (op) as an argument.
This makes operate flexible, as it can apply different functions like add, subtract, multiply, etc.

2️⃣ Returning a Function from Another Function

A function that returns another function instead of a direct value.

package main

import "fmt"

// Higher-order function: Returns a function
func multiplier(factor int) func(int) int {
    return func(n int) int {
        return n * factor
    }
}

func main() {
    double := multiplier(2) // double now holds a function that multiplies by 2
    fmt.Println(double(5))  // Output: 10
}

✅ Why Higher-Order?

multiplier(2) returns a function that multiplies any number by 2.
The returned function is stored in double, which can be used later.

3️⃣ Using Anonymous Functions in Higher-Order Functions

Instead of defining a separate function, we can pass an anonymous function directly.

package main

import "fmt"

func operate(a int, b int, op func(int, int) int) int {
    return op(a, b)
}

func main() {
    result := operate(10, 3, func(x, y int) int {
        return x - y
    })
    fmt.Println("Result:", result) // Output: Result: 7
}

✅ Why Higher-Order?

The operate function takes an anonymous function as a parameter.
No need to define a separate function like subtract.

First-Order vs. Higher-Order Functions

Feature	First-Order Function	Higher-Order Function
Accepts another function?	❌ No	✅ Yes
Returns another function?	❌ No	✅ Yes
Example	`sumArray([]int)`	`operate(4, 2, func(x, y int) int { return x * y })`

When to Use Higher-Order Functions?

✅ When writing generic, reusable functions

✅ When using callbacks or function composition

✅ When implementing custom sorting, filtering, or mapping operations

✅ When applying functional programming patterns

DEV Community: Md Abu Musa

cURL: The Swiss Army Knife of Data Transfer

Introduction

What Is cURL?

Why cURL Is Important

Basic cURL Syntax

Common HTTP Operations with cURL

1. GET Request

2. POST Request

3. PUT Request

4. DELETE Request

Working with Headers

Send Custom Headers

View Response Headers

Authentication with cURL

Basic Authentication

Bearer Token Authentication

Handling JSON Responses

File Upload and Download

Download a File

Upload a File

Debugging and Verbose Mode

Verbose Output

Timeouts and Retries

Set Timeout

Retry on Failure

Following Redirects

Using cURL in Automation and Scripts

Security Best Practices

cURL vs Postman

Conclusion

Ubuntu Server Resource Monitoring via Command Line

1. Why Resource Monitoring Matters

2. Quick System Health Overview

Command

What it shows

How to interpret load average

3. Real-Time CPU and Memory Monitoring

Using top

Key metrics

Useful shortcuts

Using htop (Recommended)

Why htop is better

4. Memory (RAM) Usage Analysis

Command

Key fields explained

5. Disk Usage Monitoring

Overall disk usage

Directory-wise disk usage

6. CPU Information and Core Count

Command

7. Network Usage Monitoring

Basic network statistics

Real-time network monitoring

8. Disk I/O Performance (Often Overlooked)

Command

9. Identify Resource-Hungry Processes

Top memory-consuming processes

Top CPU-consuming processes

10. One-Command Live Summary

Command

11. Recommended Monitoring Workflow (Production)

12. Conclusion

[Boost]

Why Your EC2 Server Suddenly Stops Responding — And How to Bulletproof Laravel & Node Apps

Why Your EC2 Server Suddenly Stops Responding — And How to Bulletproof Laravel & Node Apps

What Actually Happened?

Why a Node Build Freezes Small EC2 Instances

1. 100% CPU consumption

2. RAM exhaustion

3. Out-of-Memory (OOM) kills

4. Nginx stops responding

5. SSH becomes slow

How to Prevent This Problem in the Future

1. Never Build Frontend Code on Production or Test Servers

2. Add a 2GB Swap File

3. Limit Node.js Memory Usage (PM2 Protection)

4. Restart PHP-FPM & Nginx During High Load

5. Monitor Real-Time Resource Usage with htop

6. Use PM2 Startup to Ensure Node Apps Auto-Restart on Reboot

Using `top`

Using `htop` (Recommended)

Why `htop` is better

3. Using `make()`

📈 Capacity Growth with `append()`

🔹 Forgetting that `append()` might create a new array