DEV Community: Yasser Elgammal

Green Framework: Simple & Modern PHP Framework for Fast Development

Yasser Elgammal — Tue, 07 Apr 2026 00:25:58 +0000

Green Framework is a simple and modern PHP framework built to make development faster and easier.

It focuses on clean code and uses modern PHP features like Attributes, so you can define things like routes directly inside your controllers without extra files.

🚀 Why use Green?

Simple and lightweight
Clean and readable code
Fast to build with
Great for small to medium projects

⚡ Installation

You can install Green Framework using Composer:

composer create-project yasser-elgammal/green

📚 Documentation

You can view the full documentation and explore the project on GitHub:

👉 Project link on GitHub

Feel free to explore the code, open issues, or contribute to the project 🚀

💡 Conclusion

Green Framework is a good choice if you want a clean and simple way to build modern PHP applications without unnecessary complexity.

Introducing a Rate Limiter Library for Go

Yasser Elgammal — Sun, 18 Jan 2026 22:41:52 +0000

In modern backend systems, rate limiting is essential.

Without it, APIs are exposed to abuse, resource exhaustion, and unfair usage.

That’s why I built a production-ready, thread-safe rate limiter library in Go, based on the Token Bucket algorithm.

Why Token Bucket?

I chose the Token Bucket algorithm because it:

Allows controlled bursts of traffic
Provides smooth request flow
Is widely used in production systems
Is simple to understand and reason about

Each client gets a bucket of tokens that refills over time.

Requests consume tokens — once the bucket is empty, requests are rejected.

Library Highlights

This library focuses on correctness and simplicity:

Production-ready & thread-safe
Token Bucket algorithm with burst support
Fast in-memory storage
Detailed rate limit results (remaining, retry-after, reset time)
Extensive unit tests and race-condition testing
Optional cleanup for stale entries

Quick Example

config := limiter.Config{
    Rate:     10,
    Duration: time.Second,
    Burst:    20,
}

store := store.NewMemoryStore(5 * time.Minute)
rateLimiter, _ := limiter.NewTokenBucket(config, store)

if rateLimiter.Allow("user123") {
    fmt.Println("Request allowed")
}

With just a few lines, you get a reliable rate limiter ready for production.

Perfect For

REST APIs
Go microservices
Public-facing services
Internal tools

Anything that needs fair and controlled request handling.

Open Source

The project is open source under the MIT license and open for contributions.

GitHub:

https://github.com/yasserelgammal/rate-limiter

If you find it useful, feel free to leave a ⭐️

It really helps support open-source work.

Understanding Technical Debt in Modern Software Development

Yasser Elgammal — Thu, 15 Jan 2026 19:15:10 +0000

Technical Debt is one of the most important concepts in software engineering and product development. It refers to the future cost created when development teams choose quick, temporary, or sub-optimal solutions instead of implementing the best long-term approach.

This article explains the meaning of technical debt, why it happens, its risks, and best practices to manage it effectively.

What Is Technical Debt? — Definition

Technical Debt is the “extra work” a team will have to do later because they took shortcuts during development.

Just like financial debt:

You borrow time now (by coding quickly)
You pay back more time later (due to fixes, refactoring, bugs)

Why Does Technical Debt Happen?

Technical debt is not always caused by mistakes—it often results from business needs. Common causes include:

1. Tight deadlines

Teams prioritize delivery speed over clean architecture.

2. Changing requirements

Unclear or shifting requirements lead to temporary solutions.

3. Legacy systems

Old technologies and outdated code create unavoidable debt.

4. Lack of testing

Skipping automated tests increases future risks.

5. Quick fixes

Temporary patches remain longer than expected.

Examples of Technical Debt

Hard-to-read or unmaintainable code
Missing documentation
Poor architecture or structure
Using deprecated libraries
Duplicated logic
Large modules without clear separation
No automated testing

These issues may not break the system today, but they slow development dramatically over time.

Why Technical Debt Matters (Business Impact)

Technical debt has a direct impact on product quality and delivery speed:

1. Slower development

New features take longer because the codebase becomes harder to modify.

2. More bugs

Quick solutions often introduce hidden issues.

3. Higher maintenance cost

Developers spend more time fixing issues than building features.

4. Reduced system stability

Legacy components become fragile.

5. Lower team morale

Developers become frustrated when working with messy or outdated code.

Is Technical Debt Always Bad?

No, sometimes it’s strategic.

Teams may intentionally take technical debt to:

Release an MVP quickly
Validate an idea
Meet urgent business requirements
Beat a competitor to market

But like real debt, it must be tracked and repaid.

How to Manage and Reduce Technical Debt

1. Plan regular refactoring

Allocate time each sprint for code improvements.

2. Enforce clean code standards

Use style guides, naming conventions, and architecture rules.

3. Write automated tests

Unit tests, integration tests, and CI pipelines reduce long-term risk.

4. Track technical debt

Use backlog items, documentation, or dashboards.

5. Educate stakeholders

Explain the business impact of unmanaged technical debt.

6. Avoid “quick fixes” mentality

Make temporary solutions clearly documented and time-boxed.

Conclusion

Technical Debt is a natural part of any software project. It becomes dangerous only when ignored.

By understanding its causes and actively managing it through refactoring, testing, and good engineering practices, teams can build scalable, stable, and future-proof systems.

Boost Your Laravel Productivity with “Laravel Debug Remover” VSCode Extension

Yasser Elgammal — Tue, 18 Nov 2025 23:07:59 +0000

Debugging with dd() is part of every Laravel developer’s workflow.
But forgetting a debug statement inside a controller or Blade file can break production or interrupt API responses.

Laravel Debug Remover automatically scans and removes all dd() debug statements from your PHP and Blade files.

Key Features

Two Modes

Current File – Cleans debug statements only in the file you're working on
Entire Workspace – Scans and cleans your whole project

Smart Exclusions

Automatically skips:

vendor
node_modules
storage
bootstrap/cache

You can customize the ignored folders from the extension settings.

Fully Configurable

Add your own directory exclusions via settings.json.
Perfect for large Laravel or monolithic codebases.

High Performance

Fast and optimized scanning — ideal for projects with hundreds of files.

Usage

Press CTRL + P and choose:

Remove all debug statements (Current File)
Remove all debug statements (Entire Workspace)

Supports Both PHP & Blade

Blade templates are parsed safely without breaking UI or logic.
The extension intelligently handles both PHP and Blade syntaxes.

Download

📥 VSCode Marketplace:
Download from VSCode Marketplace

Final Thoughts

This extension solves a common and painful issue every Laravel developer faces.
If it prevents a production mistake or speeds up your workflow, then it has achieved its goal.

Introducing Lara SMS – A Flexible Laravel SMS Gateway Package

Yasser Elgammal — Fri, 24 Oct 2025 16:44:11 +0000

I’m excited to introduce my new Laravel package, Lara SMS, designed to make SMS integration in Laravel projects easier, cleaner, and more flexible.

💡 Why Lara SMS?

Integrating SMS gateways can often be repetitive and inconsistent across projects.
Lara SMS provides a unified and expressive API that allows you to send messages through multiple gateways, all while keeping your codebase elegant and maintainable.

⚙️ Key Features

✅ Multi-provider support
Built using the Strategy Pattern, allowing seamless integration with multiple SMS gateways.

✅ Fluent Builder
Provides a clean and expressive syntax for message construction using a chainable, fluent interface.

✅ Fallback Strategies
Choose between “Try All” or “Fail Fast” approaches when handling failed gateway attempts.

✅ Automatic Retries
Automatically retries sending messages on temporary failures to ensure reliability.

✅ Comprehensive Logging
Tracks and logs all SMS operations for better monitoring and debugging.

🧩 Installation

Install the package via Composer:

composer require yasser-elgammal/lara-sms

🧠 Behind the Scenes

This project taught me a lot about designing scalable and extendable Laravel packages, particularly around architectural design patterns like Strategy and Builder.

My goal was to create something that’s both powerful and developer-friendly, making SMS workflows in Laravel projects smoother than ever.

🔗 GitHub:
https://github.com/yasserelgammal/lara-sms

💬 Feedback Welcome

I’m always open to feedback, ideas, and contributions.
If Lara SMS helps simplify your workflow or if you have suggestions for improvement, I’d love to hear from you!

How to Monitor and Save Server Disk Space in Laravel

Yasser Elgammal — Wed, 10 Sep 2025 16:59:07 +0000

When working on Laravel projects, it’s important to keep an eye on your server’s storage usage. Large folders can easily go unnoticed until your server starts running out of space.

Here’s a small Laravel helper that:

Calculates the size of each folder inside storage/.
Displays both raw size (bytes) and a human-readable format (KB / MB / GB).
Allows sorting results ascending or descending.

This helps a lot when monitoring a live server, so you can quickly find which folders are consuming the most space.

Full code: 👇
👉 View the code on Gist

⚡ This is a lightweight utility, but it can save you time and help keep your servers clean.

Note:

The code works starting from Laravel 10+.
This is just a small idea, and of course, it’s open for customization or further development.

🙏 If you found this useful, share it with your network it might save someone else hours of debugging or running out of server space.

Why Should You Use Traits in PHP? - 5 Reasons

Yasser Elgammal — Wed, 13 Aug 2025 11:23:47 +0000

Introduction:

In PHP, traits are a powerful tool for reusing code across different classes. They help you keep your codebase clean, flexible, and easy to maintain, Here are five key reasons to use them:

1. Reuse code in multiple classes without copying it

Traits let you write a method once and use it in many classes, so you don’t have to duplicate the same logic everywhere.

2. Avoid single inheritance limit

Since PHP only allows one parent class, traits give you a way to add functionality from multiple sources at the same time.

3. Keep code DRY (Don’t Repeat Yourself)

Putting shared methods in a trait ensures you write them once and reuse them, reducing the chance of mistakes or inconsistencies.

4. Mix behaviors into unrelated classes

Traits allow you to add the same features to classes that are not related in the inheritance hierarchy.

5. Easy to maintain

If you need to update a shared method, you just change it in the trait, and all classes using it automatically get the update.

Summary

PHP traits let you share and reuse methods across multiple unrelated classes, bypassing the single inheritance limit. They help keep code DRY by centralizing common logic, making it easier to maintain—any change in the trait applies to all classes using it.

How to Structure Your Tests Using AAA (Arrange / Act / Assert)

Yasser Elgammal — Sat, 02 Aug 2025 06:27:45 +0000

When writing Unit or Feature tests in Laravel, one of the most effective ways to keep your tests clean and easy to follow is by using the AAA pattern.

What is AAA?

AAA stands for:

Arrange : Set up your data and dependencies
Act : Execute the behavior or function you want to test
Assert : Verify that the result matches your expectations

This structure makes your tests:

Easier to read
Easier to maintain
Easier to debug

Why Use AAA?

It helps you avoid writing "messy" tests where setup, execution, and assertions are all mixed together.

By clearly separating the 3 phases of testing, you're more likely to catch bugs early, understand what each test is doing at a glance, and maintain consistency across your codebase.

Laravel Example

Here’s a simple Feature Test example following the AAA pattern:

public function test_run_todo_show(): void
{
    // Arrange
    $todo = Todo::factory()->create();

    // Act
    $response = $this->get("/todos/{$todo->id}");

    // Assert
    $response->assertStatus(200);
    $response->assertViewIs('todos.show');
    $response->assertSee($todo->title);
}

Summary

The AAA pattern stands for Arrange, Act, Assert.
It separates test setup, execution, and verification for clarity and maintainability.
This structure improves readability, consistency, and debugging.

How Laravel Loads and Caches Translation Files in Localization

Yasser Elgammal — Wed, 30 Jul 2025 16:53:38 +0000

Localization is one of Laravel's powerful features, allowing developers to support multiple languages seamlessly using either PHP array files or JSON files.

But one question that often comes up is:

Does Laravel cache translations? And how does it handle large translation files?

Let’s break it down and understand what actually happens under the hood.

Laravel Supports Two Types of Translation Files

1️⃣ PHP Array Files

Located in:
/lang/{locale}/messages.php

Structure:

return [
    'welcome' => 'Welcome to our website',
    'login'   => 'Login here',
];

Usage:

__('messages.welcome')

2️⃣ JSON Files

Located in:
/lang/{locale}.json

Structure:

{
    "Welcome": "Welcome to our website",
    "Login": "Login here"
}

Usage:

__('Welcome')

When Does Laravel Load Translation Files?

Laravel does not load all translation files at once.

Instead:

It loads a translation file only when a key is requested from it.
Then it stores the entire file content in memory (an internal PHP array) for the rest of the current request.

This behavior is implemented inside the Illuminate\Translation\FileLoader and Translator classes.

Internally, Laravel stores loaded translations in a private property like $loaded, and avoids loading the same file twice during one request.

What Is Runtime Cache?

Runtime cache means that Laravel keeps the translations in memory only during the current HTTP request.

If you call:

__('messages.welcome')

Multiple times during the same request, Laravel will:

Load the file once via require.
Reuse the cached values in memory for any further translation calls.

This boosts performance by avoiding redundant file reads.

Once the request ends, this cache is discarded.

Laravel Does NOT Persist Translation Cache

Unlike routes, config, or compiled views, Laravel does not cache translations to disk.

There is no php artisan translations:cache command, and no bootstrap/cache storage for translations.

Why?

Because translation files are often small, and caching them permanently can:

Complicated dynamic multilingual updates.
Increase risk of stale data if edited manually.

What About Large Translation Files?

Laravel loads the full translation file when a key is requested.

That means:

If your messages.php file has 2000 keys, all of them will be loaded into memory when you use any one of them.
This can have memory implications in huge apps.

Best Practice:
Organize your translations into smaller, modular files like:

auth.php
dashboard.php
messages.php

Then reference them as:

__('dashboard.title')

Quick Recap

Laravel supports both PHP arrays and JSON translation formats.
Translation files are loaded only when a key is requested.
Laravel uses in-memory cache for the duration of a single request.
There is no persistent disk caching for translations.
Split large translation files into smaller files to improve maintainability and memory efficiency.

Thanks for reading!

If you found this helpful, share it with others it might help someone else too.

References

The Importance of Rate Limiting and How to Implement It in Laravel

Yasser Elgammal — Thu, 24 Jul 2025 17:41:46 +0000

What Happens When Your API Gets Flooded?

When an API receives too many requests in a short amount of time either from a single user or a large number of users.. it can:

Overload your server’s CPU and RAM،
Cause slowdowns or downtime،
Expose vulnerabilities to abuse or malicious attacks.

Servers have limited resources. Without protection, excessive requests can crash your system or degrade performance for all users.

The Solution is Rate Limiting

Rate Limiting is a technique that restricts the number of requests a client can make to an API in a given time window.

Why Use Rate Limiting?

Protect your server from overload
Prevent abuse and spam attacks,
Ensure fair usage across all users,
Enhance security against DDoS and brute-force attacks.

How to Implement Rate Limiting in Laravel

Laravel makes rate limiting simple using its built in middleware and features.

Basic Rate Limit with Middleware

Laravel uses throttle middleware to handle rate limits.

In routes/api.php:

Route::middleware('throttle:60,1')->group(function () {
    Route::get('/user', [UserController::class, 'index']);
    Route::post('/order', [OrderController::class, 'store']);
});

This means:

A user can make 60 requests per minute.

Customizing Rate Limits Per User

You can create dynamic rate limits based on the authenticated user:

In App\Providers\RouteServiceProvider:

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

public function boot()
{
    RateLimiter::for('api', function ($request) {
        return Limit::perMinute(100)->by(optional($request->user())->id ?: $request->ip());
    });
}

Then apply it to your route:

Route::middleware(['throttle:api'])->group(function () {
    // Protected routes
});

Tips for Production

Monitor rate limits with tools like Laravel Telescope or API Gateway logs,
Show meaningful error messages for 429 Too Many Requests,
Combine with IP banning CAPTCHA or authentication for added protection.

Summary

Rate limiting isn’t just a performance technique, it's a security layer that protects your application and ensures a good experience for all users.

Introducing Laravel Easy Wallet Package

Yasser Elgammal — Tue, 22 Jul 2025 14:56:24 +0000

Laravel Easy Wallet is a simple and extensible wallet system for Laravel applications. It allows you to associate wallets with any model, manage balances, and record transactions with support for credit and debit.

🚀 Features

Attach a wallet to any Eloquent model (walletable)
Automatically create a wallet if it doesn’t exist
Credit and debit balance safely inside a DB transaction
Transaction history tracking

📦 Installation

composer require yasser-elgammal/laravel-easy-wallet

💸 Usage Example

1. Add Required Relation to related models

use YasserElgammal\LaravelEasyWallet\Models\Wallet;

    public function wallet()
    {
        return $this->morphOne(Wallet::class, 'walletable');
    }

2. Credit Wallet

use YasserElgammal\LaravelEasyWallet\Facades\EasyWallet;
use App\Models\User;

$user = User::find(1);

EasyWallet::credit($user, 100.00, 'Initial deposit');

3. Debit Wallet

EasyWallet::debit($user, 25.00, 'Purchased course');

4. Transfer Between Wallets

$fromUser = User::find(1);
$toUser = User::find(2);

EasyWallet::transfer($fromUser, $toUser, 40.00, 'Transfer to friend');

5. Get Wallet Balance

$balance = EasyWallet::balance($user);

📌 Why I Built It

I’ve worked on several projects that needed internal balance logic. Each time, I had to rewrite the same concepts. This package is my way of solving that once and for all — for myself and for the community.

📥 Contributions & Feedback

I’d love your feedback! If you find this package useful or have suggestions, feel free to open an issue or PR on GitHub.

GitHub: github.com/yasser-elgammal/laravel-easy-wallet

Difference Between Helper Functions and Traits in PHP (Laravel)

Yasser Elgammal — Sun, 29 Jun 2025 06:21:52 +0000

As a Laravel developer, you often need to reuse code across different parts of your application. Two powerful tools at your disposal are Helper Functions and Traits. While they may seem similar at a glance, they serve different purposes and are best used in different scenarios.

In this article, we’ll clearly explain the differences, use cases, and real-world examples of both so you’ll know when to use each.

What is a Helper Function?

A Helper Function is a globally available function that performs a common task. You don’t need to create an object or class to use it. Helper functions are ideal for simple, stateless tasks that you may need in multiple places.

Key Characteristics:

Global (accessible anywhere)
Stateless (doesn’t rely on class properties)
Simple to write and use
Great for formatting, calculations, string manipulation, etc.

Example:

// helpers.php
if (!function_exists('format_price'))
function format_price($price) {
    return number_format($price, 2);
}
}

Usage:

format_price(1500); // Outputs: 1,500.00

What is a Trait?

A Trait is a reusable piece of code that can be included in multiple classes. It’s especially useful when several classes need to share the same methods or behaviors.

Unlike helper functions, traits can access class properties using $this, making them suitable for behaviors that depend on the object's internal state.

Key Characteristics:

Used inside a class using use
Can access $this and class properties
Ideal for shared behaviors across models or services
Keeps code modular and organized

Example:

trait HasSlug {
    public function generateSlug($text) {
        return \Str::slug($text);
    }
}

Usage:

class PostController {
    use HasSlug;

    public function store(Request $request) {
// Logic
        $slug = $this->generateSlug($request->title);
// Other logic
    }
}

When Should You Use Each?

Use helper functions when your logic is stateless and utility-based.
Use traits when you need to encapsulate reusable logic that depends on the class context or internal data.

Conclusion

Both helper functions and traits are incredibly useful in Laravel. The key is to use each where it fits best:

Use helper functions for quick, global logic.
Use traits to add reusable, object-specific behaviors to your classes they help you get around PHP’s single inheritance limitation.