Découvrez comment les logiciels sont générés

Le développement logiciel moderne a fondamentalement changé de la création de tout, de zéro à l’assemblage d’applications à partir de composants existants. Comprendre cette approche basée sur des composants est essentielle pour implémenter et gérer efficacement des logiciels dans des environnements de développement contemporains.

Modèle logiciel basé sur les composants

Les applications d’aujourd’hui sont créées en combinant du code d’origine avec des composants réutilisables. Au lieu d’écrire chaque élément de fonctionnalité, les équipes de développement assemblent des solutions à partir de :

• Code de logique métier d’origine : Code personnalisé qui implémente des exigences métier, des flux de travail et des fonctionnalités uniques qui différencient votre application.
• Bibliothèques et frameworks open source : Composants réutilisables créés et gérés par la communauté, fournissant des fonctionnalités courantes telles que le traitement des données, l’authentification, les interfaces utilisateur et les protocoles de communication.
• Composants commerciaux : Bibliothèques tierces offertes par les fournisseurs, offrant souvent des fonctionnalités spécialisées, un support et des garanties.
• Code d’intégration : Le code « Glue » qui connecte les composants ensemble, adapte les interfaces et orchestre les interactions entre différentes parties du système.

La recherche montre de façon cohérente que les applications modernes se composent d’environ 80% composants existants gérés en dehors du projet, avec seulement 20% étant du code d’origine écrit par l’équipe de développement. Cette composition reflète un changement fondamental de la façon dont le logiciel est créé, de la construction à l’assemblage.

Pourquoi les logiciels sont créés de cette façon

L’approche basée sur les composants offre des avantages significatifs :

Vitesse de développement

La réutilisation des composants existants accélère considérablement le développement :

• Solutions éprouvées : Au lieu de résoudre les problèmes que d’autres ont déjà résolus, les équipes incorporent des composants testés par la bataille qui fonctionnent de manière fiable.
• Temps de développement réduit : La création d’une infrastructure d’application web, d’un pilote de base de données ou d’un système d’authentification à partir de zéro prend des mois ou des années. L’utilisation de composants existants réduit cela à plusieurs jours ou heures.
• Concentrez-vous sur la valeur métier : Les développeurs se concentrent sur une logique métier unique plutôt que sur la réinvention de l’infrastructure commune.
• Réduction du délai de mise sur le marché : Les applications atteignent la production plus tôt, car les équipes n'ont pas besoin de créer chaque couche depuis le début.

Qualité et fiabilité

Les composants open source bien gérés dépassent souvent la qualité du code personnalisé :

• Vérification de la communauté : Les projets open source populaires ont des milliers d’utilisateurs qui identifient et signalent des problèmes, ce qui entraîne un code robuste et fiable.
• Développement d’experts : De nombreux projets open source sont créés et gérés par des experts spécialisés dans des domaines de problèmes spécifiques.
• Amélioration continue : Les projets actifs reçoivent des mises à jour régulières, des correctifs de bogues et des améliorations des contributeurs dans le monde entier.
• Test de production : Les composants utilisés par des milliers d’applications ont été testés dans différents environnements et scénarios.

Rentabilité

L’utilisation de composants open source réduit les coûts de développement et de maintenance :

• Aucun frais de licence : La plupart des composants open source sont gratuits à utiliser, ce qui évite les coûts de licence par siège ou par déploiement.
• Charge de maintenance partagée : Les correctifs de bogues et les améliorations sont fournis par la communauté, ce qui réduit les coûts de maintenance de votre organisation.
• Réduction des besoins en personnel : Teams n’a pas besoin de spécialistes pour chaque couche technologique, car il peut incorporer une expertise existante par le biais de composants.
• Réduction du coût total de possession : Bien que les composants commerciaux aient des coûts directs, les alternatives open source fournissent souvent des fonctionnalités similaires sans frais de licence.

Accès à l’innovation

Les communautés open source favorisent l’innovation technologique :

• Fonctionnalités de pointe : De nombreuses nouvelles technologies et approches émergent d’abord dans les projets open source.
• Effets de l’écosystème : Les infrastructures populaires créent des écosystèmes de composants, d’outils et de connaissances compatibles.
• Adoption flexible : Les organisations peuvent expérimenter de nouvelles technologies sans engagements financiers importants.
• Connaissances de la communauté : Une documentation complète, des didacticiels et un support communautaire facilitent l’adoption.

Composants open source et source fermée

Les composants sont fournis dans deux catégories fondamentales en fonction de la disponibilité du code source :

Composants open source

Le code open source est publiquement disponible pour toute personne à inspecter, utiliser, modifier et contribuer souvent à :

• Visibilité du code source : Vous pouvez examiner l’implémentation réelle, comprendre le fonctionnement du composant et vérifier les pratiques de sécurité.
• Participation communautaire : De nombreuses personnes peuvent contribuer à des améliorations, corriger des bogues et ajouter des fonctionnalités.
• Utilisation régie par la licence : Les licences open source spécifient des utilisations autorisées, allant d’une utilisation illimitée aux exigences que les dérivés partagent la même licence.
• Transparence: Les chercheurs en sécurité, les développeurs et les utilisateurs peuvent auditer le code pour les vulnérabilités, les portes dérobées ou les problèmes de qualité.

Les composants open source populaires sont les suivants :

• Langages de programmation et runtimes : Python, Node.js, .NET Core, Go, Rust.
• Frameworks web : React, Angular, Vue.js, Express, Django, Spring Boot.
• Bases: PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch.
• Outils de développement : Visual Studio Code, Git, Docker, Kubernetes.
• Bibliothèques: Lodash, Moment.js, NumPy, Pandas, TensorFlow.

Composants sources fermées

Les composants de source fermée (propriétaire) fournissent des fonctionnalités sans rendre le code source disponible :

• Distribution binaire : Les composants sont fournis en tant que fichiers binaires compilés ou bibliothèques empaquetées sans code source.
• Contrôle du fournisseur : La création de l’organisation contrôle les mises à jour, les fonctionnalités et les conditions de licence.
• Support commercial : De nombreux composants sources fermés incluent la prise en charge professionnelle, les contrats de niveau de service et la maintenance garantie.
• Transparence limitée : Les utilisateurs ne peuvent pas inspecter les détails de l’implémentation, ce qui rend les évaluations de sécurité et de qualité plus difficiles.

Par exemple, il existe de nombreux pilotes de base de données commerciaux, des kits sdk propriétaires, des outils spécifiques au fournisseur et des bibliothèques spécialisées spécifiques au secteur.

Distribution des composants

Les packages fournissent un mécanisme formalisé de distribution et de gestion des composants :

Structure de package

• Code binaire : Bibliothèques compilées prêtes à être utilisées dans les applications.
• Métadonnées: Informations sur le package, notamment le nom, la version, l’auteur et la description.
• Dépendances: Liste des autres packages requis pour que le composant fonctionne.
• Informations de licence : Conditions légales régissant la façon dont le package peut être utilisé.
• Documentation: Instructions d’utilisation, références d’API et exemples.

Écosystèmes de paquets

Différents langages de programmation ont établi des écosystèmes de package :

• npm (Gestionnaire de package de nœud) : Packages JavaScript et TypeScript, le plus grand registre de packages au monde avec plus de 2 millions de packages.
• PyPI (Index du package Python) : Packages Python, fournissant des bibliothèques pour la science des données, le développement web, l’automatisation, etc.
• NuGet : packages .NET pour les applications C#, F# et Visual Basic.
• Maven Central : Packages Java pour le développement Entreprise et Android.
• RubyGems : Packages Ruby pour les applications web et l’automatisation.
• Crates.io : Packages Rust pour la programmation des systèmes.

Outils de gestion des packages

Les gestionnaires de packages automatisent le téléchargement, l’installation et la mise à jour des dépendances :

• Résolution des dépendances : Déterminez et installez automatiquement les dépendances requises.
• Gestion des versions : Suivez les versions des packages que votre application utilise.
• Notifications de mise à jour : Informez les développeurs quand des versions plus récentes sont disponibles.
• Analyse des vulnérabilités : Certains gestionnaires de packages intègrent l’analyse de sécurité pour identifier les vulnérabilités connues.

Implications du développement basé sur les composants

Bien que l’approche basée sur les composants offre d’énormes avantages, elle présente également des défis :

Complexité de la gestion des dépendances

• Arborescences de dépendances : Votre application peut dépendre directement de 20 packages, mais ces packages dépendent d’autres, créant des arborescences de centaines ou de milliers de dépendances.
• Conflits de version : Différents composants peuvent nécessiter des versions incompatibles des dépendances partagées.
• Mettre à jour les cascades : La mise à jour d’un composant peut nécessiter la mise à jour de plusieurs autres.

Considérations relatives à la sécurité

• Vulnérabilités héritées : Les vulnérabilités de sécurité dans toutes les dépendances affectent votre application.
• Attaques de chaîne d’approvisionnement : Les acteurs malveillants peuvent compromettre les packages populaires pour attaquer les applications qui en dépendent.
• Dépendances non détenues : Les composants qui ne sont plus gérés ne recevront pas de mises à jour de sécurité.

Conformité de la licence

• Obligations de licence : Chaque licence open source a des exigences : certaines autorisent une utilisation commerciale illimitée, d’autres nécessitent le partage de votre code source.
• Prolifération des licences : Une application peut incorporer des centaines de packages avec des dizaines de licences différentes.
• Charge de conformité : Les organisations doivent suivre les obligations de licence et garantir la conformité.

Dépendances opérationnelles

• Hébergement externe : De nombreuses applications dépendent de packages hébergés sur des registres publics qui peuvent rencontrer des pannes.
• Disponibilité du Registre : Si un registre public devient indisponible, les builds et les déploiements peuvent échouer.
• Suppression du package : Les auteurs peuvent parfois supprimer des packages des registres publics, cassant les applications qui en dépendent.

Comprendre comment les logiciels modernes sont créés avec des composants fournit un contexte essentiel pour la sécurité, les problèmes juridiques et opérationnels auxquels les organisations doivent répondre lors de l’implémentation de logiciels open source. Les unités restantes de ce module explorent ces préoccupations et stratégies pour les gérer efficacement.