Découvrez le rôle d’un langage back-end et votre environnement de travail

Avant d’écrire vos premières fonctionnalités back-end, prenez un moment pour comprendre le terrain sur lequel vous allez travailler.

Quand vous découvrez une base de code existante, vous ne partez pas d’une page blanche. Vous ouvrez un projet déjà organisé, avec des fichiers, des dossiers, parfois des données et une logique déjà en place. Votre première mission consiste alors à l’explorer, à comprendre son organisation, à l’exécuter, puis à y ajouter progressivement de petites fonctionnalités.

Pour réussir, vous n’avez pas seulement besoin de savoir “écrire du code”. Vous devez aussi comprendre ce que fait un langage back-end, à quoi servent les outils de développement, comment se repérer dans un projet, et comment observer ce qui se passe quand un programme s’exécute.

C’est l’objectif de ce premier chapitre : vous donner une vue d’ensemble simple avant d’entrer dans les concepts de programmation.

Comprenez le rôle d’un langage back-end

Quand vous utilisez une application, vous voyez surtout son interface : des boutons, des formulaires, des menus, des messages à l’écran. Cette partie visible est généralement appelée le front-end. Avec les frameworks modernes comme React, Angular ou Vue, le front-end ne se contente plus d’afficher des écrans : il reçoit aussi des données, effectue des vérifications simples, filtre ou met en forme des informations avant de les présenter à l’utilisateur.

Le back-end, lui, correspond à la partie moins visible de l’application. Il prend en charge ce qui ne peut pas — ou ne doit pas — être fait côté navigateur : appliquer les règles métier sensibles, accéder aux données stockées, garantir la sécurité et servir de source de vérité commune à tous les utilisateurs. Concrètement, il peut par exemple :

• recevoir une donnée envoyée par le front-end ;

• valider cette donnée selon les règles métier de l’application ;

• lire ou modifier des informations dans une base de données ou un fichier ;

• appliquer un calcul ou un traitement qui doit rester fiable et non modifiable côté client ;

• renvoyer un résultat au front-end pour qu’il l’affiche à l’utilisateur.

Un langage back-end sert donc à écrire cette logique côté serveur, celle qui garantit la cohérence de l’application quel que soit l’appareil ou le navigateur utilisé.

Prenons un exemple simple. Imaginez une application qui gère une liste de produits. Côté utilisateur, on peut voir un nom de produit, un prix et une quantité disponible. Côté back-end, le programme doit peut-être vérifier si le produit existe, calculer un prix total, mettre à jour un stock ou afficher un message si la quantité demandée est trop élevée.

En pseudo-code, cette logique pourrait ressembler à ceci :

SI quantité demandée <= quantité disponible
    afficher "Commande possible"
SINON
    afficher "Stock insuffisant"
FIN SI

Ce n’est pas encore du Java, du Python ou du C#. Pourtant, la logique est déjà là : le programme compare deux informations, prend une décision, puis produit un résultat.

Dans ce cours, vous allez donc vous concentrer sur les raisonnements qui existent dans tous les langages : variables, conditions, boucles, fonctions, objets, erreurs et fichiers.

Identifiez ce que fait un programme

Un programme back-end suit généralement une logique en plusieurs étapes.

Il reçoit ou récupère des informations. Il les traite. Puis il produit un résultat.

On peut résumer ce fonctionnement ainsi :

Entrée → Traitement → Sortie

• L’entrée, c’est l’information utilisée par le programme. Elle peut venir d’un utilisateur, d’un fichier, d’une base de données ou d’un autre programme.

• Le traitement, c’est la logique appliquée à cette information : calcul, vérification, transformation, comparaison, organisation.

• La sortie, c’est le résultat produit : un message affiché dans la console, une donnée modifiée, un fichier mis à jour ou une information renvoyée à une autre partie de l’application.

Prenons un exemple très simple :

Entrée :
    prix = 20
    quantité = 3

Traitement :
    total = prix * quantité

Sortie :
    afficher total

Le programme reçoit deux informations : un prix et une quantité. Il les multiplie. Puis il affiche le résultat.

Cette structure peut sembler évidente, mais elle est essentielle. Quand vous explorez un code existant, demandez-vous :

• quelles informations ce fichier utilise-t-il ?

• que fait-il avec ces informations ?

• quel résultat produit-il ?

• où ce résultat est-il affiché, enregistré ou transmis ?

Ces questions vous aideront à lire un code existant sans vous perdre dans tous les détails.

Découvrez votre environnement de développement

Pour travailler sur un projet back-end, vous utiliserez plusieurs outils. Vous n’avez pas besoin de les maîtriser parfaitement dès le départ, mais vous devez comprendre leur rôle.

Le premier outil est l’IDE (pour Integrated Development Environment) : c’est le terme anglais que vous rencontrerez quasiment toujours dans la pratique. Son équivalent français, EDI (environnement de développement intégré), existe mais est très peu utilisé. C’est le logiciel dans lequel vous ouvrez, lisez et modifiez le code.

Un IDE vous aide à :

• parcourir les fichiers du projet ;

• écrire du code plus facilement ;

• repérer certaines erreurs ;

• lancer le programme ;

• parfois utiliser un terminal intégré.

Le deuxième outil important est le terminal. Le terminal permet d’envoyer des instructions à votre ordinateur sous forme de texte. Dans un projet back-end, vous pouvez l’utiliser pour installer des dépendances, lancer le programme, exécuter une commande ou lire des messages d’erreur.

Le troisième élément à connaître est le gestionnaire de paquets. Un projet utilise souvent du code déjà préparé par d’autres personnes ou par la communauté. Ces éléments externes sont appelés des dépendances. Le gestionnaire de paquets sert à les installer et à les gérer.

Selon la stack, les noms changent. Vous rencontrerez des outils différents en Java, Python ou C#. Mais l’idée reste la même : votre projet a besoin d’un environnement pour être lu, exécuté et maintenu.

Votre environnement de travail n’est donc pas seulement un endroit où écrire du code : c’est aussi un espace d’observation. Vous y lancez le programme, vous lisez ce qu’il affiche, vous repérez les erreurs et vous vérifiez progressivement si votre logique fonctionne.

Repérez les éléments importants dans un code existant

Un code existant est la base de projet à partir de laquelle vous démarrez. Il contient déjà des fichiers, une organisation et parfois une partie de la logique nécessaire. Dans un contexte professionnel, vous écrirez rarement un programme à partir d’une page blanche : il y a presque toujours un existant à comprendre avant de le faire évoluer.

Votre première mission n’est pas de tout modifier. Elle consiste d’abord à comprendre ce qui existe.

Quand vous ouvrez un code existant, commencez par observer sa structure générale. Vous pouvez vous poser les questions suivantes :

• Quels sont les dossiers principaux ?

• Quels fichiers semblent lancer le programme ?

• Quels fichiers contiennent les données ?

• Quels fichiers contiennent la logique principale ?

• Y a-t-il des exemples, des commentaires ou des noms de fichiers qui donnent des indices ?

• Que se passe-t-il quand j’exécute le projet ?

Même sans comprendre chaque ligne, vous pouvez déjà construire une première carte mentale du projet.

Par exemple, dans un projet très simple de gestion de produits, vous pourriez repérer trois éléments principaux :

projet
    données
        liste_des_produits
    logique
        vérifier_le_stock
    programme_principal

Ici, le dossierdonnéescontient les informations utilisées par le programme, comme la liste des produits. Le dossierlogiquecontient les règles appliquées à ces informations, par exemple vérifier si un produit est encore disponible. Leprogramme_principal, lui, sert de point de départ : c’est l’endroit depuis lequel le programme se lance.

Cette structure est volontairement simplifiée, mais elle montre une idée importante : un projet est rarement un seul bloc. Il est organisé en parties qui ont chacune un rôle.

Vous pourrez par exemple expliquer une base de code de cette manière :

“Ce fichier sert à lancer le programme. Celui-ci contient les données utilisées. Cette partie contient la logique qui vérifie ou transforme les informations.”

Vous n’avez pas besoin d’utiliser des formulations compliquées. Ce qui compte, c’est de montrer que vous comprenez le rôle des éléments principaux.

En suivant cette démarche, vous prenez l’habitude d’observer un projet avant de le modifier. La console joue un rôle central dans cette observation : c’est souvent là que le programme vous parle. Vous allez apprendre à la lire juste après.

Observez les sorties d’un programme

Quand un programme s’exécute, il peut produire une sortie visible. Au début de votre apprentissage, cette sortie apparaît souvent dans la console.

La console est l’espace où le programme peut afficher des messages, des résultats ou des erreurs. Elle est très utile pour comprendre ce qui se passe.

Ces messages n’apparaissent pas tout seuls : ils sont ajoutés par la personne qui écrit le programme. On les place à des moments clés pour rendre visible ce que le programme est en train de faire.

Par exemple :

afficher "Chargement des produits..."
afficher "3 produits trouvés"
afficher "Stock insuffisant"

Ces messages permettent de suivre le déroulement du programme. Ils peuvent vous aider à vérifier si une fonctionnalité fonctionne comme prévu.

Imaginons que vous ajoutez une règle simple :

SI stock = 0
    afficher "Produit indisponible"
FIN SI

Si le message apparaît au bon moment, c’est un indice que votre logique fonctionne. S’il n’apparaît pas, vous devrez vérifier votre condition, les données utilisées ou l’endroit où le code est exécuté.

Prenez donc l’habitude de lire attentivement ce que le programme affiche. Les sorties console donnent souvent les premiers indices pour comprendre une réussite, une erreur ou un comportement inattendu. Ces indices vous aident à repérer où le programme ne se comporte pas comme prévu, puis à ajuster votre logique progressivement.

À vous de jouer

Un membre de l’équipe vous transmet cet extrait trouvé dans le dépôt de la mini-application de livraison de repas. Avant d’y toucher, vous devez d’abord le comprendre.

plats = [
    { nom = "Pizza",  prix = 12 },
    { nom = "Salade", prix = 8  },
    { nom = "Burger", prix = 10 }
]

FONCTION afficher_menu(plats)
    afficher "=== Menu du jour ==="
    POUR CHAQUE plat DANS plats
        afficher plat.nom + " - " + plat.prix + " €"
    FIN POUR
FIN FONCTION

afficher_menu(plats)

Votre mission : sans écrire de nouveau code, répondez à ces questions par écrit (feuille, fichier texte, ou commentaires dans votre IDE).

1. Point d’entrée. Quelle ligne déclenche l’exécution du programme ? Quelle donnée utilise-t-elle ?

2. Entrée → Traitement → Sortie. Repérez ces trois étapes dans le starter code, ligne par ligne.

3. Sortie anticipée. Sans « exécuter » le programme, écrivez ce que la console devrait afficher, ligne par ligne.

4. Impact d’une modification. Si on ajoute{ nom = "Tiramisu", prix = 6 }à la fin de la liste, qu’est-ce que la console affichera en plus, et à quel endroit ?

En résumé

• Le back-end correspond à la partie d’un programme qui traite les données, applique des règles et produit des résultats.

• Un langage back-end sert à exprimer une logique que l’ordinateur peut exécuter.

• Un programme peut souvent se comprendre avec le schéma : entrée → traitement → sortie.

• Votre environnement de développement comprend notamment un IDE, un terminal et parfois un gestionnaire de paquets.

• Un code existant est une base de projet à explorer avant de modifier.

• La console permet d’observer les sorties du programme et de repérer des indices utiles pour comprendre ou corriger le code.

Vous savez maintenant à quoi sert un langage back-end et comment aborder votre environnement de travail. Dans le prochain chapitre, vous allez entrer dans la logique même d’un programme : variables, types, conditions, boucles et fonctions.