Pourquoi un code propre est important

Dans divers projets de conseil, j'ai remarqué dernièrement que la même chose ne cesse de se répéter : le code clusterisé. Qu’est-ce que je veux dire par là ? Eh bien, permettez-moi de le dire de cette façon. Lorsque vous codez, vous devez penser à un code propre. Oui, je sais, encore une personne qui parle de code propre. Pourquoi devrais-tu m'écouter ? Depuis l’âge de 12 ans, je m’intéresse aux ordinateurs et à leur fonctionnement. Quand j'ai eu 15 ans, j'ai commencé à regarder Pluralsight, un tas de vidéos sur la façon de faire du MVVM, du MVC, de l'architecture, etc. J'ai regardé des tonnes de vidéos, mais je ne savais pas encore programmer. J'ai suivi, mais je me souviens de ne pas avoir bien compris ce qui se passait.

Au cours des dernières années, j'ai travaillé comme architecte et développeur de logiciels senior pour diverses entreprises. J'ai une formation en ingénierie informatique et en apprentissage informatique. Et j'essaie de partager avec vous ce que je sais, comme vous le savez tous, pour aider les gens, mais aussi pour me faire connaître comme tous les gens sur LinkedIn. Ouais, ils n'aiment pas écrire autant que vous le pensez ; c'est purement un modèle commercial. Mais cela n'a pas d'importance, n'est-ce pas ? Alors voilà. J'espère qu'un jour vous achèterez un de mes produits. ;)

Maintenant, laissez-moi vous raconter ce que j'ai vu dernièrement dans différents projets. Je pense que la raison pour laquelle un code propre n’est pas toujours appliqué n’est pas nécessairement due au manque de connaissances. Il s'agit souvent de délais stricts et de pression des différents projets. Si vous êtes un ingénieur logiciel comme moi ou un chef de projet, vous savez qu'il existe certaines contraintes et pressions temporelles nécessaires à la réussite d'un projet.

Afin de livrer au client, et même lorsque vous travaillez en interne, vous êtes confronté à des délais et à différentes parties prenantes. Les entreprises fonctionnent souvent sur un modèle d'abonnement dans lequel les clients attendent régulièrement de nouvelles fonctionnalités. Cela crée de nombreux défis. Les développeurs et les planificateurs de projet doivent faire avancer le projet sans tomber dans le piège de la dette architecturale parce qu'ils n'ont pas eu suffisamment de temps pour réfléchir correctement à la solution.

Une fois ce problème posé, il est vraiment difficile de revenir en arrière et de le résoudre. D’après mon expérience, les gens ne reviennent pas souvent pour refactoriser leurs projets – du moins pas les gens que je connais. Faites-moi savoir si vous êtes différent. Il y a différentes choses que vous pouvez faire pour refactoriser, et cela aide beaucoup, mais le problème est que ce n'est pas une priorité. Si le code fonctionne et que le client est satisfait, la refactorisation n'est pas en tête de liste. Mais réfléchissons à deux ou trois ans. Que se passera-t-il une fois que le code deviendra de plus en plus clusterisé ?

Vous pourriez finir par embaucher de nombreux développeurs pour refondre l'architecture monolithique vers une architecture de microservices, ce qui coûte très cher. C'est pourquoi vous devriez penser à un code propre, pas seulement lorsque vous démarrez un projet, ni seulement lorsque vous vous réveillez, mais tout le temps. Parce qu'à terme, il reviendra vous mordre si vous ne l'appliquez pas.

Stratégies pratiques pour un code propre

Révisions cohérentes du code
Des révisions régulières du code garantissent le respect des normes de codage et détectent rapidement les problèmes potentiels.

Tests automatisés
La mise en œuvre de tests automatisés, notamment des tests unitaires, des tests d'intégration et des tests de bout en bout, permet d'identifier les problèmes avant qu'ils ne soient mis en production.

Refactoriser régulièrement
Prévoyez du temps dans votre calendrier de projet spécifiquement pour la refactorisation afin d'éviter l'accumulation de dettes techniques et de maintenir votre base de code maintenable.

Adopter des principes SOLIDES
Les principes SOLID (responsabilité unique, ouvert-fermé, substitution Liskov, ségrégation d'interface et inversion de dépendance) fournissent un cadre pour écrire du code propre et maintenable.

Documentation claire
La rédaction d'une documentation claire et concise aide les nouveaux développeurs à comprendre la base de code plus rapidement et réduit le risque d'introduction d'erreurs.

Programmation en binôme
La programmation en binôme permet à deux développeurs de travailler ensemble sur le même code, de détecter rapidement les erreurs et de partager leurs connaissances entre les membres de l'équipe.

Avantages à long terme du Clean Code

Coûts de maintenance réduits
Un code propre est plus facile à maintenir, ce qui réduit le temps et l'argent consacrés à la correction des bogues et à la mise en œuvre de nouvelles fonctionnalités.

Lisibilité et compréhension améliorées
Une base de code propre est plus facile à lire et à comprendre, ce qui est crucial pour l'intégration de nouveaux développeurs et pour la durabilité du projet à long terme.

Performances améliorées
Un code bien structuré conduit à de meilleures performances en évitant la complexité inutile et en optimisant l'utilisation des ressources.

Une plus grande évolutivité
Un code propre permet une mise à l'échelle plus facile des applications, simplifiant le processus d'ajout de nouvelles fonctionnalités et d'adaptation aux exigences changeantes.

Satisfaction accrue des développeurs
Travailler avec du code propre réduit la frustration et augmente la satisfaction professionnelle des développeurs, ce qui entraîne une productivité plus élevée et des taux de rotation plus faibles.

Exemple de code désordonné

<?php

class User extends security\Session
{
  protected $app;

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

  public function addSkill(Application $app, Request $request)
  {
    $userInput['id'] = $request->request->get('id', null);
    $userInput['id'] = preg_replace("/[^0-9,.]/", "", $userInput['id']);

    $app['checkpoint']->minimumRole(1);
    $user = $app['session']->get('user', []);
    $userId = $user['profile']['easyJobAddressId'];

    if ($userInput['id'] === null) {
      return $app->json(['ok' => true]);
    }

    $app['dbs']['appMySql']->insert('skills', [
      'skillId' => $userInput['id'],
      'userId' => $userId,
      'rank' => 0
    ]);

    return $app->json(['ok' => true]);
  }
}

Code refactorisé

Le code refactorisé adhère aux principes de code propre en décomposant les responsabilités, en utilisant l'injection de dépendances et en suivant les principes SOLID.

Injection de dépendances et constructeur

public function __construct(
    UserRoleService $userRoleService, RequestStack $requestStack,
    UserRepository $userRepository,
    EasyJobServiceInterface $easyJobService,
    SkillsRepository $skillsRepository,
    AppDataService $appDataService
) {
    $this->userRoleService = $userRoleService;
    $this->requestStack = $requestStack;
    $this->userRepository = $userRepository;
    $this->easyJobService = $easyJobService;
    $this->skillsRepository = $skillsRepository;
    $this->appDataService = $appDataService;
}

En injectant des dépendances, nous garantissons que chaque classe a une responsabilité unique et peut être facilement testée et maintenue.

Responsabilité unique pour l'ajout de compétences

#[Route('/profile/experience/add', name: 'profile_experience_add', methods: ['POST'])]
public function addExperience(Request $request): JsonResponse
{
    $this->denyAccessUnlessGranted('ROLE_USER');
    $skillId = $request->request->get('id');

    if (!is_numeric($skillId)) {
        return $this->json(['status' => 'error', 'message' => 'Invalid skill ID']);
    }

    $userId = $this->getUser()->getId();
    $result = $this->appDataService->addSkillToUser($userId, (int) $skillId);

    return $this->json(['status' => 'ok', 'added' => $result]);
}

Ici, nous utilisons une méthode dédiée pour gérer l'ajout de compétences. Il garantit la validation et suit une structure claire et concise.

Séparation des préoccupations

public function index(): Response {
    $user = $this->getUser();
    $userId = $user->getId();

    $allSkills = [90, 10, 11, 12, 13, 20, 21, 22, 23, 30, 31];
    $skills = array_fill_keys($allSkills, 0);

    $userSkills = $this->appDataService->getSkillsByUserId($userId);
    foreach ($userSkills as $skill) {
        $skillId = $skill->getSkillId();
        if (array_key_exists($skillId, $skills)) {
            $skills[$skillId] = 1;
        }
    }
}

Remarquez comment nous utilisons appDataService pour découpler le système.
En séparant les préoccupations, nous gardons chaque méthode concentrée sur une seule tâche, ce qui rend le code plus facile à lire et à maintenir.

Conclusion

En conclusion, pensez toujours à un code propre. Cela ne semble peut-être pas urgent pour le moment, mais le négliger peut entraîner des problèmes importants à long terme. Donner la priorité à un code propre permettra d’économiser du temps, de l’argent et des maux de tête à l’avenir. Refactoriser régulièrement et adhérer aux normes de codage sont essentiels pour maintenir une base de code saine. N'oubliez pas que les efforts que vous consacrez aujourd'hui à l'écriture de code propre seront payants à long terme, rendant vos projets plus évolutifs, plus maintenables et plus agréables à travailler.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!