Forem: Ahmed Raza Idrisi

🔥 Arrays vs Slices in Go (Explained in the Simplest Way)

Ahmed Raza Idrisi — Wed, 22 Apr 2026 17:10:21 +0000

If you just started learning Go, one thing will confuse you quickly:

👉 Arrays vs Slices

They look similar… but behave very differently.

Let’s break it down in the simplest way possible 👇

📦 What is an Array?

An array is a fixed-size collection.

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

Key points:

Size is fixed
Cannot grow or shrink
Rarely used in real-world Go apps

🔄 What is a Slice?

A slice is a dynamic version of an array.

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

Key points:

Size is dynamic
Can grow using append
Used almost everywhere in Go

⚡ Adding Data (Only Works with Slice)

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

numbers = append(numbers, 4)

Now:

[1, 2, 3, 4]

🧠 Under the Hood (Important Concept)

A slice is:

Pointer to an array
Length
Capacity

Think of it like:
👉 “A flexible view on top of an array”

🔍 Slice Example with Capacity

numbers := make([]int, 2, 5)

fmt.Println(len(numbers)) // 2
fmt.Println(cap(numbers)) // 5

❗ Common Mistake

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

Why?
👉 Because arrays are fixed size

🔥 Real-World Use Case

When building APIs:

users := []string{}

users = append(users, "Ahmed")
users = append(users, "John")

Dynamic data = slices ✅

🧭 When to Use What?

Feature	Array	Slice
Size	Fixed	Dynamic
Usage	Rare	Common
Flexibility	❌	✅

👉 In 95% of cases → use slice

💬 Final Thought

If you understand slices, you understand how Go manages data internally.

This is a foundational concept—don’t skip it.

🚀 Coming Next

Next post:
👉 Structs in Go (this is where real backend modeling starts)

golang #backend #programming #webdev #devto

🚀 Getting Started with Go (Golang) for Backend Developers

Ahmed Raza Idrisi — Wed, 22 Apr 2026 17:07:57 +0000

If you're coming from PHP, Node.js, or Laravel, learning Go can feel different—but in a good way.

Go is designed for performance, simplicity, and concurrency. Many modern systems use it for building fast APIs and scalable services.

Let’s understand it in a simple way 👇

🧠 What is Go?

Go (or Golang) is a compiled programming language created at Google.

Think of it like:

⚡ Faster than PHP/Node (compiled)
🧼 Cleaner syntax than Java
🔁 Built for concurrency (handling multiple tasks efficiently)

⚙️ Your First Go Program

package main

import "fmt"

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

What’s happening?

package main → entry point
import "fmt" → used for printing
func main() → main function where execution starts

🔤 Variables in Go

name := "Ahmed"
age := 25

No need to write types explicitly (Go infers them).

🔁 Loops (Only ONE loop in Go)

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

Simple and clean.

⚡ Functions

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

🧵 Concurrency (This is where Go shines)

Go uses goroutines (lightweight threads):

go func() {
    fmt.Println("Running in background")
}()

Why this matters:

Handle multiple API requests easily
Build high-performance systems
Perfect for microservices

🌐 Simple API in Go

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from Go API")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Run it and open:
👉 http://localhost:8080

🔥 Why You Should Learn Go

High performance (close to C++)
Simple syntax
Great for backend + APIs
Used by companies like Google, Uber, Netflix

🧭 Coming Next

In upcoming posts, I’ll cover:

Building REST APIs in Go
Connecting Go with PostgreSQL
Using Go with Docker
Concurrency deep dive (goroutines + channels)

💬 Final Thought

If you already know backend development, Go will feel like a power upgrade.

Start small. Stay consistent. Share what you learn.

golang #backend #programming #webdev #devto

🚀 5 Modern PHP Features You Should Start Using Today

Ahmed Raza Idrisi — Wed, 22 Apr 2026 17:03:48 +0000

If you’re still writing PHP like it's 2015, you're missing out on some powerful features that make your code cleaner, safer, and easier to maintain.

In this post, I’ll walk you through 5 modern PHP features in a very simple way — with examples you can actually use in real projects.

1. ✅ Typed Properties (Strict Data Handling)

Before PHP 7.4, you couldn’t define types for class properties.

❌ Old way:

class User {
    public $name;
}

✅ New way:

class User {
    public string $name;
}

Why it matters:

Prevents invalid data
Makes your code predictable
Helps avoid bugs early

2. ✅ Arrow Functions (Shorter Closures)

Arrow functions make your code shorter and cleaner.

❌ Old way:

$numbers = [1, 2, 3];

$squared = array_map(function($n) {
    return $n * $n;
}, $numbers);

✅ New way:

$squared = array_map(fn($n) => $n * $n, [1,2,3]);

Why it matters:

Less boilerplate
More readable functional code

3. ✅ Null Safe Operator (`?->`)

Avoid those annoying null checks.

❌ Old way:

if ($user && $user->profile) {
    echo $user->profile->email;
}

✅ New way:

echo $user?->profile?->email;

Why it matters:

Cleaner code
No more "trying to access property of null" errors

4. ✅ Match Expression (Better than switch)

match is more strict and cleaner than switch.

❌ switch:

switch($status) {
    case 'success':
        $msg = 'Done';
        break;
    case 'error':
        $msg = 'Failed';
        break;
}

✅ match:

$msg = match($status) {
    'success' => 'Done',
    'error' => 'Failed',
    default => 'Unknown'
};

Why it matters:

No break needed
Strict comparison (no type confusion)

5. ✅ Constructor Property Promotion

Less boilerplate when creating classes.

❌ Old way:

class User {
    public string $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

✅ New way:

class User {
    public function __construct(public string $name) {}
}

Why it matters:

Cleaner classes
Less repetitive code

🔥 Final Thoughts

Modern PHP is:

Faster ⚡
Cleaner ✨
Safer 🔒

If you're working with frameworks like Laravel, these features are already being used under the hood — so understanding them will level up your coding skills.

💬 What Next?

If you found this useful, I can share:

Real-world Laravel examples using these features
Performance tips for PHP apps
Clean architecture patterns in PHP

Let me know in the comments 👇

PHP #Laravel #WebDevelopment #Backend #Programming

The Case of the Empty 500: How I Proved the API Failure Wasn't Our Fault

Ahmed Raza Idrisi — Wed, 11 Feb 2026 17:40:56 +0000

We’ve all been there. You make an API call, it fails, and the finger-pointing begins. "It’s the frontend," says the backend team. "It’s your service," says the API provider.

Recently, I faced a debugging challenge where our application was receiving an empty response from an external API. On the surface, it looked like our request was simply vanishing into the void. Here is how I tracked down the culprit: The WAF.

The Problem
Our application was calling an external endpoint. The symptoms were frustratingly vague:

Response Body: Completely empty.

Result: The application logic failed because there was no data to parse.

Internal Consensus: Initial thoughts were that our request payload was malformed or our connection was dropping.

Digging into the Headers
While the response body was empty, the HTTP Status Code and Response Headers told a different story. I noticed two red flags:

Status Code 500: A "500 Internal Server Error" usually implies the server tried to do something and failed. If it were our network, we’d likely see a 404 or a timeout.

Infrastructure Headers: Looking at the network trace, I saw headers related to Cloudflare and specific WAF (Web Application Firewall) signatures.

The "Aha!" Moment
By analyzing the custom headers injected by their WAF, I realized the request wasn't even reaching their application code. Their security layer was intercepting our request and dropping the payload before the server could process it.

Even though the body was empty, the presence of those specific infrastructure headers proved that the hand-off to their network was successful, but their security rules were blocking us.

The Resolution
I presented the logs and the specific WAF headers to the provider's network team. With this evidence, they were able to:

Identify the specific firewall rule that was flagging our IP/payload.

Whitelist our service.

Restore the API functionality.

Key Takeaways for Debugging APIs
Never ignore the headers: The body might be empty, but headers are the "fingerprints" of the servers the request passed through.

Status codes matter: A 500 error is a server-side confession.

Check for Middleware: In modern web dev, you aren't just talking to a server; you're talking to Load Balancers, WAFs, and Proxies.

laravel request life cycle

Ahmed Raza Idrisi — Fri, 26 Sep 2025 15:21:04 +0000

Laravel Request Lifecycle

The Laravel request lifecycle begins when a user sends an HTTP request to the web server (Apache, Nginx). The server forwards the request to the public/index.php file, the application's single entry point. This file loads Composer’s autoloader, performs essential bootstrapping, and constructs a new instance of the Laravel application.

The next step is the HTTP Kernel, which manages the request, response, and middleware stacks. The global middleware stack runs first, acting as filters for every HTTP request. Service providers register core services, and after bootstrapping, the router dispatches the request to a route or controller, executing any route-specific middleware.

Controllers (or route closures) process the request and generate a response—HTML view, JSON, download, or redirect. Before the response is sent to the user's browser, it passes back out through the middleware stack for any post-processing. Finally, the Kernel’s handle() method returns the response for index.php to deliver to the browser.

Middleware's Role in the Lifecycle

Middleware in Laravel act as filters operating before or after the core route/controller logic. They check authentication, log requests, manipulate headers, etc. Middleware can be global (applied to all requests) or route-specific (applied only to selected routes). Middleware can halt, redirect, modify requests, or even process responses before they're sent back to the client.

Creating Custom Middleware

Global Middleware

Generate middleware: php artisan make:middleware CustomGlobalMiddleware.[8]
Add logic in app/Http/Middleware/CustomGlobalMiddleware.php:

  public function handle($request, Closure $next)
  {
      // Custom logic here
      return $next($request);
  }

  protected $middleware = [
      // ... existing middleware,
      \App\Http\Middleware\CustomGlobalMiddleware::class,
  ];

Now the middleware runs for every HTTP request.

Route Middleware

Generate middleware: php artisan make:middleware CustomRouteMiddleware.
Add logic in app/Http/Middleware/CustomRouteMiddleware.php as above.
Register in app/Http/Kernel.php within $routeMiddleware:

  protected $routeMiddleware = [
      'custom' => \App\Http\Middleware\CustomRouteMiddleware::class,
  ];

Apply to route:

  Route::get('/example', function () {
      return 'Example Route';
  })->middleware('custom');

For groups:

  Route::middleware(['custom'])->group(function () {
      Route::get('/a', ...);
      Route::get('/b', ...);
  });

Passing Parameters to Middleware

Parameters can be sent to route middleware by appending them after a colon in the route definition:

Route::get('/post/{id}', 'PostController@show')->middleware('verify.role:admin');

In the middleware class, receive them as extra arguments:

public function handle($request, Closure $next, $role)
{
    // Check for required role
    return $next($request);
}

To access route parameters (like {id}) inside middleware:

$id = $request->route('id'); // Gets route param 'id'
$params = $request->route()->parameters(); // All parameters array

This lets you make your middleware context-aware and dynamic.

Quick Reference Table: Request Lifecycle Steps

Step	Purpose
Web Server	Receives & forwards HTTP request
index.php	Application entry, bootstraps Laravel
Kernel	Handles requests, global middleware
Service Providers	Register services
Router	Routes requests, applies route middleware
Controller/View	Core logic & generates response
Middleware	Filters/Processes requests & responses
Response	Sent back via Kernel & index.php

This sequence gives a robust, hands-on understanding of where middleware intercepts requests, how to build custom ones, and how parameters integrate with the lifecycle—all as essential for mastering Laravel’s request flow and middleware.

Replication & High Availability

Ahmed Raza Idrisi — Sat, 20 Sep 2025 06:15:42 +0000

Replication & High Availability

🔹 What is Replication?

Replication is the process of copying data from one database server (the primary) to one or more other servers (replicas/secondaries).

The primary (or master) handles writes (INSERT, UPDATE, DELETE).
The replicas (or slaves, followers, standbys) receive these changes and apply them.
This ensures multiple copies of the same data exist across servers.

👉 Think of it like keeping photocopies of your important notebook in multiple places — if one is lost, you still have backups.

🔹 Types of Replication

Synchronous Replication

Writes on the primary are confirmed only after replicas also confirm they’ve written the change.
Ensures no data loss but can slow down performance (since it waits).
Example: PostgreSQL synchronous replication.

Asynchronous Replication

Primary writes immediately return success, and replicas catch up later.
Faster, but risk of data loss if primary crashes before replicas sync.
Example: MySQL’s default replication.

Semi-synchronous Replication

A middle ground: primary waits for at least one replica to confirm before success.
Balance between safety & performance.

🔹 Why Replication is Important?

Read Scaling: Distribute reads across replicas (read-heavy apps benefit).
High Availability: If primary fails, replicas can be promoted as new primary.
Disaster Recovery: Data is safe even if one server is lost.
Geographic Distribution: Users in Asia can read from an Asia replica instead of a US server.

🔹 High Availability (HA)

HA is about keeping your database always online, even during failures. Replication is a core building block of HA, but HA adds automatic failover and monitoring.

If primary dies, a replica automatically becomes the new primary.
Clients reconnect automatically without manual intervention.
Requires a cluster manager / orchestrator.

🔹 Replication & HA in Popular Databases

MySQL
- Replication: Asynchronous by default (binlog-based).
- HA: Tools like MySQL InnoDB Cluster, Orchestrator, or ProxySQL handle failover.
PostgreSQL
- Built-in streaming replication.
- HA: Tools like Patroni, PgBouncer, repmgr, or Stolon.
MongoDB
- Replica sets built-in: one primary, multiple secondaries, automatic failover.
Cassandra
- Replication is peer-to-peer (no master/replica distinction). Every node can handle writes.

🔹 Example Scenario

Imagine a banking app:

Primary DB (Mumbai) → handles all deposits/withdrawals.
Replicas:
- Delhi replica → handles read queries for North India users.
- London replica → handles reads for European users.

If the Mumbai primary crashes:

Delhi replica is promoted to new primary.
All writes now go to Delhi, ensuring zero downtime for customers.

✅ Summary
Replication = Copying data across servers.
High Availability = Making sure the database stays alive automatically, even if one server dies.

🔹 How Automatic Failover Works

1. Health Monitoring

Tools like Patroni (PostgreSQL), Orchestrator (MySQL), or MongoDB built-in replica sets constantly ping the primary DB.
They check:
- Is the DB server alive (via TCP/heartbeat)?
- Is replication up-to-date?
- Is there network partition (primary is alive but unreachable)?

👉 If the primary stops responding within a certain timeout (say 10s), it’s marked as failed.

2. Leader Election

In a cluster, you don’t want two primaries (split-brain issue ⚠️).
A consensus system like Etcd, Consul, or Zookeeper is used.
Cluster members vote:
- "Primary is dead, we need a new one."
- They agree on which replica is most up-to-date.

👉 The most recent replica (with the least replication lag) becomes the new Primary.

3. Failover / Promotion

The chosen replica:
- Promotes itself to Primary.
- Stops being read-only.
- Starts accepting writes.

👉 In Patroni (PostgreSQL), this is done with pg_ctl promote.
👉 In Orchestrator (MySQL), it issues RESET SLAVE ALL + reconfigures replication.

4. Reconfiguration

Other replicas now start replicating from the new Primary.
The cluster updates routing so apps know where to send writes.
Tools like HAProxy, ProxySQL, or PgBouncer help by pointing apps to the current Primary.

5. Application Transparency

Applications don’t have to know which DB is Primary.
They just connect to a load balancer / proxy.
If failover happens, the proxy redirects traffic to the new Primary.

👉 This ensures no downtime for the app.

🔹 Example with Tools

PostgreSQL + Patroni
- Patroni uses Etcd/Consul for cluster state.
- Monitors DB health.
- On failure → promotes replica → updates routing.
MySQL + Orchestrator
- Continuously monitors replication topology.
- Detects primary failure.
- Promotes the best replica automatically.
- Updates HAProxy/ProxySQL.
MongoDB Replica Set
- Built-in heartbeat detection.
- Automatic election (no external tool needed).
- One secondary becomes new primary.

✅ Summary in Simple Words
Failover tools are like a traffic cop:

Check if the main road (primary DB) is open.
If closed, find the best alternative road (replica).
Redirect all cars (applications) automatically.

Advance Indexing in MYSql and Psql

Ahmed Raza Idrisi — Fri, 19 Sep 2025 12:25:42 +0000

Perfect 👌 Let’s go deep into Indexing since it’s the heart of database performance.
I’ll keep it detailed but easy to follow with MySQL & PostgreSQL examples.

🔹 Advanced Indexing Explained

Indexes are like the table of contents in a book 📖.

Without index → You scan the whole book to find “Chapter 10”.
With index → You jump directly to the page number listed.

In databases, indexes speed up SELECT queries by avoiding full table scans.

1. B-Tree Index (Default in MySQL & PostgreSQL)

Most common type.
Great for equality (=) and range queries (<, >, BETWEEN).
Data stored in a balanced tree → lookup is O(log n).

Example (Postgres/MySQL):

CREATE INDEX idx_users_email ON users(email);

Query using it:

SELECT * FROM users WHERE email = 'abc@gmail.com';

👉 Index lets DB jump directly to matching rows instead of scanning all.

2. Hash Index

Only good for exact matches (=).
Not good for ranges (<, >, BETWEEN).
MySQL has them in Memory engine; PostgreSQL supports HASH explicitly.

Example (Postgres):

CREATE INDEX idx_users_username_hash ON users USING HASH(username);

👉 WHERE username = 'john_doe' becomes super fast.

3. GIN Index (Generalized Inverted Index – PostgreSQL only)

Used for full-text search and JSONB queries.
Stores a mapping from value → rows containing it.

Example: Full-text search

CREATE INDEX idx_post_content_gin ON posts USING GIN(to_tsvector('english', content));

Query:

SELECT * FROM posts WHERE to_tsvector('english', content) @@ to_tsquery('database & scaling');

👉 Useful for search features (like Google inside your DB).

4. GiST Index (Generalized Search Tree – PostgreSQL)

More flexible than B-Tree.
Supports geospatial queries, ranges, similarity search.

Example (find locations near a point):

CREATE INDEX idx_locations_gist ON locations USING GiST(geom);

Query:

SELECT * FROM locations
WHERE ST_DWithin(geom, ST_MakePoint(77.5946, 12.9716)::geography, 5000);

👉 Finds all locations within 5km of given coordinates (great for maps).

5. BRIN Index (Block Range Index – PostgreSQL)

Very lightweight.
Instead of indexing every row, it stores min/max per block of rows.
Great for sequential / time-series data.

Example:

CREATE INDEX idx_logs_date_brin ON logs USING BRIN(log_date);

👉 Efficient for queries like:

SELECT * FROM logs WHERE log_date BETWEEN '2025-01-01' AND '2025-01-31';

👉 Works best when data is naturally ordered (like timestamps).

6. Covering Index (a.k.a. Index with INCLUDE columns)

Stores extra columns in the index itself.
Avoids going back to the table (called “index-only scan”).

Postgres:

CREATE INDEX idx_orders_customer_date
ON orders(customer_id) INCLUDE(order_date, total_amount);

Now:

SELECT customer_id, order_date, total_amount
FROM orders WHERE customer_id = 123;

👉 DB serves query only from index, no table lookup needed.

7. Partial / Filtered Index

Index only rows that meet a condition.
Saves space & improves performance when you query subsets often.

Postgres:

CREATE INDEX idx_active_users ON users(email) WHERE status = 'active';

👉 Queries on active users become lightning fast, without indexing inactive ones.

8. Expression Index

Index on a function or expression.
Great when queries always apply transformations.

Postgres:

CREATE INDEX idx_lower_email ON users(LOWER(email));

Now:

SELECT * FROM users WHERE LOWER(email) = 'abc@gmail.com';

👉 Uses index instead of scanning all rows.

🔹 How to Know Which Index to Use?

Exact match lookup → Hash index (Postgres) or B-Tree.
Range queries (>, <, BETWEEN) → B-Tree.
Text search / JSONB search → GIN.
Geospatial / similarity → GiST.
Time-series / ordered data → BRIN.
Only certain rows → Partial index.
Always lowercase/transform → Expression index.

🔹 Important Notes

Indexes speed up reads but slow down writes (inserts/updates/deletes need to update indexes).
Too many indexes = slower writes + more storage.
Always use EXPLAIN or EXPLAIN ANALYZE to see if your query uses the index.

✅ Summary:
Indexes are like shortcuts — different types exist for different problems.
Mastering them = 80% of database optimization as a database engineer.

Sharding in Databases: How Queries Identify the Right Shard

Ahmed Raza Idrisi — Fri, 19 Sep 2025 12:12:21 +0000

🔹 What is Sharding in Databases?

Sharding is a database partitioning technique where data is split across multiple databases or servers (called shards) to improve scalability and performance.

Each shard contains a portion of the data (not a full copy). For example:

Suppose you have a users table with 100 million rows.
Instead of storing all in one DB, you could split:
- Shard 1 → users with IDs 1–25M
- Shard 2 → users with IDs 25M–50M
- Shard 3 → users with IDs 50M–75M
- Shard 4 → users with IDs 75M–100M

Now each shard only handles a subset, so queries and writes become faster.

👉 Sharding is commonly used in very large-scale systems (e.g., Facebook, Twitter, YouTube) where one DB server cannot handle all the load.

🔹 Similar Concepts in Databases

Sharding is just one of many scaling/distribution techniques. Let’s compare:

1. Replication

Copies of the same database are kept across multiple servers.
Master → Replica(s) model.
Used for read scaling and high availability.
Example: MySQL Replication, PostgreSQL Streaming Replication.

👉 Difference from sharding: Replicas have full copies, while shards have partial data.

2. Partitioning (within a single DB)

Data is divided into smaller, manageable partitions inside one database server.
Types:
- Horizontal Partitioning → rows are split (like sharding, but within one server).
- Vertical Partitioning → columns are split (e.g., frequently accessed columns in one table, large JSON/blob in another).
Example: MySQL Partitioning, PostgreSQL Table Partitioning.

👉 Sharding is basically horizontal partitioning across multiple servers.

3. Federation / Database Clustering

Splitting data across different databases logically (like sharding, but sometimes done at the application level).
Example: SQL Server Federation, Citus for PostgreSQL.

4. Connection Pooling

Not data distribution, but an important concept: reuses DB connections to improve performance under high load.

5. Caching

Store frequently accessed data in Redis, Memcached, etc.
Helps reduce load on DB (often combined with sharding).

🔹 In MySQL vs PostgreSQL

MySQL
- Supports replication, partitioning, and can be sharded via middleware like Vitess (used by YouTube).
- MySQL Cluster (NDB) also provides automatic sharding.
PostgreSQL
- Native table partitioning.
- Built-in replication.
- Can use extensions like Citus (for distributed PostgreSQL with sharding).

this is the tricky part of sharding — how the system decides which shard to query.

There’s no magic — the database (or middleware, or your app) needs a shard key (a rule to determine where a piece of data lives).

🔹 How Queries Find the Right Shard

Shard Key

A special column (like user_id, customer_id, order_id, etc.) is chosen.
Example: If user_id = 12345, then the system applies a rule like:
```
 shard_number = user_id % 4
```
- If result = 1 → go to Shard 1
- If result = 2 → go to Shard 2, etc.
This is called hash-based sharding.

Shard Mapping (Lookup Table)

Sometimes, a mapping table (or config service) stores which shard holds which data.

Example:

 user_id_range   -> shard
 1 - 25M         -> shard1.db.com
 25M - 50M       -> shard2.db.com
 50M - 75M       -> shard3.db.com

When a query comes, the app looks up the mapping table first.

Middleware / Proxy

Tools like Vitess (MySQL), Citus (Postgres), or custom middleware sit between the app and DB.
They intercept queries, check the shard key, and route to the right shard.
To your app, it looks like one database.

Broadcast Queries (last resort)

If a query doesn’t include the shard key (e.g., “find all users with email = xyz@gmail.com”), the system may need to query all shards and combine results.
This is slow, which is why choosing the right shard key is critical.

🔹 Example: Shard Query Flow

Say you’re storing users across 4 shards:

Shard Rule: user_id % 4
User with user_id = 1017 logs in.

Query:

SELECT * FROM users WHERE user_id = 1017;

Flow:

App sees user_id = 1017.
Computes → 1017 % 4 = 1.
Query goes to Shard 1 only.
Result returned.

✅ Summary:

Queries find the right shard using shard keys.
Routing is done by either:
- App logic
- Middleware/proxy
- Lookup table
If no shard key → either broadcast query or centralized index.

✅ Quick Recap:

Replication → copies of same data.
Sharding → split data into subsets across servers.
Partitioning → split data inside a single DB.
Clustering / Federation → multiple databases acting as one.
Caching → reduce DB load.

Understanding Reverse Proxy, Jump Servers, Application Servers, and Database Servers

Ahmed Raza Idrisi — Wed, 17 Sep 2025 13:56:43 +0000

🔹 Reverse Proxy

A reverse proxy is a server that sits between the client (browser) and your application servers.
Instead of clients hitting your Laravel/PHP application directly, they talk to the reverse proxy, which then forwards (proxies) the request to the right backend server.

Example:

You configure ** Nginx ** or ** HAProxy ** as a reverse proxy.
Requests from users go first to Nginx → Nginx decides where to forward the request → Laravel app (PHP-FPM).

Why it’s required:

Load balancing – distribute traffic among multiple Laravel servers.
Security – hide your actual app servers’ IPs from the public.
SSL termination – proxy handles HTTPS (SSL) and forwards plain HTTP to app server.
Caching / Rate Limiting – can cache responses or block abuse before reaching Laravel.

👉 In PHP/Laravel context:
Your Laravel app runs on PHP-FPM (or Apache). Instead of exposing it directly, you put Nginx as reverse proxy.
User → Nginx (reverse proxy) → Laravel (application server).

🔹 Jump Server (or Bastion Host)

A jump server is a secure intermediate server used by administrators/devs to connect to internal servers (like app servers or DB servers) that are not exposed to the internet.

Why it’s required:

Security – only one exposed entry point (the jump server), rest of servers are private.
Audit & Logging – all admin SSH connections go through the jump server (easy to monitor).
Network segmentation – app and DB servers stay in private subnet.

👉 In PHP/Laravel context:

You don’t directly SSH into the Laravel application server or database server.
You SSH into the jump server first → then from there, connect to internal servers.

🔹 Application Server

This is the server that runs your business logic / application code.
For Laravel:

Runs PHP-FPM or Apache/Nginx + PHP.
Executes Laravel code (routes, controllers, services).
Talks to database server for data.

Example:

AWS EC2 or DigitalOcean droplet running Laravel app.

🔹 Database Server

This is the server that stores and manages your data.
For Laravel:

MySQL / PostgreSQL / MongoDB, etc.
Application server connects to DB server over the private network.
DB server usually is not exposed to the internet, only accessible by application servers.

🔹 Putting It All Together (Laravel Deployment Architecture)

[ Client Browser ]
        |
        v
 [ Reverse Proxy (Nginx/HAProxy/Cloudflare) ]
        |
        v
 [ Application Server (Laravel + PHP-FPM) ]
        |
        v
 [ Database Server (MySQL/Postgres) ]

And for Admin/Dev access:

[ Developer Laptop ]
        |
        v
 [ Jump Server (Bastion Host) ]
        |
        v
 [ Application Server / Database Server ]

✅ In short:

Reverse Proxy → handles traffic, security, scaling.
Jump Server → secure entry point for admins.
Application Server → runs Laravel/PHP code.
Database Server → stores data for the Laravel app.

php bottlenecks and performance

Ahmed Raza Idrisi — Mon, 15 Sep 2025 19:05:46 +0000

PHP Performance Bottlenecks + Concepts

🔹 Common PHP Performance Bottlenecks

Loops

Heavy nested loops (for inside foreach) slow execution.

Example:

 for ($i = 0; $i < 100000; $i++) {
     // expensive operation here
 }

✅ Solution: Minimize work inside loops, break early if possible, use built-in functions (array_map, array_filter) when efficient.

Excessive Database Queries (N+1 problem)

Example:

 $users = User::all();
 foreach ($users as $user) {
     echo $user->posts->count(); // runs query every time ❌
 }

✅ Solution: Use eager loading:

   $users = User::with('posts')->get();

I/O Bottlenecks

File read/write in large loops
Slow external API calls ✅ Solution: Caching (Redis, Memcached), batch I/O, async workers (queues).

🔹 Opcode Caches (Opcache)

PHP is an interpreted language. Normally:
- Every request = parse → compile → execute.
Opcache stores compiled bytecode in memory → saves compilation time.
✅ Enable in php.ini:

  opcache.enable=1
  opcache.memory_consumption=128
  opcache.max_accelerated_files=10000

Benefit: Faster response, less CPU load.

🔹 Password Hashing Best Practices

Never store plain text or MD5/SHA1 (too weak).
Use PHP’s built-in:

  $hash = password_hash("mypassword", PASSWORD_DEFAULT); // bcrypt/argon2
  if (password_verify("mypassword", $hash)) {
      echo "Password correct!";
  }

✅ password_hash automatically salts and uses strong algorithms.
✅ password_verify safely compares.

Hands-On Benchmarking

📌 Example: Compare for loop vs foreach for arrays.

<?php
$array = range(1, 1000000);

// Benchmark foreach
$start = microtime(true);
$sum = 0;
foreach ($array as $num) {
    $sum += $num;
}
echo "Foreach: " . (microtime(true) - $start) . " seconds\n";

// Benchmark for
$start = microtime(true);
$sum = 0;
for ($i = 0; $i < count($array); $i++) {
    $sum += $array[$i];
}
echo "For: " . (microtime(true) - $start) . " seconds\n";

👉 You’ll see that foreach is generally faster for arrays.
👉 for with count($array) inside loop is slow → store count in variable instead.

📌 Example: Password Hashing

<?php
$password = "supersecret";

// Hashing
$hash = password_hash($password, PASSWORD_DEFAULT);
echo "Hash: $hash\n";

// Verify
if (password_verify("supersecret", $hash)) {
    echo "Login success!\n";
} else {
    echo "Invalid password\n";
}

Interview Prep Review

Common PHP Interview Questions (from Week 1 topics)

What’s new in PHP 8?

JIT, Match expressions, Attributes, Nullsafe operator, Named arguments, Constructor property promotion.

Explain the difference between == and ===.

== compares values (type juggling).
=== compares value and type (strict).

How does password_hash differ from md5 or sha1?

password_hash is adaptive, salted, secure.
MD5/SHA1 are fast → vulnerable to brute force.

What is a PHP Trait?

Mechanism for code reuse, allows grouping methods to include in multiple classes without inheritance.

What are Generators (yield)?

Functions that return values one at a time without storing the whole dataset in memory → efficient for large data.

Explain SRP (Single Responsibility Principle).

A class should have only one reason to change. Helps with maintainability.

What’s the difference between git merge and git rebase?

Merge: keeps history with branches.
Rebase: rewrites history, keeps linear commit log.

✅ By the end of this:

You’ll spot bottlenecks in PHP.
You’ll benchmark performance with microtime(true).
You’ll be confident answering interview-style questions aloud.

Caching in Laravel & PHP

Ahmed Raza Idrisi — Fri, 05 Sep 2025 14:01:30 +0000

Great question 👍 Let’s cover caching in PHP (raw) and then how Laravel makes it much easier and powerful.

🧠 1. What is Caching?

Caching means storing data temporarily so you don’t need to recalculate or refetch it every time.

Speeds up performance 🚀
Reduces database/API load
Stores in memory (Redis/Memcached) or files

🐘 2. Caching in Plain PHP

In raw PHP, you don’t have a built-in cache system like Laravel, but you can implement simple ones.

Example 1: File-based Cache

<?php
function getCache($key) {
    $file = __DIR__ . "/cache/{$key}.txt";
    if (file_exists($file) && (time() - filemtime($file) < 60)) {
        // valid cache for 60 sec
        return file_get_contents($file);
    }
    return null;
}

function setCache($key, $data) {
    $file = __DIR__ . "/cache/{$key}.txt";
    file_put_contents($file, $data);
}

// Example: Caching API result
$data = getCache("users");

if (!$data) {
    echo "Fetching fresh data...\n";
    $data = json_encode(["Ahmed", "Ali", "Sara"]);
    setCache("users", $data);
} else {
    echo "Using cache...\n";
}

echo $data;

✅ First time → fetches fresh data
✅ Next times (within 60 sec) → returns cache

Example 2: Memory Caching with APCu (if installed)

<?php
apcu_store('name', 'Ahmed', 60); // store 60 sec
echo apcu_fetch('name'); // Ahmed

🎯 3. Caching in Laravel (Much Easier!)

Laravel comes with a powerful cache system out of the box.
Supported drivers: file, database, array, redis, memcached.
Default in .env:

CACHE_DRIVER=file

🔹 Basic Cache Usage

use Illuminate\Support\Facades\Cache;

// Store
Cache::put('name', 'Ahmed', 60); // 60 seconds

// Retrieve
$name = Cache::get('name'); // Ahmed

// Retrieve with default
$name = Cache::get('username', 'Guest');

// Check
if (Cache::has('name')) {
    echo "Cache exists!";
}

// Delete
Cache::forget('name');

🔹 Remember Pattern

Very common in Laravel:

$users = Cache::remember('users', 60, function () {
    return DB::table('users')->get();
});

➡️ First time → runs the DB query, caches it for 60 sec
➡️ Next time → pulls from cache directly

🔹 Forever Cache

Cache::forever('site_settings', ['theme' => 'dark']);

Remove it:

Cache::forget('site_settings');

⚡ 4. Real-World Example: API Caching

public function getWeather() {
    return Cache::remember('weather_data', 600, function () {
        $response = Http::get('https://api.weatherapi.com/v1/current.json?key=API_KEY&q=London');
        return $response->json();
    });
}

✅ Saves API response for 10 minutes.
✅ Avoids calling external API every time.

🔔 5. Best Practices

Use Redis for high-performance caching in production.
Use remember or rememberForever instead of manually managing put/get.
Clear cache safely:

  php artisan cache:clear

For config caching:

  php artisan config:cache

✅ In short:

In PHP, you can use files or APCu for caching.
In Laravel, use Cache facade → simple and powerful (DB, Redis, Memcached, File).
Perfect for speeding up DB queries, API calls, or expensive calculations.

Perfect 👌 Redis is one of the fastest ways to do caching in Laravel (and plain PHP too). Let’s break it down with easy examples.

🔥 1. What is Redis?

An in-memory data store (everything is in RAM → super fast ⚡).
Supports strings, lists, sets, hashes.
Used for caching, sessions, queues, pub/sub messaging.

🐘 2. Redis in Plain PHP

To use Redis in PHP, you install the phpredis extension or use Predis (PHP client).

Example (Predis):

require 'vendor/autoload.php';

$redis = new Predis\Client();

// Store in cache
$redis->setex("name", 60, "Ahmed"); // store for 60 sec

// Get from cache
echo $redis->get("name"); // Ahmed

// Delete
$redis->del("name");

✅ Works just like a key-value store.
✅ But Laravel makes it even easier.

🎯 3. Redis in Laravel

🔹 Step 1: Install Redis

Make sure Redis is installed on your system and running:

redis-server

Install PHP extension (if needed):

composer require predis/predis

🔹 Step 2: Configure in `.env`

CACHE_DRIVER=redis
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis

🔹 Step 3: Use Redis via Cache Facade

use Illuminate\Support\Facades\Cache;

// Store data
Cache::put('username', 'Ahmed', 60); // 60 sec

// Get data
echo Cache::get('username'); // Ahmed

// Remember (common use case)
$users = Cache::remember('users', 300, function () {
    return DB::table('users')->get();
});

// Forget
Cache::forget('username');

✅ Now instead of storing in files, Laravel stores in Redis memory.

📊 4. Example: Cache Heavy Query with Redis

Route::get('/top-users', function () {
    $users = Cache::remember('top_users', 600, function () {
        return DB::table('users')
            ->orderBy('points', 'desc')
            ->limit(10)
            ->get();
    });

    return $users;
});

➡️ First call → hits DB, stores in Redis.
➡️ Next calls (10 min) → served instantly from Redis.

🔔 5. Example: Cache API Response with Redis

public function getWeather()
{
    return Cache::remember('weather_london', 900, function () {
        return Http::get('https://api.weatherapi.com/v1/current.json?key=API_KEY&q=London')
            ->json();
    });
}

✅ The API response is cached in Redis for 15 min.
✅ No need to re-hit the external API.

🛠️ 6. Using Redis Facade Directly (Low-level)

use Illuminate\Support\Facades\Redis;

// Store
Redis::set('site_name', 'My Laravel App');

// Get
echo Redis::get('site_name');

// Increment counter
Redis::incr('visits');

// Lists
Redis::rpush('queue', 'task1');
Redis::rpush('queue', 'task2');
echo Redis::lpop('queue'); // task1

✅ In Summary

Plain PHP → use Predis or phpredis.
Laravel → just set CACHE_DRIVER=redis and use Cache or Redis facade.
Best for:
- Heavy DB queries
- API results
- Session & authentication data
- Queues

PHP GC for FIles

Ahmed Raza Idrisi — Fri, 05 Sep 2025 13:35:22 +0000

Let’s go step by step and see how PHP Garbage Collection & Memory Management behave when using classes, methods, and heavy tasks like PDF/Excel generation.

🏗️ 1. Classes & Methods

When you use classes and objects in PHP:

<?php
class User {
    public $name;
    function __construct($name) {
        $this->name = $name;
    }
}

function createUser() {
    $user = new User("Ahmed");
    echo $user->name;
} // <- $user goes out of scope here, memory freed

createUser();
?>

✅ After the function ends, $user is destroyed and memory is released.
❌ But if there’s a circular reference inside objects, GC kicks in.

🌀 2. Circular References in Classes

<?php
class A {
    public $ref;
}
class B {
    public $ref;
}

$a = new A();
$b = new B();

$a->ref = $b;
$b->ref = $a; // <- circular reference

unset($a, $b); // memory NOT immediately freed
gc_collect_cycles(); // manually free cycles
?>

➡️ Without GC, long-running scripts (like workers) would slowly eat up RAM.

📄 3. PDF Generation Example (Memory Heavy)

Suppose you’re using dompdf or TCPDF in Laravel/PHP.

<?php
use Dompdf\Dompdf;

function generatePDF($data) {
    $dompdf = new Dompdf();
    $dompdf->loadHtml("<h1>Hello $data</h1>");
    $dompdf->render();
    $pdf = $dompdf->output();

    file_put_contents("output.pdf", $pdf);

    // Free memory explicitly
    unset($dompdf, $pdf);
    gc_collect_cycles(); // cleanup
}

generatePDF("Ahmed");
?>

⚠️ Problem: If you generate thousands of PDFs in a queue job without cleanup, memory keeps rising.
✅ Solution: unset() variables, call gc_collect_cycles() occasionally.

📊 4. Excel Generation Example (Maatwebsite / PhpSpreadsheet)

<?php
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

function generateExcel() {
    $spreadsheet = new Spreadsheet();
    $sheet = $spreadsheet->getActiveSheet();
    $sheet->setCellValue('A1', 'Hello Ahmed');

    $writer = new Xlsx($spreadsheet);
    $writer->save('output.xlsx');

    // Free memory
    $spreadsheet->disconnectWorksheets();
    unset($spreadsheet, $writer);
    gc_collect_cycles();
}

generateExcel();
?>

⚠️ If you create 100,000+ rows without cleaning up, memory will spike (hundreds of MBs).
✅ Best practice:

Use chunked writes (write in batches instead of loading everything in memory).
Always unset() objects and call gc_collect_cycles() in long-running scripts.

🚀 5. Real-World Tips (Laravel Jobs / Workers)

For short web requests: memory is freed at the end of the request anyway.
For long-running jobs (queues, daemons, APIs that loop over big datasets):
- Always unset() large objects after use.
- Call gc_collect_cycles() every few iterations.
- For Excel, prefer ->store() with queue exports (Maatwebsite handles memory better).
- For PDF, generate and store in chunks instead of bulk in one go.

Let’s clear the confusion — why do we need to unset() and call gc_collect_cycles() in PDF (or Excel) generation, even though variables go out of scope?

🧠 1. Normal Case – Variables Go Out of Scope

In a short script or a web request, PHP automatically:

Destroys variables when they go out of scope
Frees memory when the request ends

Example:

function test() {
    $a = "hello";  // allocated
} // <- function ends, $a destroyed, memory freed

➡️ Nothing special needed.

🧾 2. Why PDF/Excel is Different

Libraries like Dompdf, TCPDF, PhpSpreadsheet are heavy:

They create big objects in memory (fonts, images, large buffers, XML tree for Excel, etc.)
Some of these objects reference each other (circular references)
PHP’s normal “out of scope” cleanup can’t immediately free all memory because circular references stay alive until GC runs

So, if you’re generating 1 PDF in a request, it doesn’t matter — memory is freed at request end.
But if you’re generating 100 PDFs in a loop (long-running worker), memory keeps growing until GC decides to run.

🔄 3. Example: PDF Without Explicit Cleanup

use Dompdf\Dompdf;

for ($i = 0; $i < 100; $i++) {
    $dompdf = new Dompdf();
    $dompdf->loadHtml("<h1>PDF $i</h1>");
    $dompdf->render();
    file_put_contents("pdf_$i.pdf", $dompdf->output());

    // no unset or GC
}

⚠️ Problem: Memory grows with each loop because internal buffers & objects remain in circular references.
Eventually → script crashes with Out of Memory error.

✅ 4. With Explicit Cleanup

use Dompdf\Dompdf;

for ($i = 0; $i < 100; $i++) {
    $dompdf = new Dompdf();
    $dompdf->loadHtml("<h1>PDF $i</h1>");
    $dompdf->render();
    file_put_contents("pdf_$i.pdf", $dompdf->output());

    // Cleanup
    unset($dompdf);
    gc_collect_cycles(); // force GC to break cycles
}

✔️ Memory stays stable, script runs fine.

⚡ 5. Key Difference

Short script/web request → memory is freed when request ends (no worries).
Long-running jobs (queue workers, daemons, batch processing) → memory accumulates unless you explicitly free heavy objects.

📝 Rule of Thumb

For normal requests: don’t bother, PHP cleans up.
For batch jobs / loops / workers: always unset() heavy objects and occasionally call gc_collect_cycles().

👉 That’s why for PDF/Excel generation in bulk, we explicitly free memory — not because PHP won’t free it at all, but because waiting until the script ends is too late for long-running processes.

✅ In summary:

Classes & methods free memory normally.
Garbage Collection is important when objects reference each other (circular refs).
For PDF/Excel generation, explicitly free memory (unset, disconnectWorksheets, gc_collect_cycles) to prevent leaks.
In queues/long-running jobs, this is critical to avoid servers crashing from memory bloat.

Forem: Ahmed Raza Idrisi

🔥 Arrays vs Slices in Go (Explained in the Simplest Way)

📦 What is an Array?

Key points:

🔄 What is a Slice?

Key points:

⚡ Adding Data (Only Works with Slice)

🧠 Under the Hood (Important Concept)

🔍 Slice Example with Capacity

❗ Common Mistake

🔥 Real-World Use Case

🧭 When to Use What?

💬 Final Thought

🚀 Coming Next

golang #backend #programming #webdev #devto

🚀 Getting Started with Go (Golang) for Backend Developers

🧠 What is Go?

⚙️ Your First Go Program

What’s happening?

🔤 Variables in Go

🔁 Loops (Only ONE loop in Go)

⚡ Functions

🧵 Concurrency (This is where Go shines)

Why this matters:

🌐 Simple API in Go

🔥 Why You Should Learn Go

🧭 Coming Next

💬 Final Thought

golang #backend #programming #webdev #devto

🚀 5 Modern PHP Features You Should Start Using Today

1. ✅ Typed Properties (Strict Data Handling)

❌ Old way:

✅ New way:

Why it matters:

2. ✅ Arrow Functions (Shorter Closures)

❌ Old way:

✅ New way:

Why it matters:

3. ✅ Null Safe Operator (?->)

❌ Old way:

✅ New way:

Why it matters:

4. ✅ Match Expression (Better than switch)

❌ switch:

✅ match:

Why it matters:

5. ✅ Constructor Property Promotion

❌ Old way:

✅ New way:

Why it matters:

🔥 Final Thoughts

💬 What Next?

PHP #Laravel #WebDevelopment #Backend #Programming

The Case of the Empty 500: How I Proved the API Failure Wasn't Our Fault

laravel request life cycle

Laravel Request Lifecycle

Middleware's Role in the Lifecycle

Creating Custom Middleware

Global Middleware

Route Middleware

Passing Parameters to Middleware

Quick Reference Table: Request Lifecycle Steps

Replication & High Availability

Replication & High Availability

🔹 What is Replication?

🔹 Types of Replication

🔹 Why Replication is Important?

🔹 High Availability (HA)

🔹 Replication & HA in Popular Databases

🔹 Example Scenario

🔹 How Automatic Failover Works

1. Health Monitoring

2. Leader Election

3. Failover / Promotion

4. Reconfiguration

5. Application Transparency

🔹 Example with Tools

Advance Indexing in MYSql and Psql

🔹 Advanced Indexing Explained

1. B-Tree Index (Default in MySQL & PostgreSQL)

3. ✅ Null Safe Operator (`?->`)

🔹 Step 2: Configure in `.env`