DEV Community: Ahmed sliman

[Boost]

Ahmed sliman — Tue, 22 Sep 2026 09:57:37 +0000

Ahmed sliman

Mar 15 '22

The Clean Architecture in PHP: A Short Review

#php #solid #designpatterns #architecture

2 min read

Laravel Events 101

Ahmed sliman — Tue, 19 Dec 2023 09:08:04 +0000

What is Event-Driven Programming?

Simply put, events are actions that occur within an application. Coming from the world of JavaScript, you probably understand events as user actions such as mouse click, mouseover, key press, etc. In Laravel, events can be various actions that occur within an application such as email notifications, logging, user sign-up, CRUD operations, etc. Laravel events provide a simple observer implementation, allowing you to subscribe and listen for various events that occur in your application.

Why should we use Events?!

Easier to maintain (SOLID).
Less risk of regression,
Make classes responsible for only one thing,
Make team’s work easier,
Expect the unexpected, If you ever need to add new functionality, all you need to do is create a new listener and register it with the event. Job is done!
Your logic is separated and now the Controller has much-reduced responsibility
Allow asynchronous tasks easily (queues in Laravel).
Be ready for broadcasting

Let's compare two pieces of code with/without events

With

Without

How do we create Events?

Defining Our Events

php artisan make:event UserRegistered

The event has been created successfully

php artisan make:listener SendWelcomeMail --event=UserRegistered

The listener has been created successfully

php artisan make:listener SignupForWeeklyNewsletter --event=UserRegistered

The listener has been created successfully

php artisan make:listener SendSMS --event=UserRegistered

The listener has been created successfully

ESP - EventServiceProvider

php artisan event:generate

Events and Listeners generated successfully

Stopping The Propagation Of An Event

Eloquent Native Events

With his Eloquent model, Laravel will automatically fire created, saved, updated and deleted events respectively.

To start listening to model events, define a $dispatchesEvents property on your Eloquent model. This property maps various points of the Eloquent model's lifecycle to your event classes. Each model event class should expect to receive an instance of the affected model via its constructor.

Eloquent Native Events

Why MobX?

Ahmed sliman — Wed, 07 Sep 2022 09:27:34 +0000

MobX?
It's an open source state management tool. When creating a web application, developers often seek an effective way of managing state within their applications.

Why MobX?

MobX get you an ability to handle multiple data-structures of states
Sync render by tracking observable pieces of state
Help on scalable applications with manage state easily

What is State?

Application state refers to the entire model of an application and can contain different data types including arrays, numbers, and objects. In MobX, actions are methods that manipulate and update the state. These methods can be bound to a JavaScript event handler to ensure a UI event triggers them.

MobX concepts

MobX has four principle concepts that we should learn, to understand how it works: observables, computed values, reactions and actions.
MobX also introduces a few concepts: state, actions, and derivations (including reactions and computed values).
By wrapping the component with an observer, it will now automatically become aware of changes in the store

The Clean Architecture in PHP: A Short Review

Ahmed sliman — Tue, 15 Mar 2022 16:57:31 +0000

I recently finished reading The Clean Architecture in PHP, and it was an enjoyable and practical journey through SOLID principles, design patterns, and Clean Architecture.

The book does a great job of introducing the theory behind these concepts before applying them to a growing PHP project. Instead of presenting architecture as a collection of abstract ideas, it demonstrates how an application can evolve while keeping its business logic maintainable and independent from external concerns.

One of the most interesting parts is the gradual transition between frameworks. The project moves from Zend to Laravel and then Symfony, showing how a well-decoupled application can adapt to different technologies without requiring major changes to its core business logic.

What I liked about the book

It explains SOLID principles and common design patterns in a practical way.
It introduces the theory briefly before applying it to a real project.
The project grows throughout the book, making the architectural decisions easier to understand.
It demonstrates how to isolate framework-specific code.
It shows how the same application can be adapted to different PHP frameworks.
It focuses on practical decoupling rather than architecture for its own sake.

Some topics were covered rather briefly, so I occasionally used additional resources to explore them in more detail. However, this did not take away from the overall learning experience.

Practical lessons I took from the book

Keep business logic independent of frameworks whenever possible.
Depend on abstractions rather than concrete implementations.
Use dependency injection to make code easier to test and replace.
Avoid putting too much responsibility into controllers or service classes.
Introduce design patterns to solve real problems—not simply to make the code look sophisticated.
Treat architecture as something that evolves as a project grows.
Isolate framework-specific code at the boundaries of the application.
Write tests for business rules independently of the database and web framework.
Prefer small, focused classes over large classes with many responsibilities.
Refactor continuously instead of waiting until the codebase becomes difficult to maintain.

Final thoughts

Overall, this book provides a practical introduction to Clean Architecture in PHP. Its biggest strength is the combination of theory and application: concepts are introduced and then demonstrated through a project that becomes more advanced over time.

I would recommend it to developers who already understand the basics of object-oriented programming and want to improve the structure, flexibility, and maintainability of their applications. It is also a useful resource for anyone who wants to understand why decoupling matters and how to apply it in a real-world project.

This is a short review because the book felt less like a collection of isolated lessons and more like an enjoyable journey through better software design.