Forem: Peter Kostandy

🚨 Avoiding the Single Point of Failure (SPOF) in Software Design 🚨

Peter Kostandy — Tue, 08 Jul 2025 09:55:50 +0000

🚨 Avoiding the #Single_Point_of_Failure (#SPOF) in Software Design 🚨

In software architecture, a Single Point of Failure is any one component that, if it fails, brings down the entire system. Whether it’s a service, server, or piece of code, depending solely on one thing is risky.

🎯 Let’s make it real with a PHP example.

Imagine you're using a class to handle logging across your application:

class Logger {

  public function log($message) {

    file_put_contents('log.txt', $message . PHP_EOL, FILE_APPEND);

  }

}

And across your code:

$logger = new Logger();

$logger->log("Something happened");

If log.txt becomes unavailable (e.g., disk full, file permission denied), your whole logging system fails, and maybe even "crashes your app".

🔧 Solution: Apply the #Strategy #Pattern

Instead of relying on one logging method (file logging), we can design our system to be more resilient:

interface LoggerInterface {

  public function log($message);

}



class FileLogger implements LoggerInterface {

  public function log($message) {

    file_put_contents('log.txt', $message . PHP_EOL, FILE_APPEND);

  }

}



class DatabaseLogger implements LoggerInterface {

  public function log($message) {

    // Assume $pdo is a valid PDO instance

    global $pdo;

    $stmt = $pdo->prepare("INSERT INTO logs (message) VALUES (:msg)");

    $stmt->execute(['msg' => $message]);

  }

}



class LoggerManager {

  private array $loggers;



  public function __construct(array $loggers) {

    $this->loggers = $loggers;

  }



  public function log($message) {

    foreach ($this->loggers as $logger) {

      try {

        $logger->log($message);

      } catch (Exception $e) {

        // Handle individual logger failure silently

      }

    }

  }

}

Now:

$manager = new LoggerManager([new FileLogger(), new DatabaseLogger()]);

$manager->log("App started");

✅ If the file logger fails, the DB logger still works, so there is no single point of failure.

💡 Key takeaway: Always design for redundancy. Don’t put all your reliability eggs in one basket, "especially in #production".

Have you encountered a SPOF in your projects? How did you overcome it?

SoftwareArchitecture #PHP #DesignPatterns #CleanCode #TechLeadership #SPOF #SinglePointOfFailure #PHPDevelopers #CleanCode #DesignPatterns #ResilientDesign #BackendDevelopment #SoftwareArchitecture #CodeSmarter #DevLife #TechTips

Mastering Cart Management with Laravel's Observer Pattern

Peter Kostandy — Thu, 24 Aug 2023 08:13:37 +0000

Implementing the Observer Pattern for "Add to Cart" in Laravel:

The Observer pattern is a powerful design pattern that allows you to create loosely coupled components that can respond to changes in the state of an object.
Applying this pattern to a common scenario like "Add to Cart" functionality in Laravel can lead to a more modular and maintainable codebase.

In this guide, we'll walk you through implementing the Observer pattern to handle the "Add to Cart" feature in a Laravel application. We'll explain every step and give you code samples to help you understand the idea and use it effectively...

Step 1: Define the Subject and Observers

First, we'll define the "Subject", which is the object that maintains a list of its dependents (observers) and notifies them of any state changes. In our case, the cart will act as the subject, and items added to the cart will trigger notifications to the observers.

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;

class Cart extends Model
{
    protected $items;

    public function __construct()
    {
        $this->items = new Collection();
    }

    public function addItem($item)
    {
        $this->items->push($item);
        $this->notifyObservers();
    }

    public function notifyObservers()
    {
        foreach ($this->observers as $observer) {
            $observer->update($this);
        }
    }
}

interface CartObserver
{
    public function update(Cart $cart);
}

class PriceObserver implements CartObserver
{
    public function update(Cart $cart)
    {
        // Update total price logic here
    }
}

class InventoryObserver implements CartObserver
{
    public function update(Cart $cart)
    {
        // Adjust inventory logic here
    }
}

Step 2: Create the Observers

Next, we'll create the observers that will respond to changes in the cart's state. These observers can include actions like updating the total price, displaying a notification, or adjusting inventory.

$priceObserver = new PriceObserver();
$inventoryObserver = new InventoryObserver();

Step 3: Implement the Observer Pattern

We'll integrate the observers with the cart using Laravel's event system. We'll demonstrate how to define events, listeners, and dispatch them when items are added to the cart.

$cart = new Cart();
$cart->attach($priceObserver);
$cart->attach($inventoryObserver);

// Adding an item to the cart triggers observers
$cart->addItem($item);

Step 4: Register Observers

We'll show you how to register the observers with the cart. This step is crucial to establish the connection between the subject (cart) and the observers.

class Cart extends Model
{
    protected $items;
    protected $observers;

    public function __construct()
    {
        $this->items = new Collection();
        $this->observers = new Collection();
    }

    public function attach(CartObserver $observer)
    {
        $this->observers->push($observer);
    }

    // Other methods as before...
}

Step 5: Test the Implementation

Testing is vital to ensure that our Observer pattern implementation works as expected. We'll guide you through testing scenarios where adding items triggers the desired observer responses.

class Cart extends Model
{
    protected $items;
    protected $observers;

    public function __construct()
    {
        $this->items = new Collection();
        $this->observers = new Collection();
    }

    public function attach(CartObserver $observer)
    {
        $this->observers->push($observer);
    }

    // Other methods as before...
}

Benefits of Using the Observer Pattern:

Decoupling: The Observer pattern promotes loose coupling between components, making your codebase more flexible and easier to maintain.
Scalability: Adding new functionalities or behaviors becomes more manageable without altering existing code.
Reusability: Observers can be reused across different parts of your application, enhancing code efficiency.
Modularity: Each observer handles a specific task, promoting code organization and clarity.

By the end of this guide, you'll have a clear understanding of how to implement the Observer pattern for "Add to Cart" functionality in Laravel. You'll be equipped with the knowledge to enhance your Laravel applications by applying this pattern to other scenarios as well.

Unlock the power of the Observer pattern and create a more dynamic and responsive application. Let's dive in and transform your development approach today!

Happy coding!

👉 Don't miss out on exclusive Laravel tips and tricks.😊
👉 Peter B. Youssef

Decoding DI vs. DI ✨

Peter Kostandy — Fri, 18 Aug 2023 16:25:52 +0000

Dependency Injection (DI) vs. Dependency Inversion (DI)

Dependency Injection (DI):
Dependency Injection is a technique where external dependencies are passed to a class rather than the class creating them itself. It's about injecting dependencies from the outside. In other words, instead of a class creating its own dependencies, those dependencies are provided from the outside.

Example of Dependency Injection:
Consider a Laravel controller that requires a service to handle business logic. Without DI, the controller would create the service instance internally. With DI, the service instance is passed to the controller's constructor.

// Without Dependency Injection
class UserController extends Controller
{
    public function index()
    {
        $userService = new UserService();
        $users = $userService->getAllUsers();
        return view('users.index', ['users' => $users]);
    }
}

// With Dependency Injection
class UserController extends Controller
{
    protected $userService;

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

    public function index()
    {
        $users = $this->userService->getAllUsers();
        return view('users.index', ['users' => $users]);
    }
}

Dependency Inversion (DI):
Dependency Inversion is a principle from the SOLID design principles. It suggests that high-level modules should not depend on low-level modules. Both should depend on abstractions. Additionally, abstractions should not depend on details; details should depend on abstractions. This means that instead of tightly coupling components, they should depend on abstractions (interfaces or abstract classes).

Example of Dependency Inversion:
Suppose you have a Laravel controller that interacts with a specific repository implementation. Without applying DI, the controller would directly depend on that implementation. With DI and DI principle, you would use an interface as an abstraction for the repository, and then inject the concrete implementation.

// Without Dependency Inversion
class UserController extends Controller
{
    protected $userRepository;

    public function __construct()
    {
        $this->userRepository = new UserRepository();
    }

    public function index()
    {
        $users = $this->userRepository->getAll();
        return view('users.index', ['users' => $users]);
    }
}

// With Dependency Inversion
interface UserRepositoryInterface
{
    public function getAll();
}

class UserRepository implements UserRepositoryInterface
{
    public function getAll()
    {
        // Fetch users from database
    }
}

class UserController extends Controller
{
    protected $userRepository;

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

    public function index()
    {
        $users = $this->userRepository->getAll();
        return view('users.index', ['users' => $users]);
    }
}

In the Dependency Injection example, you see how the UserService is injected into the controller's constructor.
In the Dependency Inversion example, the UserRepositoryInterface is used to define the contract, and the UserController depends on this abstraction instead of a concrete implementation.

Enhancing Laravel Applications with Action-Based Architecture 💡

Peter Kostandy — Tue, 08 Aug 2023 17:13:00 +0000

Laravel is a popular PHP framework that provides a structured and elegant way to build web applications. As your application grows in complexity, maintaining clean and organized code becomes crucial.
One approach to enhance code organization is by using the concept of "Actions".
In this article, we will delve into what Laravel Actions are, why they are beneficial, and provide practical examples of how to implement them in your Laravel applications.

What Are Laravel Actions?

Laravel Actions are a design pattern that helps organize your application's logic into reusable and encapsulated classes.
They promote the Single Responsibility Principle (SRP) by separating different functionalities into distinct classes, resulting in cleaner and more maintainable code. Actions allow you to encapsulate the steps required to perform a specific action, making your codebase more modular and easier to test.

Benefits of Using Actions:

Modularity: Actions encourage breaking down your application's functionalities into small, focused classes. This promotes code reuse and ensures that changes to one part of the application have minimal impact on other parts.
Readability: With Actions, your code becomes self-documenting. Each Action class represents a specific action or use case, making it easier for developers to understand the purpose of the code.
Testability: Actions are highly testable because they encapsulate a specific functionality. You can write unit tests for each Action to ensure that it behaves as expected.
Separation of Concerns: Actions separate different concerns, such as validation, business logic, and database interactions. This leads to cleaner code where each class focuses on a single task.

Implementing Actions:

Let's illustrate the concept of Laravel Actions with a practical example.

Example 1: Creating a User
Suppose you want to create a new user in your application. You can encapsulate this logic into an Action class.

a) Create the Action class:

php artisan make:action CreateUserAction

b) Open CreateUserAction.php and define the logic:

namespace App\Actions;

use App\Models\User;

class CreateUserAction
{
    public function execute(array $data)
    {
        return User::create($data);
    }
}

c) Use the Action in a controller:

namespace App\Http\Controllers;

use App\Actions\CreateUserAction;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(Request $request, CreateUserAction $createUserAction)
    {
        $data = $request->all();
        $user = $createUserAction->execute($data);

        return response()->json($user, 201);
    }
}

Example 2: Sending Email Notifications
Let's say you want to send email notifications to users. Create an Action to handle this functionality.

a) Create the Action class:

php artisan make:action SendEmailNotificationAction

b) Open SendEmailNotificationAction.php and define the logic:

namespace App\Actions;

use Illuminate\Support\Facades\Mail;
use App\Mail\NotificationEmail;

class SendEmailNotificationAction
{
    public function execute($user, $message)
    {
        Mail::to($user->email)->send(new NotificationEmail($message));
    }
}

c) Use the Action in a controller or service:

namespace App\Http\Controllers;

use App\Actions\SendEmailNotificationAction;
use App\Models\User;
use Illuminate\Http\Request;

class NotificationController extends Controller
{
    public function sendNotification(Request $request, SendEmailNotificationAction $sendEmailNotificationAction)
    {
        $user = User::find($request->user_id);
        $message = $request->message;

        $sendEmailNotificationAction->execute($user, $message);

        return response()->json(['message' => 'Notification sent']);
    }
}

Example 3: Creating a Blog Post
Assume you want to create a blog post in your application using an Action.

a) Create the Action class:

Create an Action class named CreateBlogPostAction using the artisan command:

php artisan make:action CreateBlogPostAction

b) Open CreateBlogPostAction.php and define the Action Logic:

Open the CreateBlogPostAction.php file and define the logic for creating a new blog post. This may involve validating input, interacting with the database, and any other necessary steps.

use App\Models\BlogPost;

class CreateBlogPostAction
{
    public function execute(array $data)
    {
        // Validate input data
        $validatedData = validator($data, [
            'title' => 'required|string',
            'content' => 'required|string',
        ])->validate();

        // Create a new blog post
        return BlogPost::create($validatedData);
    }
}

c) Use the Action in a controller:

In your controller, you can use the Action to handle the creation of a new blog post:

use App\Actions\CreateBlogPostAction;

class BlogPostController extends Controller
{
    public function store(Request $request, CreateBlogPostAction $createBlogPostAction)
    {
        $data = $request->only(['title', 'content']);
        $blogPost = $createBlogPostAction->execute($data);

        // Redirect or return response
    }
}

These examples demonstrate how to use Actions in various scenarios within a Laravel application.
By encapsulating specific logic into Action classes, you can achieve better code organization, modularity, and testability.

Additional Considerations and Best Practices:

Dependency Injection: In the example above, we used dependency injection to inject the CreateBlogPostAction into the controller. This approach ensures that your controller remains focused on handling HTTP-related concerns while delegating the actual business logic to the Action class.
Error Handling: Consider adding error handling to your Actions. You can throw custom exceptions or return error messages based on the outcome of the Action's execution.
Authorization and Validation: Actions can encapsulate not only business logic but also authorization and validation rules. This keeps your controller methods concise and easy to understand.
Reusable Actions: As your application grows, you can reuse Actions across different parts of your application. For example, the same CreateBlogPostAction could be used in an API endpoint and a web form.
Unit Testing: Write comprehensive unit tests for your Action classes to ensure they function as expected. Laravel's testing tools make it straightforward to test individual components.
Documentation: Document your Action classes with clear descriptions of their purpose, input data, and expected outcomes. This helps other developers understand how to use them effectively.

Conclusion:

Laravel Actions provide a structured and elegant approach to organizing your application's logic. By encapsulating specific actions or use cases into separate classes, you can achieve greater modularity, readability, and testability in your codebase. Actions encourage adhering to best practices, such as the Single Responsibility Principle and the separation of concerns. As you continue developing your Laravel applications, consider adopting the Action design pattern to create cleaner, more maintainable, and more efficient code.

Keep innovating and coding with a smile! 😉👌

Laravel Pro Tips - Laravel Queue ✨

Peter Kostandy — Sat, 27 May 2023 11:21:14 +0000

✨ Unlocking Efficiency and Scalability: Harnessing the Power of Laravel Queue

📂 From "Laravel Pro Tips" series,

• Laravel queue is a powerful tool that allows developers to perform time-consuming tasks in the background, freeing up server resources and improving application performance. Here are some examples of how Laravel queue can be used in real-life scenarios:

Sending emails: When sending emails to a large number of recipients, it can take a lot of time and resources to process each email individually. By using the Laravel queue, developers can send emails in the background, allowing users to continue using the application without any delays.
Processing payments: When processing payments, it's important to ensure that transactions are completed quickly and securely. By using the Laravel queue, developers can process payments in the background, reducing the risk of errors or delays.
Generating reports: Generating reports can be a time-consuming task that requires a lot of server resources. By using the Laravel queue, developers can generate reports in the background, allowing users to continue using the application without any delays.
Image processing: When uploading and processing images on a website or application, it can take a lot of time and resources to resize or edit each image individually. By using the Laravel queue, developers can process images in the background, allowing users to continue using the application without any delays.
Data analysis: When performing data analysis on large datasets, it can take a lot of time and resources to process each data point individually. By using the Laravel queue, developers can perform data analysis in the background, allowing users to continue using the application without any delays.

• Overall, #Laravel_Queue is an essential tool for improving application performance and user experience by offloading time-consuming tasks to the background.

👉 Don't miss out on exclusive Laravel tips and tricks. Follow my LinkedIn account today! 😊

👉 Peter B. Youssef

5 tips for writing efficient PHP code 💡💹

Peter Kostandy — Mon, 15 May 2023 14:12:54 +0000

5 tips for writing efficient PHP code 💡💹

• Use Proper Variable Scope
• Minimize Database Queries
• Optimize Loops
• Use Built-in Functions
• Use Opcode Caching

For more information :
https://www.linkedin.com/feed/update/urn:li:activity:7062033419655888896/

By following these tips, you can improve the efficiency and performance of your PHP code, resulting in faster and more responsive applications.