DEV Community: Victor

Comment j’ai construit le site d’Illis Digital avec Astro

Victor — Tue, 10 Mar 2026 10:02:06 +0000

Pour le site de Illis Digital, mon objectif était simple : créer un site rapide, moderne et facile à maintenir.

Plutôt que de partir sur un framework lourd, j’ai choisi Astro, un framework qui met l’accent sur la performance et les sites orientés contenu.

Pourquoi Astro ?

Astro se distingue par sa philosophie : envoyer le moins de JavaScript possible au navigateur.

Contrairement à beaucoup de frameworks front-end classiques, les pages sont générées en HTML statique par défaut, et le JavaScript n’est chargé que lorsque c’est nécessaire.

Les avantages sont immédiats :

des pages ultra rapides
un SEO optimisé
une complexité côté client réduite

Astro utilise également l’architecture dite des “îlots” : la majeure partie du site reste statique, et seuls certains composants interactifs chargent du JavaScript. Cela permet de combiner performance et interactivité sans alourdir le site.

Construire le site d’Illis Digital

Pour Illis Digital, j’ai structuré le site autour de composants réutilisables et de pages statiques générées au moment du build.

Le résultat : un site léger, moderne et prêt à évoluer, tout en restant facile à maintenir et performant sur tous les devices.

Astro permet également d’intégrer facilement d’autres outils ou frameworks front-end si besoin, tout en gardant le contrôle sur les performances.

Illis Digital en quelques mots

Illis Digital a pour mission de créer des sites web modernes, rapides et efficaces pour les entreprises.

Le web devient de plus en plus complexe, mais les utilisateurs attendent toujours :

un site rapide
une navigation fluide
une expérience utilisateur optimale

C’est exactement ce que permet Astro, et c’est pour ça que ce projet a été un vrai plaisir à construire.

Demeter's Law in PHP: Principle, Examples, and Best Practices

Victor — Mon, 03 Nov 2025 07:51:15 +0000

📝 This article is an English translation of the original French version available here: https://victor-prdh.com/blog/03-loi-de-demeter.md/

Demeter's Law in PHP: Writing Code That Talks Less… but Better

In software development, we often hear about best practices: decoupling, separation of concerns, SOLID principles… But there is one, sometimes overlooked, that deserves our attention: Demeter's Law. Also known as the principle of least knowledge, it helps write more robust, readable, and maintainable code.

In this article, we will see what it entails, why it is useful, and how to apply it practically in your PHP and Symfony projects.

What is Demeter's Law?

Formulated in the late 1980s at MIT, Demeter's Law is based on a simple idea:

“An object should only talk to its immediate friends, not to the friends of its friends.”

In other words, a class should limit its knowledge of the system. It should only interact with:

itself (its own methods),
its direct attributes,
its method parameters,
the objects it creates,
and possibly global objects (like singletons, though these should be avoided).

The goal is to prevent code from being too dependent on the internal structure of other objects.

Example of Demeter Law Violation

Here’s a common example:

$city = $order->getCustomer()->getAddress()->getCity();

Here, to get the city of a customer, the Order object must expose its Customer, which exposes its Address, which exposes its City.

This is what we call the train wreck pattern: a long chain of calls showing that we know far too much about the internal structure of the object.

Corrected Example

A better approach is to delegate responsibility to the appropriate objects:

class Order
{
    private Customer $customer;

    public function getCustomerCity(): string
    {
        return $this->customer->getCity();
    }
}

Then, usage becomes:

$city = $order->getCustomerCity();

This way, the Order object becomes responsible for how the information is accessed.

If the internal structure of Customer changes tomorrow (for example, if the address is no longer directly linked to the Customer object), the calling code will not be impacted.

Concrete Benefits

Respecting Demeter's Law brings several immediate benefits:

Robustness: internal changes do not affect calling code.
Encapsulation: objects hide their internal details.
Readability: fewer chained calls, code expresses directly what we want.
Testability: it's easier to test a single method than to simulate a long object chain.

Conclusion

Demeter's Law is a simple but powerful rule: “only talk to your close friends.”

By avoiding excessive chained calls and delegating responsibilities to the right objects, you get code that is:

clearer,
more robust,
easier to maintain.

Take a moment to review your code: how many successive -> calls do you find?

It might be a sign that it's time to apply Demeter's Law.

What about you?

Share your experience or tips with me on LinkedIn — happy to chat!

Traits in PHP – a powerful yet underused tool?

Victor — Wed, 21 May 2025 09:07:32 +0000

📝 This article is an English translation of the original French version available here: https://victor-prdh.com/blog/02-traits-avec-php/

PHP does not support multiple inheritance. To work around this limitation, Traits were introduced in PHP 5.4. They allow injecting methods into several classes without using class inheritance.

When misused, they can harm readability and maintainability. When mastered, they are a great tool to structure shared code. Here's an overview of use cases, best practices, and common pitfalls.

1. Why Traits?

In PHP, a class can only inherit from one parent class. Traits allow factoring reusable behavior into multiple different classes.

trait LoggerTrait {
    public function log(string $message): void {
        echo "[LOG] $message\n";
    }
}

class ServiceA {
    use LoggerTrait;
}

class ServiceB {
    use LoggerTrait;
}

2. Practical use cases

Traits are useful for encapsulating cross-cutting behaviors.

Shared logger

trait LoggerTrait {
    public function log(string $message): void {
        echo date('Y-m-d H:i:s') . " - $message\n";
    }
}

Soft delete

trait SoftDeleteTrait {
    private ?\DateTime $deletedAt = null;

    public function delete(): void {
        $this->deletedAt = new \DateTime();
    }

    public function isDeleted(): bool {
        return $this->deletedAt !== null;
    }
}

3. Best practices

One Trait = one responsibility

Avoid catch-all Traits. Each Trait should have a clear and focused purpose.

Explicit method names

Clear names help avoid collisions. Prefer handleForm() over handle().

No hidden dependencies

A Trait should not assume the existence of properties or methods unless clearly defined or injected.

// Bad
trait BrokenTrait {
    public function doSomething(): void {
        $this->repository->save(); // hidden dependency
    }
}

// Good
trait WellDefinedTrait {
    protected RepositoryInterface $repository;

    public function setRepository(RepositoryInterface $repo): void {
        $this->repository = $repo;
    }

    public function doSomething(): void {
        $this->repository->save();
    }
}

4. Pitfalls to avoid

Method name collisions

If two Traits define the same method, you must resolve the conflict explicitly.

class C {
    use A, B {
        B::sayHello insteadof A;
    }
}

Overuse

Too many Traits in a single class can reduce clarity.

False abstraction

Traits are not a replacement for solid object-oriented design. If you need polymorphism or hierarchy, prefer interfaces or abstract classes.

5. Alternatives

Interface + abstract class: more restrictive but often clearer.
Composition: delegate responsibilities to other objects.
Dedicated services: in Symfony, injecting a service is often cleaner.

Conclusion

Traits are a useful tool to structure shared code—if used with moderation and discipline.

In short:

Keep them focused.
Avoid hidden dependencies.
Prefer composition when Traits become too heavy.

Well used, Traits simplify. Misused, they complicate. It's your call.

What about you?

Were you familiar with Traits in PHP?

Share your experience or tips with me on LinkedIn — happy to chat!

[Boost]

Victor — Mon, 19 May 2025 10:06:36 +0000

Victor

May 12 '25

Boosting Performance with Symfony HttpClient and Parallel Requests

#symfony #php #performance

Comments

2 min read

Boosting Performance with Symfony HttpClient and Parallel Requests

Victor — Mon, 12 May 2025 14:52:05 +0000

📝 This article is an English translation of the original French version available here: https://victor-prdh.com/blog/01-requete-asynchrone-symfony/

When developing a Symfony application that communicates with multiple APIs, it's tempting to send requests one after another. However, this approach can quickly become a bottleneck.

Fortunately, Symfony’s HttpClient component makes it easy to manage multiple parallel requests — without threads, promises, or workers.

In this article, I’ll show you how to take advantage of this feature to improve performance.

The Classic Problem: Sequential API Calls

Let’s take a simple example. You need to query 5 APIs to retrieve and merge data. Most developers would instinctively write something like this:

$results = [];

foreach ($urls as $url) {
    $response = $client->request('GET', $url);
    $results[] = $response->toArray();
}

This code works, but it’s slow: each request waits for the previous one to complete before starting.

The Solution: `stream()` for Concurrent Requests

Symfony provides a more powerful API with the stream() method. It allows you to fire off all requests at once and process responses as soon as they’re ready — avoiding unnecessary blocking.

Here’s how:

$responses = [];

foreach ($urls as $url) {
    $responses[] = $client->request('GET', $url);
}

// Read responses as they come in
foreach ($client->stream($responses) as $response => $chunk) {
    if ($chunk->isLast()) {
        $result = $response->toArray();
        // Process the result
    }
}

This code:

sends all requests in parallel
processes each response as soon as it’s complete
significantly reduces total execution time

Performance Gains

Gains depend on your target APIs, but in many cases, you can cut total response time by a factor of 2 to 10, especially when APIs take 300 to 500 ms to respond individually.

When to Use This Method

Use stream() whenever you have:

multiple independent API calls to make
simple response processing logic
slow or numerous third-party APIs

In Summary

Symfony HttpClient allows you to write simple, readable, and asynchronous code without adding unnecessary technical complexity.

The stream() method is a powerful tool to add to your toolbox for any API-driven Symfony project.

Go Further

To explore the full capabilities of HttpClient and stream(), check out the official Symfony documentation.

What About You?

Have you already used stream() in your Symfony projects?

Share your feedback or tips with me on LinkedIn — I’d love to chat!

Adding ReCaptha to Symfony

Victor — Wed, 24 Aug 2022 19:03:36 +0000

Why ReCaptcha are required today ?

With all these bots who are spamming the web, having a recaptcha to protecting your contact or sign-up section. It's pretty simple to set-up, nearly 5 minutes when you know the steps, for this tutorial we gonna say 15 minutes max !

Sign up to Google Console

If you want to integrate a ReCaptcha to your website, you need to ask google give you token for be able to use their service. It's very simple and no verifications are required. Just go to the ReCaptcha console and fill your informations.

As you can see in this example, i added a name, choosed the ReCaptcha V2 and added my domain name. The little trick is i added localhost too. With this domain added on the console i will be able to test it on my local server.

Coding time

Now go to your symfony project. The first step is to require the recaptcha-bundle with:

composer require victor-prdh/recaptcha-bundle

With Symfony flex

You can quickly configure this bundle by using symfony/flex:

answer no for google/recaptcha
answer yes for victor-prdh/recaptcha-bundle

If everything is good, you must have the bundle registred in the "bundles.php" file of your config folder ("config/bundles.php"):

//config/bunldes.php
<?php
return [
    ...
    VictorPrdh\RecaptchaBundle\RecaptchaBundle::class => ['all' => true]
];

Just add it if you dont see this line.

You can directly go to Usage section

Without Symfony flex

If you don't want / you can't use the flex recipe you can create a "recaptcha.yaml" file in your config folder ("config/packages/recaptcha.yaml"):

#config/packages/recaptcha.yaml
recaptcha:
  google_site_key: '%env(GOOGLE_RECAPTCHA_SITE_KEY)%'
  google_secret_key: '%env(GOOGLE_RECAPTCHA_SECRET_KEY)%'

Once you created this config file, you can go in your ".env" file and add this:

###> victor-prdh/recaptcha ###
# https://www.google.com/recaptcha/admin  <--- get keys here
GOOGLE_RECAPTCHA_SITE_KEY='your site key'
GOOGLE_RECAPTCHA_SECRET_KEY='your secret key'
###< victor-prdh/recaptcha ###

It's time for update the bundle, if you don't do it, your keys will not be used by the bundle.

composer update victor-prdh/recaptcha-bundle

Usage

Integration in Symfony Form

You have now a "ReCaptchaType" class available for all your forms. You can use it in your FormBuilder like a "TextType" or "PasswordType":

<?php

namespace App\Form;

use VictorPrdh\RecaptchaBundle\Form\ReCaptchaType;

class TaskType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder->add("recaptcha", ReCaptchaType::class);
    }
}

Display error on your Twig view

Once you create the form, you render it as usual with Symfony. You can show it in your twig file like that:

{{ form_start(form) }}

    {{ form_row(form.recaptcha) }} 
    {# must be the same name of this put on the FormBuilder #}

    {{ form_errors(form.recaptcha) }}
    {# That will display the error of the captcha to user #}

{{ form_end(form) }}

And voilà ! You have your ReCapthca verification set-up on your symfony project !

DEV Community: Victor

Comment j’ai construit le site d’Illis Digital avec Astro

Pourquoi Astro ?

Construire le site d’Illis Digital

Illis Digital en quelques mots

Demeter's Law in PHP: Principle, Examples, and Best Practices

Demeter's Law in PHP: Writing Code That Talks Less… but Better

What is Demeter's Law?

Example of Demeter Law Violation

Corrected Example

Concrete Benefits

Conclusion

What about you?

Traits in PHP – a powerful yet underused tool?

1. Why Traits?

2. Practical use cases

3. Best practices

4. Pitfalls to avoid

5. Alternatives

Conclusion

What about you?

[Boost]

Boosting Performance with Symfony HttpClient and Parallel Requests

Boosting Performance with Symfony HttpClient and Parallel Requests

The Classic Problem: Sequential API Calls

The Solution: stream() for Concurrent Requests

Performance Gains

When to Use This Method

In Summary

Go Further

What About You?

Adding ReCaptha to Symfony

Why ReCaptcha are required today ?

Sign up to Google Console

Coding time

With Symfony flex

Without Symfony flex

Usage

Integration in Symfony Form

Display error on your Twig view

The Solution: `stream()` for Concurrent Requests