Forem: Tacite WAKILONGO

🚀 Contribuer en Open Source avec Git & GitHub : Le Guide Ultime du Workflow Pro

Tacite WAKILONGO — Wed, 25 Feb 2026 21:39:48 +0000

🚀 Contribuer en Open Source : Le Guide Ultime du Workflow Pro

Contribuer à un projet open source, ce n’est pas seulement "envoyer du code". C’est intégrer une organisation collaborative mondiale. Pour réussir, il ne faut pas seulement savoir coder, il faut savoir communiquer et respecter des standards.

L’open source ne récompense pas seulement les meilleurs codeurs.
Il récompense les développeurs organisés.
Ceux qui savent collaborer proprement.

Prenons une analogie pour tout comprendre...

🏗️ L'analogie du "Chantier Communautaire"

Imagine un immense projet de construction d'un hôpital public.

Le dépôt (Repository) principal = Le bâtiment officiel en construction.
L’architecte (Mainteneur) = Celui qui valide les plans et la qualité.
Les artisans (Contributeurs) = Toi et des centaines d'autres.
Le cahier des charges (Issues) = La liste des pièces à construire ou des fuites à réparer.
Le permis de construire (Pull Request) = Ta proposition de modification soumise à l'architecte.

1️⃣ Étape 0 : L'étiquette (Ne travaillez pas pour rien !)

Avant de coder, vérifiez le cahier des charges.

Consultez les Issues : Cherchez les labels good first issue (idéal pour débuter).
Communiquez : Laissez un commentaire sur l'issue : "Je souhaite travailler sur ce sujet, pouvez-vous me l'assigner ?".
Proposez : Si vous avez une idée neuve, créez une issue avant de coder pour voir si l'architecte est d'accord.

👉 C’est comme demander si on a besoin d'un électricien avant de commencer à poser des câbles.

2️⃣ Étape 1 : Le Fork (Ta copie privée)

Sur GitHub, cliquez sur le bouton Fork.
Cela crée une copie exacte du projet sur ton propre compte GitHub. Tu es désormais le roi de cette copie, tu peux tout casser sans risquer d'abîmer le projet officiel.

3️⃣ Étape 2 : Le Clone & l'Upstream (Préparer son bureau intelligemment)

Ramène le projet sur ton ordinateur :

git clone <url-de-ton-fork>

⚠️ Ce que beaucoup ne comprennent pas :
Quand tu clones ton fork, Git configure automatiquement un remote appelé : origin.
👉 origin = Ton dépôt GitHub personnel (ton fork). C’est là que tes push iront par défaut.

🔎 L’étape cruciale (souvent oubliée) :
Ajoute une connexion vers le dépôt original (celui de l'owner) pour pouvoir récupérer les mises à jour des autres :

git remote add upstream <url-du-repo-original>

📡 Ce que tu viens de créer :
Si tu tapes git remote -v, tu verras :

origin (https://github.com/ton-compte/nom_du_repo.git) -> Lecture + Écriture.
upstream (https://github.com/owner/nom_du_repo.git) -> Lecture principalement.

🧠 Comprendre avec un schéma :

                 (Repo Officiel)
                    upstream
                        ↑
                        |
   (Ton repo local) ----+----> origin (Ton Fork sur GitHub)

🏗️ Analogie chantier :

origin = Ton entrepôt personnel.
upstream = Le chantier principal.
git remote add upstream = Installer un talkie-walkie pour écouter les annonces du chantier officiel.

🎯 Pourquoi on ajoute upstream ?
Pour rester à jour pendant que tu travailles :

git fetch upstream
git rebase upstream/main

💡 Les équipes avancées préfèrent **rebase* pour garder un historique propre et linéaire.*

4️⃣ Étape 3 : Installation & README

Ne fonce pas dans le code !

Lis le README.md : Il contient l'architecture et les règles de l'architecte.
Installe les outils : npm install.
Vérifie que le projet se lance : Tu dois partir d'une base saine.

5️⃣ Étape 4 : La Branche (La zone d'isolation)

Règle d'or : On ne travaille jamais sur la branche main. Jamais.
Crée une branche avec un nom clair :

git checkout -b feat/ajout-formulaire-client

👉 C’est comme construire une maquette de la pièce dans ton atelier avant de la poser sur le vrai bâtiment.

6️⃣ Étape 5 : Coder & Respecter les standards

Pendant que tu codes, respecte le style du projet (Linting, Prettier).
Les "Conventional Commits" : Pour que l'historique soit propre, utilise des messages clairs :

feat: ... (nouvelle fonctionnalité)
fix: ... (correction de bug)

7️⃣ Étape 6 : La Qualité (Husky & Tests)

Avant de partager ton travail, assure-toi qu'il est parfait.

Lance les tests : npm test.
Nettoie ton code : Supprime les console.log. Si le projet utilise Husky (comme MariaSaaS), ton commit sera bloqué automatiquement si ton code est "sale" (ex: présence de any).

8️⃣ Étape 7 : Synchronisation (Éviter les conflits)

Avant l'envoi, assure-toi d'avoir intégré les derniers changements de l'architecte (voir Étape 2 avec fetch et rebase).

9️⃣ Étape 8 : Le Push & la Pull Request (La proposition officielle)

Ton travail est prêt, synchronisé et tes tests passent. Maintenant, tu envoies ton travail vers ton fork, pas vers le repo officiel :

git push origin feat/ajout-formulaire-client

🧠 Schéma clair du flux réel :

      Tu codes ici
      (Local branch)
             |
             v
     git push origin
             |
             v
     Ton Fork (GitHub)
             |
             v
     Pull Request  ----->  Repo Officiel (Upstream)

🏗️ Analogie chantier :
Le push = tu envoies ta maquette à ton entrepôt (origin).
La Pull Request = tu demandes à l’architecte : “Est-ce que ma pièce peut être intégrée au bâtiment officiel ?”

🎯 La Pull Request (moment stratégique) :
Sur GitHub, clique sur "Compare & Pull Request". Pour être accepté :

✅ Explique clairement le problème et ta solution.
✅ Ajoute des captures d'écran si tu as touché à l'interface.
✅ Mentionne l’issue liée (ex: Closes #12).

🔟 Étape 9 : La Revue de Code (Le dialogue)

L'architecte va lire ton code. Il peut :

Valider : 🎉 Ton code est fusionné !
Demander des modifs : Ne le prends pas personnellement ! Modifie ton code localement, refais un commit et un push, la PR se mettra à jour toute seule.

📌 Résumé pour ton antisèche :

Issue : Choisir sa tâche.
Fork/Clone : Créer son espace + Upstream.
Branch : Isoler son travail.
Code/Test : Produire de la qualité.
Push : Envoyer vers origin.
PR : Proposer à upstream et discuter.

💡 Le mot de la fin

L'Open Source est une école gratuite.
Mais comme toute école, elle récompense ceux qui respectent la méthode.

En suivant ce workflow, tu montres que tu es un développeur :

Professionnel
Fiable
Organisé
Collaboratif

Et ça, c’est ta meilleure carte de visite. 🚀

⚠️ Les mauvaises pratiques qui ruinent une contribution

Voici ce qui fait immédiatement “débutant” :

❌ Travailler directement sur main
❌ Oublier de synchroniser avec upstream
❌ Faire une Pull Request sans description
❌ Envoyer 15 commits “fix”, “update”, “final final v2”
❌ Ne pas tester avant de push
❌ Ignorer les retours du mainteneur
❌ Prendre une review comme une attaque personnelle

👉 L’open source est collaboratif. Pas émotionnel.

🧠 Les bonnes pratiques des développeurs pros

✅ Toujours partir d’une issue claire
✅ Nommer proprement ses branches (feat/, fix/, docs/)
✅ Faire des commits propres (Conventional Commits)
✅ Synchroniser avant de push
✅ Tester avant de proposer
✅ Répondre poliment et rapidement aux reviews
✅ Apprendre des corrections

Un bon contributeur ne cherche pas à prouver qu’il est fort.
Il cherche à améliorer le projet.

🎯 Rappelle-toi ceci

Un recruteur qui regarde ton GitHub ne voit pas seulement ton code.
Il voit :

Ta discipline
Ta capacité à travailler en équipe
Ton respect des standards
Ta maturité technique

L’Open Source n’est pas seulement un terrain d’entraînement.
C’est un simulateur du monde professionnel.

Si tu maîtrises ce workflow :

Tu es prêt pour travailler en équipe.
Tu es prêt pour collaborer à grande échelle.
Tu es prêt pour évoluer.

Et ça… ça vaut plus qu’un simple commit. 💙

Le backend pour débutants

Tacite WAKILONGO — Fri, 13 Feb 2026 15:20:15 +0000

👨‍🍳 Cuisiner ta première API REST : Le Secret de la Sauce Express, Prisma et Postgres

Tacite WAKILONGO ・ Feb 13

👨‍🍳 Cuisiner ta première API REST : Le Secret de la Sauce Express, Prisma et Postgres

Tacite WAKILONGO — Fri, 13 Feb 2026 13:44:47 +0000

Salut à toi, futur(e) pro du Backend ! 🚀

Tu viens de dompter React, tu sais créer des interfaces qui déchirent, mais maintenant, tu te demandes : "Où vont mes données quand je clique sur Envoyer ?". Bienvenue dans les coulisses !

Aujourd'hui, on va construire le moteur d'une application de gestion de présence pour un centre de formation. On va gérer des Programmes (Web Dev, Marketing, etc.), des Coachs et des Apprenants.

💡 L'analogie du Chef Cuistot

Pour comprendre comment fonctionne une API en architecture MVC (Modèle-Vue-Contrôleur), imagine qu'on prépare une Pâte de maïs (Foufou) :

La Base de Données (Le Garde-manger) : C'est là où sont stockés tes sacs de maïs et ton eau.
Le Modèle (La Recette) : C'est le plan qui dit : "Pour faire la pâte, il faut tel ingrédient avec tel type de mesure".
Le Contrôleur (Le Chef) : C'est celui qui mélange, surveille le feu et décide quand c'est prêt. C'est la logique.
Le Routeur (Le Serveur de salle) : Il prend la commande du client ("Je veux un plat de Foufou !") et l'apporte au Chef.
La Vue (Le Plat servi) : En API, on ne sert pas une assiette décorée, mais un fichier JSON (de la donnée pure) que ton React pourra ensuite "dresser" sur l'écran.

🛠️ La Boîte à Outils

Oublie les outils complexes comme Docker pour l'instant, on va tout installer en local pour bien voir ce qui se passe "sous le capot".

Node.js (ton moteur JS).
PostgreSQL : Télécharge-le (via Postgres.app sur Mac ou l'installeur officiel sur Windows/Linux).
Un client API : Postman ou l'extension Thunder Client dans VS Code.

🏗️ Étape 1 : Initialisation du Projet (Préparer la cuisine)

Avant de lancer le feu, on doit préparer notre plan de travail. Ouvre ton terminal et tape ces commandes. C'est ici qu'on définit les règles du jeu :

mkdir gestion-presence-api # Crée le dossier du projet
cd gestion-presence-api    # Entre dans le dossier
npm init -y                # Crée le fichier package.json (Ton carnet de recettes)

# Installation des ingrédients principaux (Dépendances de production)
npm install express @prisma/client bcrypt jsonwebtoken

# Installation des ustensiles (Dépendances de développement)
npm install -D prisma nodemon

🥘 À quoi servent ces ingrédients ?

Si on compare notre API à la préparation d'une Pâte de maïs (Foufou), voici le rôle de chaque outil :

Express.js (Le Réchaud) : C'est ton moteur. Sans lui, rien ne chauffe. Il reçoit les demandes des clients (ex: "Je veux la liste des élèves") et s'assure que la réponse arrive à bon port.
Prisma & @prisma/client (Le Traducteur) : Ta base de données parle le "SQL", mais toi tu parles le "JavaScript". Prisma est le traducteur magique qui te permet de commander tes ingrédients sans apprendre une langue complexe. C'est l'ORM (Object-Relational Mapping).
Bcrypt (Le Pilon de sécurité) : Imagine que tu veuilles cacher une épice secrète. Avec Bcrypt, on "écrase" les mots de passe des coachs pour les transformer en une poudre illisible. Même si quelqu'un regarde dans ton garde-manger, il ne pourra jamais retrouver le mot de passe original. C'est le hachage.
JSON Web Token / JWT (Le Ticket de caisse) : Une fois que le coach est connecté, on lui donne un ticket (le token). À chaque fois qu'il veut "faire l'appel", il montre ce ticket pour prouver qu'il a bien le droit d'être là.
Nodemon (Le Commis de cuisine) : Normalement, à chaque fois que tu changes un ingrédient dans ton code, tu dois éteindre et rallumer le réchaud. Nodemon le fait automatiquement pour toi dès que tu sauvegardes un fichier. Un gain de temps fou !

💡 Astuce de chef : Ouvre ton fichier package.json et ajoute la ligne "type": "module",. Cela permet d'utiliser les commandes import et export exactement comme tu le faisais avec React. On reste en terrain connu !

🗄️ Étape 2 : Le Schéma (Le Plan d'Architecte ou La Recette)

Avant de toucher au code, on doit définir la structure de nos données. C'est ici qu'entre en scène Prisma.

🤔 C'est quoi un ORM ?

Imagine que tu cuisines pour un invité qui ne parle que SQL (le langage des bases de données), alors que toi tu ne parles que JavaScript. L'ORM (Object-Relational Mapping) est ton interprète personnel.
Au lieu d'écrire des requêtes complexes comme SELECT * FROM Student WHERE id = ..., tu vas simplement écrire du JavaScript : prisma.student.findUnique(...). C'est plus propre, plus rapide et plus sûr !

🛡️ Un mot sur la sécurité et la doc

Prisma est puissant, mais comme un couteau de chef, mal utilisé, il peut être dangereux. Une mauvaise configuration peut exposer tes données ou créer des failles (comme les injections SQL).
👉 Ton premier réflexe de pro : Lis la Documentation Officielle de Prisma. C'est ta bible. Prends le temps de comprendre comment les relations fonctionnent pour construire des applications robustes.

🆔 Pourquoi utiliser des CUID au lieu de chiffres (1, 2, 3) ?

Dans notre centre de formation, on utilise des CUID (ex: clh1abc...). Pourquoi ?

Sécurité : Si ton ID est 1, n'importe qui peut deviner que l'étudiant suivant est le 2 et tenter d'accéder à ses infos. Avec un CUID, c'est impossible à deviner.
Évolutivité : C'est beaucoup plus pratique quand on commence à avoir des milliers de données réparties partout.

🏗️ Mise en place

Initialise Prisma dans ton projet :

npx prisma init

Ouvre le fichier prisma/schema.prisma qui vient d'apparaître et remplace tout par notre "recette" :

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

// 🏫 Le programme (Web Dev, Marketing, etc.)
model Program {
  id        String    @id @default(cuid())
  name      String    @unique
  coaches   Coach[]
  students  Student[]
}

// 👨‍🏫 Le Coach (Il gère un programme)
model Coach {
  id        String   @id @default(cuid())
  name      String
  email     String   @unique
  password  String   // Chut ! Ce sera haché !
  program   Program  @relation(fields: [programId], references: [id])
  programId String
}

// 🧑‍🎓 L'Apprenant
model Student {
  id        String   @id @default(cuid())
  name      String
  program   Program  @relation(fields: [programId], references: [id])
  programId String
  attendances Attendance[]
}

// 📝 La feuille d'appel (Présence)
model Attendance {
  id        String   @id @default(cuid())
  date      DateTime @default(now())
  isPresent Boolean  @default(false)
  student   Student  @relation(fields: [studentId], references: [id])
  studentId String
}

🚀 Action !

Crée une base de données vide (appelée presence_db) dans ton logiciel Postgres (ou via pgAdmin).
Dans ton fichier .env, mets à jour l'URL : DATABASE_URL="postgresql://USER:PASSWORD@localhost:5432/presence_db?schema=public". Remplace USER par le nom d'utiliseur que tu as créé avec ta base de données, même choses pour PASSWRD
Envoie ce plan à ta base de données pour créer les tables :

npx prisma migrate dev --name init_db

Cette commande génère aussi le "Prisma Client", l'outil qui te permettra de manipuler ces données en JS !

📂 Étape 3 : L'Architecture MVC (Organises ta cuisine)

Imagine que tu prépares le foufou : si le sac de farine est sous le lit, l'eau dans le garage et le réchaud au salon, tu vas perdre un temps fou et ta cuisine sera un désordre total. C’est ce qu’on appelle le "Code Spaghetti" : un mélange emmêlé où plus personne ne s'y retrouve.

Pour éviter cela, on utilise une Architecture. C'est le plan de rangement de ton logiciel.

🏰 Pourquoi MVC ?

Il existe plusieurs façons d'organiser un projet (on appelle ça des Design Patterns) :

Les Microservices : On sépare chaque fonction dans des mini-serveurs différents (très puissant mais très complexe).
La Clean Architecture : On crée des couches ultra-étanches pour que le code soit indépendant de tout (très rigoureux, mais lourd pour débuter).
Le MVC (Modèle-Vue-Contrôleur) : C'est le standard de l'industrie pour les applications web. C'est l'équilibre parfait entre simplicité et propreté.

Pourquoi on le choisit ? Parce qu'il sépare les responsabilités : celui qui gère les données (le garde-manger) ne doit pas être celui qui décide des chemins (le serveur de salle).

🏗️ Notre structure de fichiers

Crée les dossiers suivants dans ton dossier src/. Voici comment on va répartir les tâches :

lib/ (Le placard à outils) : Contient la configuration de Prisma. C'est ici qu'on prépare notre connexion à la base de données pour qu'elle soit prête à l'emploi.
routes/ (Le Menu/Le Serveur de salle) : C'est ici qu'on définit les URLs (ex: /api/students). Son seul rôle est de prendre la commande du client et de la passer au bon chef.
controllers/ (Le Chef de cuisine) : C'est le cerveau ! C'est ici que réside la logique métier. Le chef reçoit la commande, vérifie les ingrédients dans la base de données, prépare le plat et le renvoie.
middlewares/ (Le Vigile à l'entrée) : Avant d'entrer en cuisine, on vérifie si tu as ton badge (JWT). Si tu n'es pas un coach autorisé, le vigile te bloque ici.
index.js (La Porte principale) : C'est le point d'entrée. C'est lui qui allume le réchaud et lance le serveur.

⚙️ Création du client Prisma (`src/lib/prisma.js`)

Dans notre cuisine, on veut une seule instance de Prisma pour tout le monde (on appelle ça un Singleton). Cela évite de saturer ta base de données avec trop de connexions ouvertes.

Crée le fichier src/lib/prisma.js :

import { PrismaClient } from '@prisma/client';

// On crée l'instance qui nous permettra de parler à la DB
export const prisma = new PrismaClient();

// C'est cet objet "prisma" qu'on importera dans nos contrôleurs 
// pour faire nos opérations CRUD (Create, Read, Update, Delete)

Avec cette structure, ton code est "pro", facile à tester et surtout, facile à maintenir. Si tu as un bug sur une URL, tu sais qu'il faut regarder dans routes/. Si le calcul de présence est faux, tu vas dans controllers/ !

🔐 Étape 4 : L'Authentification (Le Badge d'accès du Coach)

Dans notre centre de formation, n'importe qui ne peut pas entrer en cuisine pour modifier la liste des élèves ou faire l'appel. Seuls les Coachs ont ce droit. Pour cela, on a besoin de deux choses :

Le Hachage : Pour ne jamais stocker les mots de passe en clair (sécurité maximale).
Le JWT (Token) : C'est le fameux "badge" que le coach porte après s'être connecté.

Imagine que le mot de passe du coach soit un piment entier. Si quelqu'un vole ton garde-manger, il voit le piment. Le hachage (Bcrypt), c'est comme passer ce piment au mixeur avec d'autres ingrédients pour en faire une sauce très forte. On peut goûter la sauce pour vérifier que c'est bien le bon piment, mais il est impossible de reconstruire le piment original à partir de la sauce. C'est ça, la magie du hachage !

🧑‍🍳 Le Contrôleur d'Authentification (`src/controllers/authController.js`)

Crée ce fichier. Il va contenir la logique pour Inscrire un coach (Register) et le Connecter (Login).

import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { prisma } from '../lib/prisma.js';

// --- INSCRIPTION D'UN NOUVEAU COACH ---
export const register = async (req, res) => {
  try {
    const { name, email, password, programId } = req.body;

    // 1. On "pilonne" le mot de passe (Hachage)
    // Le chiffre 10 est le "Salt" : plus il est élevé, plus le hachage est solide
    const hashedPassword = await bcrypt.hash(password, 10);

    // 2. On enregistre le coach dans la base de données via Prisma
    const newCoach = await prisma.coach.create({
      data: {
        name,
        email,
        password: hashedPassword, // On stocke la version "sauce", pas le piment !
        programId // Rappelle-toi, c'est un CUID (ex: clh1...)
      }
    });

    // 3. On renvoie le coach créé (sans son mot de passe par sécurité)
    const { password: _, ...coachWithoutPassword } = newCoach;
    res.status(201).json(coachWithoutPassword);

  } catch (error) {
    res.status(400).json({ error: "L'inscription a échoué. L'email est peut-être déjà utilisé." });
  }
};

// --- CONNEXION DU COACH (LOGIN) ---
export const login = async (req, res) => {
  try {
    const { email, password } = req.body;

    // 1. On cherche le coach dans le garde-manger (DB) par son email
    const coach = await prisma.coach.findUnique({ where: { email } });

    if (!coach) {
      return res.status(401).json({ error: "Email ou mot de passe incorrect." });
    }

    // 2. On compare le mot de passe reçu avec la sauce (hash) stockée
    const isPasswordValid = await bcrypt.compare(password, coach.password);

    if (!isPasswordValid) {
      return res.status(401).json({ error: "Email ou mot de passe incorrect." });
    }

    // 3. Si tout est bon, on fabrique le "Badge d'accès" (JWT)
    // Ce badge contient l'ID du coach et expire après 24h
    const token = jwt.sign(
      { coachId: coach.id }, 
      'VOTRE_CLE_SECRETE_SUPER_SECURISEE', // À mettre dans ton .env plus tard !
      { expiresIn: '24h' }
    );

    res.json({
      message: "Connexion réussie ! Voici votre badge.",
      token: token,
      coach: { id: coach.id, name: coach.name }
    });

  } catch (error) {
    res.status(500).json({ error: "Erreur lors de la connexion." });
  }
};

🧐 Ce qu'il faut retenir pour ta carrière :

Ne jamais stocker en clair : Si tu vois password: "123456" dans une base de données, c'est une faute grave. Utilise toujours Bcrypt.
JWT est comme un ticket de cinéma : Une fois que tu l'as, tu n'as plus besoin de redonner tes identifiants à chaque porte (route). Tu montres juste ton ticket.
Gestion des erreurs : Remarque comment on utilise try { ... } catch { ... }. En Backend, il faut toujours prévoir que la base de données puisse être indisponible ou qu'un email existe déjà. C'est ce qui différencie un développeur junior d'un pro !

📝 Étape 5 : Le CRUD des Apprenants (Gérer tes ingrédients)

Le mot CRUD est le pain quotidien du développeur Backend. C'est un acronyme qui résume les 4 actions de base que tu peux faire sur n'importe quelle donnée dans ton garde-manger (Base de données) :

Create (Créer) : Ajouter un nouvel apprenant.
Read (Lire) : Afficher la liste ou les détails.
Update (Modifier) : Changer le nom d'un apprenant.
Delete (Supprimer) : Retirer un apprenant du centre.

🧑‍🍳 Le Chef en action (`src/controllers/studentController.js`)

Dans notre architecture MVC, ce fichier est le Contrôleur. Il reçoit la commande, demande à Prisma (le commis) de chercher ou modifier les ingrédients, et renvoie le résultat au client.

import { prisma } from '../lib/prisma.js';

/**
 * LIRE (Read) : Récupérer tous les apprenants
 * C'est comme sortir tous les sacs de maïs pour vérifier le stock.
 */
export const getStudents = async (req, res) => {
  try {
    // On demande à Prisma de trouver tous les étudiants
    const students = await prisma.student.findMany({
      include: { 
        program: true // "Jointure" : On récupère aussi les détails du programme (Web Dev, etc.)
      }
    });

    // On renvoie la liste en format JSON (Le plat est servi !)
    res.json(students);
  } catch (error) {
    res.status(500).json({ error: "Impossible de récupérer les apprenants." });
  }
};

/**
 * CRÉER (Create) : Ajouter un nouvel apprenant
 * C'est comme ajouter un nouveau sac de semoule dans le placard.
 */
export const createStudent = async (req, res) => {
  try {
    // On récupère les données envoyées depuis le front-end (React)
    const { name, programId } = req.body;

    // On utilise Prisma pour créer l'entrée dans PostgreSQL
    const newStudent = await prisma.student.create({
      data: { 
        name, 
        programId // On lie l'apprenant à un programme via son CUID
      }
    });

    // 201 : Code HTTP qui signifie "Créé avec succès !"
    res.status(201).json(newStudent);
  } catch (error) {
    res.status(400).json({ error: "Erreur lors de la création. Vérifie l'ID du programme." });
  }
};

/**
 * MODIFIER (Update) : Mettre à jour les infos
 * Si on s'est trompé sur le nom de l'apprenant.
 */
export const updateStudent = async (req, res) => {
  try {
    const { id } = req.params; // On récupère l'ID dans l'URL
    const { name } = req.body;

    const updatedStudent = await prisma.student.update({
      where: { id }, // On cherche l'apprenant par son CUID unique
      data: { name }
    });

    res.json(updatedStudent);
  } catch (error) {
    res.status(404).json({ error: "Apprenant non trouvé." });
  }
};

/**
 * SUPPRIMER (Delete) : Retirer un apprenant
 * On vide l'assiette !
 */
export const deleteStudent = async (req, res) => {
  try {
    const { id } = req.params;

    await prisma.student.delete({
      where: { id }
    });

    res.json({ message: "Apprenant supprimé avec succès." });
  } catch (error) {
    res.status(404).json({ error: "Impossible de supprimer. L'apprenant n'existe pas." });
  }
};

🔥 Pourquoi c'est important d'être explicite ici ?

Le try...catch : En cuisine, on peut renverser de l'eau. En code, une base de données peut planter. Le try...catch permet de "rattraper" l'erreur proprement au lieu de faire crash tout le restaurant (ton serveur).
Les codes de statut (res.status) :
- 200 : OK (Tout va bien).
- 201 : Created (Nouveau plat créé).
- 400 : Bad Request (Tu as oublié un ingrédient dans ta demande).
- 404 : Not Found (Le plat ou l'étudiant n'existe pas).
- 500 : Server Error (Le réchaud a explosé).
L'inclusion (include) : C'est la force de Prisma. En une seule ligne, tu lies l'Apprenant à son Programme. En SQL pur, cela aurait nécessité une commande "JOIN" beaucoup plus complexe.

Félicitations ! Tu as maintenant un système complet pour gérer tes apprenants. Dans la prochaine étape, on va voir comment le Coach peut utiliser ces fonctions pour "faire l'appel". 🚀

📢 Étape 6 : "Faire l'appel" (La fonctionnalité spéciale)

Où met-on ce code ?
Puisque cette action concerne la présence, nous allons créer un nouveau fichier : src/controllers/attendanceController.js.

Pourquoi un nouveau fichier ?
Dans une bonne architecture MVC, on essaie de séparer les responsabilités. Un contrôleur pour les étudiants, un pour les coachs, et un pour les feuilles de présence. C'est plus propre !

📝 Le code commenté (`src/controllers/attendanceController.js`) :

import { prisma } from '../lib/prisma.js';

/**
 * Faire l'appel : Enregistrer si un étudiant est présent ou absent.
 * Analogie : C'est comme si le Chef cochait une liste pour savoir 
 * quel ingrédient a été utilisé aujourd'hui.
 */
export const takeAttendance = async (req, res) => {
  try {
    // 1. On récupère les infos envoyées par le front (ID de l'étudiant et son état)
    const { studentId, isPresent } = req.body;

    // 2. On utilise Prisma pour créer une nouvelle ligne dans la table Attendance
    const attendance = await prisma.attendance.create({
      data: {
        studentId, // Le CUID de l'étudiant (ex: "clh1...")
        isPresent  // true pour présent, false pour absent (un Boolean)
      }
    });

    // 3. On confirme que tout s'est bien passé
    res.json({ 
      message: "Présence enregistrée avec succès !", 
      attendance 
    });
  } catch (error) {
    // Si l'étudiant n'existe pas ou s'il y a un bug serveur
    res.status(500).json({ error: "Impossible d'enregistrer la présence." });
  }
};

🚦 Étape 7 : Les Routes (Le Serveur de salle)

Imagine que ton API est un grand restaurant.

Le Contrôleur, c'est le Chef en cuisine. Il sait comment préparer le plat.
La Route, c'est le Serveur qui prend la commande. Il se tient à l'entrée et dit : "Si vous demandez le menu Étudiants, je vais voir le Chef des étudiants. Si vous demandez la Feuille d'appel, je vais voir le Chef de la présence."

Sans les routes, personne ne peut communiquer avec tes chefs !

🛤️ Configuration des routes (`src/routes/studentRoutes.js`) :

C'est ici qu'on associe une URL et une Méthode HTTP (GET, POST, etc.) à une fonction de notre contrôleur.

import express from 'express';
// On importe les fonctions (logique) depuis le contrôleur
import { getStudents, createStudent, updateStudent, deleteStudent } from '../controllers/studentController.js';

const router = express.Router();

/**
 * Le Routeur est comme un aiguillage de train.
 * Il regarde l'URL et la méthode, puis envoie la requête au bon endroit.
 */

// Si on reçoit une requête GET sur "/" (qui sera http://localhost:3000/api/students)
router.get('/', getStudents);  

// Si on reçoit une requête POST sur "/" pour créer un étudiant
router.post('/', createStudent); 

// Si on reçoit une requête PUT avec un ID (ex: /api/students/clh1...) pour modifier
router.put('/:id', updateStudent);

// Si on reçoit une requête DELETE avec un ID pour supprimer
router.delete('/:id', deleteStudent);

export default router;

🏗️ Le point final : Assembler tout dans `src/index.js`

C'est le fichier principal. C'est ici qu'on dit à notre application Express d'utiliser les routes que nous venons de créer.

import express from 'express';
import studentRoutes from './routes/studentRoutes.js';
// (Imagine qu'on a aussi créé attendanceRoutes.js sur le même modèle)
import attendanceRoutes from './routes/attendanceRoutes.js';

const app = express();

// Middleware pour permettre à Express de lire le JSON envoyé par React (très important !)
app.use(express.json());

/**
 * On "monte" nos routes sur des préfixes.
 * Toutes les routes d'étudiants commenceront par /api/students
 */
app.use('/api/students', studentRoutes);

/**
 * Toutes les routes de présence commenceront par /api/attendance
 */
app.use('/api/attendance', attendanceRoutes);

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`🚀 Le restaurant est ouvert sur http://localhost:${PORT}`);
  console.log(`📡 Prêt à recevoir les commandes !`);
});

🔥 Résumé pour bien comprendre :

Le Client (React) envoie une requête : POST http://localhost:3000/api/students.
index.js voit passer la requête, reconnaît le préfixe /api/students et l'envoie vers studentRoutes.js.
studentRoutes.js voit que c'est une méthode POST et appelle la fonction createStudent dans le Contrôleur.
studentController.js prend les données, demande à Prisma de les enregistrer dans PostgreSQL.
Prisma répond "C'est fait !", et le Contrôleur renvoie un message de succès (JSON) au client.

La boucle est bouclée ! Tu as maintenant une architecture professionnelle, organisée et prête à évoluer. 🏆

🏆 Pourquoi cette approche est-elle "Pro" ?

En terminant ce projet, tu n'as pas juste écrit du code, tu as construit une véritable infrastructure logicielle. Voici pourquoi ton travail est de qualité professionnelle :

L'Identifiant CUID : Tes IDs ne sont plus de simples chiffres prévisibles (1, 2, 3), mais des chaînes uniques et sécurisées (ckjvw12340000...). C'est la norme pour éviter les fuites de données.
L'Architecture MVC : Ta "cuisine" est parfaitement rangée.
- Un bug sur une URL ? Direction routes/.
- Une erreur de calcul ou de logique ? Direction controllers/.
- Un problème de structure de données ? Direction le Modèle (schema.prisma).
Sécurité Maximale : Grâce au hachage avec Bcrypt, même si un petit malin accède à ta base de données, il ne verra jamais les mots de passe des coachs, seulement une suite de caractères indéchiffrables.

📂 Rappel de ton architecture (Ton plan de travail)

Pour que tout fonctionne, ton dossier src/ doit ressembler à ça :

lib/prisma.js : Ta connexion unique à la base de données.
controllers/ : Tes "Chefs" (auth, students, attendance).
routes/ : Tes "Serveurs" qui dirigent les requêtes.
index.js : Ton "Réchaud" qui lance tout le système.

🧪 À toi de jouer : Le test final avec Postman !

Une API sans test, c'est comme un plat qu'on ne goûte pas avant de servir.

Lance le feu : npx nodemon src/index.js.
Prépare le terrain : Crée d'abord un Programme (ex: "Développement Web") via une requête POST sur /api/programs (si tu as créé la route).
Inscris le Coach : Fais un POST sur /api/auth/register avec l'ID du programme.
Ajoute les Apprenants : Utilise l'ID du programme pour créer tes étudiants.
Fais l'appel : Utilise le contrôleur takeAttendance pour marquer qui est là !

📚 Pour approfondir (Tes sources de savoir)

Ne t'arrête pas en si bon chemin ! Pour devenir un véritable expert, dévore ces ressources :

Documentation Officielle de Prisma : Indispensable pour maîtriser les relations complexes.
MDN Web Docs - Express : La base pour comprendre le fonctionnement des serveurs.
FreeCodeCamp (Backend Development) : Des exercices interactifs gratuits.
Grafikart.fr : D'excellents tutoriels vidéo en français sur Node.js et les ORM.

🚀 Prochaines étapes & Communauté

Maintenant que tu as une API solide, les possibilités sont infinies :

Validation : Utilise une bibliothèque comme Zod ou Joi pour vérifier que les données reçues sont correctes avant de les envoyer à Prisma.
Frontend : Connecte ton application React à cette API en utilisant fetch ou Axios.
Déploiement : Apprends à mettre ta base de données en ligne (sur Supabase ou Render).

Une question ? Un bug ? Une suggestion ?
N'hésite pas à proposer des améliorations ou des correctifs dans les commentaires ! Si ce format vous plaît, je pourrais en faire une version vidéo pour détailler chaque ligne de code en direct.

Dis-moi aussi en commentaire : Quel sujet aimerais-tu que j'aborde dans le prochain article ? (La validation de données ? Le déploiement ? L'upload d'images ?).

Bravo encore, tu viens de passer du côté puissant de la force : le Backend. 🚀🍲

SUR LE CHEMIN DU HACKING ! Kali Academy, trois mois d’initiation 👺

Tacite WAKILONGO — Fri, 14 Jun 2024 22:20:06 +0000

Et oui 🙂 vous ne rêvez pas ! Je dis dis bien hacking ! Avant tout, mettons-nous d'accord sur la terminologie “Hacking”. Les médias nous ont menti sur le hacking, ils confondent le hacking au cracking. Richard Stallman, un fervent défenseur du logiciel libre et fondateur du mouvement du logiciel libre, définit un hacker comme quelqu'un qui aime jouer avec des systèmes, comprendre leur fonctionnement interne et les améliorer. Le hacking, dans ce contexte, est un acte de créativité, d'innovation et de résolution de problèmes, souvent associé à la programmation informatique. C’est une part de vérité, le hacking est bien plus que cette définition, il est en soi un état d’esprit, une manière de penser… Je vous conseille de lire cet ouvrage pour en savoir plus sur cette littérature : “Hackers and Painters: Big Ideas from the Computer Age” de Paul Graham.

Introduction

Dans cet article, je vais vous parler du parcours que propose Kali Academy aux jeunes développeurs pour les initier au Hacking. Kali Academy est une académie qui vise à promouvoir les valeurs de l'open source dans les régions les moins représentées notamment en Afrique, voir le site de Kali Academy. J’ai personnellement été parmi les 10 stagiaires retenus pour la cohorte 2024 et c’est fut une énorme opportunité pour ma carrière de développeur, je me sens dans l’obligation de partager avec cette expérience assez passionnante. Avant d’entrer dans le vif du sujet, je tiens a préciser que je ne me considère pas hacker, et je ne me considérerai jamais hacker, c’est la pertinence de mon travail qui pourra me procurer ce titre.

Le parcours de stage chez Kali Academy est subdivisé en 3 parties :

les fondamentaux
la spécialisation Wikimédia et
le projet de fin de stage.

Mais avant de décortiquer ce programme apparemment, commençons par nous poser les bonnes questions en guise de fondamentaux 🙂. Qui construit et entretient l'infrastructure numérique sur laquelle nous nous appuyons au quotidien ? Quels sont les défis et les obstacles rencontrés par ceux qui travaillent à la construction et à la maintenance de cette infrastructure ? Quelles sont les implications sociales, politiques et économiques de la manière dont l'infrastructure numérique est construite et gérée ? Comment les décisions prises en matière d'infrastructure numérique affectent-elles la vie quotidienne des gens ? Quels sont les modèles de financement et de gouvernance de l'infrastructure numérique, et comment peuvent-ils être améliorés ? Comment pouvons-nous garantir que l'infrastructure numérique reste ouverte, accessible et équitable pour tous ? Ces questions semblent peut-être basiques, mais elles poussent à une très grande réflexion si on y consacre un peu d'attention.

Sur quoi est basé notre infrastructure numérique ?

Selon Nadia Eghba, dans son livre (essaie) "Roads and Bridges: The Unseen Labor Behind Our Digital Infrastructure", il nous rappelle que toute notre infrastructure numérique est basée sur l’open source. Personnellement, lorsque j’ai lu ce passage, la première question je me suis demandé qui est derrière les projets open source, comment gagne-t-il sa vie…. C’est à ce moment que j'ai compris l’importance d’une contribution, même aussi petite soit-elle. Nous posons des questions sur des forums tels que stack overflow, mais est-ce qu’on se demande qui nous répond, ni même pourquoi il nous répond ? Nous lisons des articles sur ce site, et nous savons que leurs auteurs ne perçoivent rien comme droit d’auteur mais nous écrivent quand-même. C’est avec ces genres des questions qu’on devient hacker. Etes-vous toujours prêt à le devenir ? Si oui, demandes-toi quelle est ta part dans tout ça, combien de fois as-tu contribué dans un projet open source ou même partager publiquement et gratuitement tes connaissances ? L’open source ce n’est pas seulement dans l’informatique, la liberté d'être bien informé ne peut être garantie que si l’information est open source (souvenez-vous de l’affaire Wikileaks ayant conduit à l’arrestation de Julian Assange et Chelsea Manning), la connaissance ne peut-être universelle que si elle a été partagée (les brevets publiques) ! Voyons notre part dans tout ça, bien que minime soit-elle mais elle est là. C’est de cette manière que Kali Academy m’a amené à voir les choses, consacrer un peu de mon temps à faire découvrir aux autres ce que nous avons appris dans le but de faire évoluer la connaissance et de la démocratiser 🗽.

GNU/Linux, l'OS des Hackers

Maintenant que nous avons découvert que toute notre infrastructure numérique est grandement basée sur de l’open source, rentrons dans le technique. GNU/Linux, savez-vous de quel animal s’agit-il ? 😂 On a souvent tendance à ne dire que Linux et laisser GNU, pourtant Linux n’est que le noyau. GNU est un projet de logiciel libre lancé par Richard Stallman en 1983. Le nom "GNU" est un acronyme récursif qui signifie "GNU's Not Unix", ce qui souligne que bien que GNU soit compatible avec Unix, il n'est pas dérivé de celui-ci. Le projet GNU a pour objectif de fournir un système d'exploitation libre, complet et cohérent composé entièrement de logiciels libres. GNU/Linux est le résultat de l'effort combiné de deux projets : le projet GNU, qui a fourni les outils et les utilitaires, et le noyau Linux, développé par Linus Torvalds. Cette collaboration a produit un système d'exploitation puissant, flexible et libre, qui a eu un impact significatif sur l'industrie informatique et la culture technologique mondiale. Dans mon parcours à Kali Academy, j’ai découvert qu’il est important pour un hackeur d’avoir une idée sur l'architecture d’un système d’exploitation, surtout GNU/Linux car il est open source, on peut se challenger à toucher dans son code et produire notre propre distribution, ce qui est du hacking au sens pur 🙂, ensuite il faut savoir l’installer sans assistance, manipuler bien la ligne de commande, construire des petits scripts bash, automatiser certaines tâches, manipuler l’environnement bureau…

Git, la collaboration facilitée

Ensuite, il faut savoir très bien manipuler git, car c’est la base de la collaboration dans une équipe de développeurs, j’ai récemment commencé à publier une série d’article à sujet je vous invite à aller y jeter un coup d'œil. La plupart des plateformes collaboratives sont basées sur git. Git a pas mal évolué mais il reste intuitif de l’utiliser en CLI.

les licences opens sources, le droit en ingénierie

Lorsque vous installez un logiciel open ou non, vous devez d'abord avoir accepter les termes de la licence. C’est un cas que vous avez déjà rencontré au moins une fois, mais si on n’est pas suffisamment informé, on néglige cette partie, ce qui nous amène à violer les licences. Pour moi, la plus grande victime c’est Microsoft, en tout cas dans le contexte de ma région, sur 1000 personnes que je connais, 900 utilisent Windows, et seulement 100 ont une licence, 50 l’ont payé et les autres ont des craques 😂. C'est triste, mais c’est ça la réalité, pourtant il y a un GNU/Linux gratuit et open source, le seul motif qu’on c’est que Linux est complexe, c’est qui une pure invention de ses concurrents. Cette situation a conduit Kali Academy à nous initier à la lecture des licences open source. Cette lecture nous a mis dans un grande confusion: un logiciel peut être open source mais pas libre, gratuit mais pas libre, libre mais avec une version payante, gratuit mais pas open source 😴. C’est embêtant non ! Mais ce qu’il faut retenir, c’est qu’une licence d'un logiciel est un contrat entre l'éditeur du logiciel et l'utilisateur qui définit les conditions d'utilisation du logiciel. Cette licence précise notamment si l'utilisateur est autorisé à installer le logiciel sur un ou plusieurs appareils, s'il peut le partager avec d'autres personnes, s'il peut le modifier, etc. En échange du respect de ces conditions, l'utilisateur est autorisé à utiliser le logiciel de manière légale.

Voyons maintenant la différence entre un logiciel Open source et un logiciel libre.
Les critères d'un logiciel libre, selon la Free Software Foundation (FSF, initiée par Richard Stallman) , sont les quatre libertés :

Liberté d'exécution : Exemple de Licence : GNU General Public License (GPL) La GPL permet aux utilisateurs d'exécuter le programme pour n'importe quel usage.
Liberté d'étude : Exemple de Licence : GNU General Public License (GPL) La GPL garantit l'accès au code source, permettant aux utilisateurs d'étudier et de modifier le programme.
Liberté de redistribution : Exemple de Licence : GNU General Public License (GPL) La GPL permet aux utilisateurs de redistribuer des copies du programme, que ce soit en version originale ou modifiée.
Liberté de distribution des versions modifiées : Exemple de Licence : GNU General Public License (GPL) La GPL permet aux utilisateurs de distribuer des copies de leurs versions modifiées, tout en conservant les mêmes libertés pour les autres utilisateurs. Les critères d'un logiciel open source, selon l'Open Source Initiative (OSI), incluent les éléments suivants :
Libre redistribution : Exemple de Licence : MIT License La MIT License permet la distribution du logiciel sans restriction.
Code source : Exemple de Licence : Apache License 2.0 La licence Apache 2.0 exige que le code source soit disponible.
Travaux dérivés : Exemple de Licence : BSD License La BSD License permet la modification et la distribution de travaux dérivés sous les mêmes conditions.
Intégrité du code source de l'auteur : Exemple de Licence : Mozilla Public License 2.0 La MPL 2.0 permet les modifications tout en exigeant que les fichiers modifiés soient redistribués sous la même licence.
Pas de discrimination contre des personnes ou des groupes : Exemple de Licence : MIT License La MIT License ne discrimine personne.
Pas de discrimination contre des domaines d'application : Exemple de Licence : Apache License 2.0 La licence Apache 2.0 ne limite pas l'utilisation du logiciel à certains domaines.
Distribution de la licence : Exemple de Licence : GNU General Public License (GPL) La GPL assure que les droits sont transférés à tous les destinataires du programme.
Licence non spécifique à un produit : Exemple de Licence : BSD License La BSD License n'exige pas que le programme soit partie intégrante d'un produit spécifique.
Licence non restrictive pour d'autres logiciels : Exemple de Licence : Apache License 2.0 La licence Apache 2.0 ne pose pas de restrictions sur les logiciels distribués avec le programme.
Licence technologiquement neutre : Exemple de Licence : MIT License La MIT License ne fait pas référence à une technologie spécifique.

Mais ce qu’il faut retenir c’est que tout logiciel libre est open source mais tout logiciel open source n’est pas libre, il y a aussi des gratuiciels (logiciel gratuit mais pas open source). Je vous recommande de mettre, en commentaire, des exemples d'applications ayant telle ou telle autre licence précitée.

Wikimédia, écosystème open source par excellence

C’est dans cela que nous avons passé la majeure partie du premier mois, on avait autant d’ouvrages à consulter, des documentations à parcourir et des ateliers à suivre et parfois partager quand bien même on n’a pas bien assimilé la leçon, bref c'était très intense. Ces connaissances acquises ne pouvaient nous aider en rien si on n’avait pas une bonne communauté où les expérimenter. Il est bien d’avoir une houe, mais il encore mieux de l’essayer au champ 🙂, c’est pourquoi dans le deuxième moi de mon stage chez Kali Academy, nous nous sommes maintenant intéressés aux projets open source, nous avons d’abord cherché de nous même, je me souviens j’avais forké un repo de “awesome” où j’ai eu trop de mal à contribuer et mon PR n’avait même pas été validé, mais mon coach m’a consolé en disant “le plus important c’est que tu as réussi à cloner le projet, à runer le projet et à résoudre l’issue, peut importe que ton PR soit mergé ou pas”, et c'est une des leçons que je garde à cœur. Ensuite, Kali nous a proposé d’approcher l’écosystème Wikimédia qui est de nos jours un des plus grands projets open sources avec son MediaWiki qui est le moteur qui propulse Wikipédia et son projet frères ainsi que d’autres wiki. C’était comme une forte immersion arrivée soudainement. Nous avions d’abord participé à un événement de code que Wikimédia a choisi de nommer “Wishathon”, au cours duquel il fallait corriger quelques bogues et résoudre certains issues dans les projets ciblés dans l’écosystème, c’était très intenses pour nous étant donné que c’était une première fois de nous retrouver dans ces genres d’événement, encore que c’était un événement mondial, je m'étais retrouvé en train de travailler avec un turc aussi débutant que moi en Anglais 😂, mais c’était wow. Ensuite, pour comprendre un peu comment faire mes premières contributions sur Wikipédia, Wikidata, wiki Common …. j’ai postulé à une bourse de la fondation Moleskine laquelle m’a permis de suivre tout cela en seulement 5 séances intenses. J’ai appris à installer MediaWiki de différentes façons, à créer des thèmes, des extensions …. C’était vraiment chouette cette aventure. Ouf ! 😣J’ai oublié de vous révéler une petite confidence, au cours du Wishathon j’ai reçu un gift venu expressément des USA, c’était un moment très émouvant !

Initier un projet open source

Normalement l’initiation à l’open source devrait s’achever là, mais Kali Academy a souhaité que nous puissions initier aussi des projets open source sur lesquels d’autres personnes vont aussi contribuer. Dans ce cadre, j’ai été mis dans une équipe où on était à trois, moi, mon ami que j’appelle toujours beau frère Firmin NGANDULI et le petit Christian BIREGO, un très bon geek. Ensemble, on a travaillé sur une application nommée LeaderBoard qui compare les contributions des bénévoles sur les projets Wikimédia et les classes en fonction du nombre des contributions. Voici le lien de l’application déployée ici et de la documentation ici… Si vous êtes intéressé par ce projet, dites-le moi aussi en commentaire.

En bref, c’est à ça qu'à ressemblé mon parcours de stage chez Kali Academy, c'était une expérience extrêmement passionnante, j’ai goûté un peu au code professionnel, à l’expertise des grands développeurs open source de Wikimédia… Je remercie Kali Academy pour m’avoir offert cette opportunité, malgré mon niveau et mes faiblesses, je remercie également tous mes collègues avec lesquels on a fait ce parcours ainsi que vous tous qui avez lu cet article jusqu’ici, je vous prie de me faire des corrections en privé s’il en y a 🙂. Ainsi commence mon parcours d’apprenti hacker, à nous revoir dans le future 🙂, étant déjà hackeur 😂

Git & GitHub, de l'historique aux dépôts distants

Tacite WAKILONGO — Tue, 11 Jun 2024 20:21:26 +0000

Vous voulez gérer les versions de votre code et les conserver en un endroit sûr sur internet ? Vous voulez vous faciliter la collaboration avec votre équipe dans un projet de logiciel ? Voulez-vous montrer au monde entier comment vous êtes devenu un grand codeur ? Et oui 🙂, vous êtes au bon endroit ! Dans cette suite d’articles, nous allons découvrir ensemble c’est quoi “GitHub” et nous allons apprendre à le démystifier! Allons y c'est parti!

Tout d’abord, Git, GitHub, GitLab ? c’est quoi ces gros mots ? D’où viennent-ils ? Ont-ils été créés pour vous impressionner et vous foutre hors du code ? Pas vraiment, au contraire ce sont vos grands compagnons dans votre aventure de développeur. Pour bien le comprendre, faisons un petit tour dans le passé.

Dès les années 97, nos vaillants premiers développeurs utilisaient BitKeeper pour la gestion de versions. BitKeeper est un système de gestion de versions distribué, développé par BitMover Inc, fondée par Larry McVoy. Ce dernier est un ancien ingénieur de Sun Microsystems, il a conçu BitKeeper pour répondre aux besoins complexes de gestion de versions de grands projets logiciels. Notre génie Larry introduit plusieurs nouveautés qui vont faire le grand bonheur des développeurs de l’époque, notamment la gestion des versions distribuées qui permet à chaque développeur de travailler avec une copie complète de l'historique du projet; la fusion avancée, BitKeeper a développé des algorithmes sophistiqués pour la fusion de branches, ce qui facilite le travail parallèle des développeurs; la performance et la scalabilité, c’est chouette non 😀? Même si pour l'instant, ça parait encore une langue non comprise pour vous, lisez quand même, j'aurais aimé avoir toutes ces informations avant de me lancer sur git !

En 2002, la communauté du noyau Linux adopte BitKeeper pour gérer le développement du noyau. Wow, c’est l'âge d’or de BitKeeper, il est utilisé par un des plus grands projets open-source au monde de l’époque, pour les développeurs, tout cela est oufs car BitKeeper offrait une version gratuite pour les développeurs open-source, mais avec des restrictions 🤗. En 2005, des différends concernant ces restrictions ont conduit BitMover à retirer la version gratuite, Linus Torvalds et sa communauté derrière le noyau Linux décident de créer un nouvel outil pour remplacer BitKeeper, conduisant à la création de Git. Voilà enfin le fameux Git, Torvalds a pris sa revanche avec un produit collaboratif incluant la distribution, la performance et la sécurité utilisant le hachage cryptographique SHA-1. BitKeeper va continuer d’exister comme produit commercial, mais devenus vétuste, en 2016, son équipe de développement va décider de le rendre open Source pour permettre à la jeune génération de l’expérimenter. Tout ceci est bien beau, mais où est GitHub dans tout ça 🤔?

En 2008, 3 ambitieux, Tom Preston-Werner, Chris Wanstrath, PJ Hyett et Scott Chacon, inspirés par la success story de Mark Zuckerberg, s’élancent dans la construction d’un nouveau monde, le FaceBook des développeurs 😀! GitHub est né, accueilli comme le saint grâle ! Le succès est au rendez-vous, GitHub devient très vite la principale plateforme de collaboration et est directement adopté par plusieurs projets open source et devient une plateforme centrale dans l'écosystème du développement logiciel. En 2012, il atteint 1 million de dépôts. Le business s’invite là aussi au rendez-vous: Pour sa stratégie Cloud et Open Source, Microsoft, voulant aussi avoir accès aux 1 million d’utilisateurs GitHub, le 4 juin 2018 annonce acquérir GitHub pour une somme colossale de 7,5 milliards de dollars en actions Microsoft. L'annonce a suscité diverses réactions, certains développeurs étaient sceptiques quant à l'impact de cette acquisition sur la neutralité de GitHub, tandis que d'autres y voyaient une opportunité de bénéficier des ressources et de l'infrastructure de Microsoft. C’est parti nos 3 ambitieux s’en sortent milliardaires au prix de leur rêve de Facebook de développeurs, mais bon 7,5 milliards on n’en a pas tous les jours 😣.

Pour rassurer les développeurs pris au piège entre optimisme et scepticisme, Microsoft a assuré que GitHub continuerait à fonctionner de manière indépendante, avec Nat Friedman (ancien CEO de Xamarin) nommé CEO de GitHub après l'acquisition, sous la propriété de Microsoft, GitHub a continué à soutenir et à promouvoir les projets open source. Microsoft lui-même est devenu un contributeur majeur aux projets open source sur GitHub. Microsoft a investi dans l'infrastructure de GitHub et a introduit de nouvelles fonctionnalités, comme GitHub Actions pour l'intégration continue et le déploiement continu (CI/CD). Les fonctionnalités clés de GitHub sont :

Pull Requests : Facilite les révisions de code et les contributions externes.
Issues : Outil de suivi des bogues et des fonctionnalités.
Actions GitHub : Intégration continue et déploiement continu (CI/CD).
Pages GitHub : Hébergement de sites web statiques directement depuis un dépôt GitHub.

Et GitLab alors ? 🤔 GitLab a été fondé en 2011 par Dmitriy Zaporozhets et Valery Sizov. Initialement un projet open-source, GitLab offre des fonctionnalités similaires à GitHub mais se distingue par ses options de déploiement auto-hébergées. Perçu comme une alternative à GitHub, de nos jours, GitLab est une plateforme complète de DevOps couvrant tout le cycle de vie du développement logiciel, de la gestion du code à la livraison et à la surveillance des applications. Ses principales fonctionnalités sont :

Pipeline CI/CD : Intégration native pour tester et déployer automatiquement le code.
Auto-hébergement : Les entreprises peuvent installer et gérer GitLab sur leurs propres serveurs.
Cycle de vie complet : Supporte la gestion de projet, le contrôle des versions, l'intégration continue, le déploiement et la surveillance.
Sécurité : Fonctionnalités avancées pour la gestion des permissions et la sécurité du code.

Nous avons découvert nos trois termes Git, GitHub et GitLab qui étaient jadis des concepts impénétrables. Nous allons expérimenter dans la deuxième partie de cette série d’articles consacrés à Gît la beauté de tout cela dans la pratique, prenez bien soins de vous, et retrouvons-nous dans la suite 👏

COMMENT RÉSOUDRE L’ERREUR 403 DE GIT ?

Tacite WAKILONGO — Sat, 04 May 2024 10:11:41 +0000

En tant que développeur, vous travaillez sûrement avec github, gitlab, gerrit ou une autre plateforme collaborative similaire pour pouvoir envoyer vos modifications à vos collaborateurs ou pour voir les leurs. Un beau jour, vous décidez de changer de machine pour une raison que toi-même connais! Vous devez tout configurer de nouveau en commençant par votre environnement de développement, et bien sûr git. Mais vous vous rendez compte que malgré vous avez changé les identifiants reliés à git, vous n’avez pas d’autorisation pour vous écouter même à vos propres dépôts distants; lorsque vous creusez un peu, vous trouvez que vous faites face à l'erreur 403 de git ! Qu’est-ce ? Comment le résoudre ? Vous êtes au bon endroit, c’est l’objet de cet article.

C'est quoi l'erreur 403 ?

Pour faire simple, l’erreur 403 dans Git est généralement liée à des problèmes d’autorisation lors de l’accès à un dépôt distant.

Comment le résoudre ?

Sur Windows

Voici quelques étapes pour résoudre cette erreur sous Windows :

Vérifiez vos informations d’identification:

Ouvrez le Gestionnaire d’informations d’identification Windows.
Recherchez les informations d’identification liées à GitHub et supprimez-les si nécessaire.
Vérifiez vos paramètres Git :
Exécutez la commande : git config user.name pour vérifier votre nom d’utilisateur.
Exécutez la commande git config user.email pour vérifier votre adresse e-mail.
Assurez-vous que vos paramètres sont corrects et que les modifications sont bien prises en compte.
Vérifiez le gestionnaire d’informations d’identification :
Exécutez la commande git config credential.helper pour connaître le gestionnaire d’informations d’identification utilisé (par exemple, Windows Credential Managers).
Si vous avez activé la double authentification (2FA) sur GitHub, vous devrez utiliser un jeton d’accès personnel (PAT) au lieu de votre mot de passe.
Vérifiez le fichier de configuration du dépôt :
Modifiez le fichier .git/config dans votre répertoire de travail.
Recherchez l’entrée url=sous la section [remote "origin"]. Changez-la de url=[^3^][8] à url=[^4^][9], en remplaçant _USERNAME_par votre nom d’utilisateur GitHub.

Sur GNU linux

Pour résoudre l’erreur 403 de Git sur Linux, qui est souvent due à un problème d’authentification, voici quelques étapes supplémentaires que vous pouvez suivre :

Vérifiez l’accès au dépôt : Assurez-vous que vous avez le niveau d’accès requis pour effectuer l’opération souhaitée. Si quelqu’un d’autre vous a ajouté au dépôt, vérifiez qu’il vous a accordé les permissions nécessaires.
Supprimez les identifiants enregistrés : Si Git a mémorisé des identifiants incorrects, vous pouvez les supprimer. Sur Linux, cela peut être fait en supprimant les entrées correspondantes dans le fichier ~/.git-credentials ou en utilisant la commande git credential-cache exit si vous utilisez le cache des identifiants.
Utilisez un jeton d’accès personnel (PAT) : Si l’authentification par mot de passe a été désactivée en faveur des PAT, vous devrez en générer un via les paramètres de votre compte sur la plateforme de gestion de version (comme GitHub ou Bitbucket) et l’utiliser à la place du mot de passe.
Changez de méthode d’authentification : Si vous utilisez HTTPS et que vous rencontrez des problèmes, vous pouvez essayer d’utiliser SSH, ou vice versa. Pour SSH, assurez-vous que votre clé publique est ajoutée à votre compte sur la plateforme de gestion de version.
Configurez le proxy : Si vous êtes derrière un proxy, vous devrez peut-être configurer Git pour utiliser ce proxy avec la commande git config --global http.proxy proxy_url.

En suivant ces étapes, vous devriez pouvoir résoudre l’erreur 403 sur votre machine. Si le problème persiste, il peut être utile de consulter la documentation de la plateforme de gestion de version que vous utilisez ou de demander de l’aide à l’administrateur du dépôt. Si vous avez lu jusqu'ici, c'est que l'article vous a été utile, ne manquez pas de faire part de vos impressions en commentaire, cela m'aidera à améliorer.

Comment faire sa première contribution dans le monde de l’Open Source

Tacite WAKILONGO — Mon, 15 Apr 2024 20:27:56 +0000

L’Open Source est un univers fascinant où le partage et la collaboration sont les clés de l’innovation et de l’amélioration continue. Contribuer à l’Open Source peut sembler intimidant au début, mais c’est une expérience enrichissante qui peut vous aider à développer vos compétences, à vous connecter avec d’autres développeurs et à apporter une contribution significative à la communauté. Voici un guide étape par étape pour faire votre première contribution.

Étape 1: Choisissez un Projet qui Vous Passionne

La première étape est de trouver un projet qui vous intéresse. Vous pouvez commencer par explorer des sites comme GitHub, GitLab ou Bitbucket pour découvrir des projets qui correspondent à vos intérêts et à vos compétences.

Étape 2: Comprenez le Projet

Prenez le temps de comprendre le projet. Lisez la documentation, les issues ouvertes, et essayez d’utiliser le logiciel pour vous familiariser avec celui-ci. Cela vous aidera à identifier où vous pourriez apporter votre aide.

Étape 3: Communiquez avec la Communauté

Avant de contribuer, il est important de se connecter avec la communauté. Rejoignez les canaux de communication du projet, tels que les forums, les listes de diffusion ou les chats Slack/Discord. Posez des questions, présentez vous et exprimez votre désir de contribuer.

Étape 4: Trouvez une Tâche

Cherchez des tâches adaptées aux débutants ou des bugs faciles à corriger. Les projets Open Source utilisent souvent des balises comme “good first issue” ou “help wanted” pour indiquer les tâches appropriées pour les nouveaux contributeurs.

Étape 5: Installez l’Environnement de Développement

Configurez votre environnement de développement local en suivant les instructions du projet. Assurez-vous de pouvoir exécuter le projet et de comprendre le processus de build et de test.

Étape 6: Faites Votre Première Contribution

Une fois que vous avez choisi une tâche, créez une fork du projet et commencez à travailler sur votre contribution. Respectez les conventions de codage et les directives de contribution du projet.

Étape 7: Soumettez Votre Contribution

Après avoir terminé votre travail, soumettez une pull request (PR) au projet principal. Décrivez clairement ce que vous avez fait et pourquoi. Attendez les retours des mainteneurs du projet et soyez prêt à faire des modifications si nécessaire.

Étape 8: Apprenez de l’Expérience

Peu importe l’issue de votre PR, prenez le temps de réfléchir à l’expérience. Qu’avez-vous appris ? Comment pouvez-vous améliorer vos futures contributions ? La rétroaction est un cadeau précieux dans l’Open Source.

Conclusion

Faire votre première contribution à l’Open Source est le début d’un voyage d’apprentissage continu. Chaque contribution compte, et avec le temps, vous pourriez même devenir un mainteneur de projet. Alors, lancez-vous et rejoignez la révolution Open Source !
N’oubliez pas, l’Open Source est autant une question de communauté que de code. Votre première contribution est une étape importante pour devenir un membre actif de cette communauté mondiale. Bonne chance !
Vous pouvez aussi lire :

Comment sécuriser son compte Facebook ?

Tacite WAKILONGO — Tue, 02 Apr 2024 11:41:25 +0000

Avec ses 2,91 milliards d'utilisateurs actifs, Facebook est le réseau social le plus utilisé. On estime qu'une personne y passe en moyenne 33 minutes par jour, ce qui génère un trafic mensuel de plus de 4,5 milliards de publications aimées, commentées ou partagées, des revenus publicitaires atteignant plus de 32,6 milliards USD au quatrième trimestre 2022. L'age moyen de ses utilisateurs est de 27 ans dont 56% sont des hommes. Sources : Statista, Hooksuite et Facebook.

Avec un tel succès, les utilisateurs de Facebook ne sont pas à l'abri des pirates informatiques qui, jour et nuit, cherchent à découvrir les nouvelles façons de nuire aux internautes pour des raisons diverses.

Pourquoi sécuriser son compte Facebook ?

La sécurité de votre compte Facebook est essentielle pour plusieurs raisons, il est crucial de la prendre au sérieux. Voici quelques unes des raisons pour lesquelles vous devez sécuriser votre compte Facebook :

Prévenir le piratage : En sécurisant votre compte, vous réduisez les risques de piratage par des individus malveillants.
Protéger vos données personnelles : Votre compte contient des informations sensibles telles que vos photos, messages et coordonnées; sa sécurisation empêche aux individus malveillants d'y accéder sans autorisation.
Préserver votre vie privée : En contrôlant l’accès à votre compte, vous protégez votre vie privée en ligne. Lorsqu'un inconnu accède sans autorisation sur votre compte, votre vie privée est compromise. Il peut voir du contenu que vous n'avez pas rendu public, lire vos messages sensibles...
Maintenir votre réputation : Un compte compromis peut entraîner des publications indésirables ou des activités suspectes, nuisant à votre réputation.
Prévenir l’usurpation d’identité : Les pirates peuvent se faire passer pour vous et causer des problèmes en utilisant votre compte. En utilisant votre compte, on peut accéder à tout les sites et applications liés à votre compte Facebook sans autorisation, ce qui peut vous porter préjudice dans le cas d'une utilisation malveillante.

Pourquoi les pirates chercheraient à contrôler votre compte Facebook ?

Les pirates ont différentes raisons de chercher à prendre le contrôle de votre compte allant de l'espionnage au chantage, ou bien une simple curiosité de se challenger. Voici quelques unes des motivations qui pourraient inciter à pirater votre compte :

Vol d’informations personnelles : Ils cherchent à accéder à vos données confidentielles. Lorsque vous souscrivez aux services publicitaires de Méta par exemple, vous liez en même temps votre mode de paiement en ligne à votre compte Facebook, et donc ayant accès à votre compte on peut effectuer des achats en votre nom.
Accès à vos amis et à votre famille : Contrôler votre compte leur permet d’interagir avec vos proches. Ils peuvent ainsi se passer pour vous auprès de vos proches.
Espionnage (Stalking) : Les stalkers utilisent des comptes piratés pour surveiller les utilisateurs. Ainsi des comptes des journalistes, des défenseurs des droits humains et des opposants politiques sont régulièrement victimes de ces genres de piratages.
Motivation financière : Les cybercriminels exploitent vos informations pour des gains financiers. Sur certains sites du darknet, on peut trouver des comptes Facebook piratés en vente; d'autres part, des comptes bénéficiant d'une grande communauté très interactive, donc qui génèrent des revenus peuvent aussi être ciblés.
Chantage : Ils menacent de divulguer vos données sensibles à vos amis. Les personnalités publiques, religieuses, les journalistes et même vous, vous tenez beaucoup à votre réputation et à votre honneur. Ainsi, les pirates ayant accès à votre compte peuvent menacer de publier vos informations sensibles qui pourraient compromettre votre crédibilité.
Récupération de comptes professionnels : Les entreprises et influenceurs sont ciblés pour une rançon.

Comment les pirates prennent le contrôle de votre compte ?

Voici quelques techniques couramment utilisées par les pirates :

Hameçonnage (Phishing) : Ils envoient des messages frauduleux pour vous inciter à divulguer vos informations de connexion. Pour ça ils se font passer pour vos proches dont, dans la plus part de cas, ils ont aussi pirater le compte. Ils peuvent aussi vous envoyer des messages renfermant des liens malveillants se faisant passer pour Méta.
Vol de mots de passe : Les mots de passe faibles ou réutilisés sont ciblés.
Logiciels malveillants : Ils vous incitent à télécharger des logiciels qui volent vos informations.
Récupération via les amis : Ils se font passer pour des proches et demandent de l’aide pour récupérer un compte.
Vulnérabilités de sécurité : Si Facebook présente des failles, les pirates les exploitent.

Bonnes pratiques pour protéger votre compte

Utilisez un mot de passe fort et unique pour votre compte Facebook.
Activez l’authentification à deux facteurs pour une sécurité accrue.
Méfiez-vous des liens suspects et ne partagez pas vos informations avec des sources non fiables.
Surveillez les activités inhabituelles sur votre compte et signalez-les immédiatement.

En suivant ces conseils, vous renforcez la sécurité de votre compte Facebook et protégez vos données personnelles.

Courte introduction à la propriété background en CSS3

Tacite WAKILONGO — Thu, 20 Jul 2023 12:59:49 +0000

Lorsque vous concevez un site web, l'arrière-plan est un élément essentiel pour créer une ambiance visuelle et améliorer l'expérience utilisateur. Pour définir l'arrière-plan en CSS, nous utilisons la propriété background. Dans cet article nous allons parler plus concrètement de : background-color, background-image, background-repeat.

Note: Il existe plusieurs autres propriétés pour définir les arrières plan telles que background-clip, background-size... Mais, ici, nous allons nous limiter aux trois ci-dessus précitées.

1. Couleurs d'arrière-plan

La méthode la plus simple pour définir un arrière-plan est d'utiliser une couleur unie. Vous pouvez le faire en utilisant la propriété "background-color" suivie du nom de la couleur ou du code hexadécimal. Par exemple :

body {
  background-color: #f2f2f2;
}

Note : il y a plusieurs façons de spécifier une couleur de . Les plus rependues sont : l’appeler par son nom en anglais (red, marron, yellow …), indiquer son code hexadécimal (#ffffff), l’identifier par la méthode RGB et RGBA…

2. Dégradés d'arrière-plan

Les dégradés sont une autre option populaire pour les arrière-plans. Ils permettent de créer des transitions fluides entre deux couleurs ou plus. Vous pouvez utiliser la propriété "background-image" avec la valeur "linear-gradient" pour définir un dégradé linéaire. Par exemple :

body {
  background-image: linear-gradient(to bottom, #ff0000, #0000ff);
}

3. Images d'arrière-plan

Si vous souhaitez utiliser une image comme arrière-plan, vous pouvez utiliser la propriété "background-image" avec la valeur "url" suivie de l'URL de l'image. Par exemple :

body {
  background-image: url("chemin/vers/image.jpg");
}

Vous pouvez également spécifier d'autres options pour l'image d'arrière-plan, telles que la position, la répétition et la taille, en utilisant les propriétés "background-position", "background-repeat" et "background-size".

4. Motifs d'arrière-plan

Les motifs sont des images répétées pour créer un effet de motif sur l'arrière-plan. Vous pouvez utiliser la propriété "background-image" avec la valeur "url" pour spécifier l'image du motif, et la propriété "background-repeat" pour définir la répétition du motif. Par exemple :

body {
  background-image: url("chemin/vers/motif.png");
  background-repeat: repeat;
}

5. Utilisation de la propriété Background seule

Il est aussi possible d'utiliser la propriété Background sans spécifier un autre élément après lui. Par exemple :

background: red;

Cette façon est peu usitée, mais peut s'avérer utile dans certaines circonstances.

Conclusion

Ce sont quelques-unes des options les plus couramment utilisées pour définir des arrière-plans en CSS. Vous pouvez les combiner et les personnaliser selon vos besoins pour créer des designs uniques et attrayants pour votre site web.

Forem: Tacite WAKILONGO

🚀 Contribuer en Open Source avec Git & GitHub : Le Guide Ultime du Workflow Pro

🚀 Contribuer en Open Source : Le Guide Ultime du Workflow Pro

🏗️ L'analogie du "Chantier Communautaire"

1️⃣ Étape 0 : L'étiquette (Ne travaillez pas pour rien !)

2️⃣ Étape 1 : Le Fork (Ta copie privée)

3️⃣ Étape 2 : Le Clone & l'Upstream (Préparer son bureau intelligemment)

4️⃣ Étape 3 : Installation & README

5️⃣ Étape 4 : La Branche (La zone d'isolation)

6️⃣ Étape 5 : Coder & Respecter les standards

7️⃣ Étape 6 : La Qualité (Husky & Tests)

8️⃣ Étape 7 : Synchronisation (Éviter les conflits)

9️⃣ Étape 8 : Le Push & la Pull Request (La proposition officielle)

🔟 Étape 9 : La Revue de Code (Le dialogue)

📌 Résumé pour ton antisèche :

💡 Le mot de la fin

⚠️ Les mauvaises pratiques qui ruinent une contribution

🧠 Les bonnes pratiques des développeurs pros

🎯 Rappelle-toi ceci

Le backend pour débutants

👨‍🍳 Cuisiner ta première API REST : Le Secret de la Sauce Express, Prisma et Postgres

Tacite WAKILONGO ・ Feb 13

👨‍🍳 Cuisiner ta première API REST : Le Secret de la Sauce Express, Prisma et Postgres

💡 L'analogie du Chef Cuistot

🛠️ La Boîte à Outils

🏗️ Étape 1 : Initialisation du Projet (Préparer la cuisine)

🥘 À quoi servent ces ingrédients ?

🗄️ Étape 2 : Le Schéma (Le Plan d'Architecte ou La Recette)

🤔 C'est quoi un ORM ?

🛡️ Un mot sur la sécurité et la doc

🆔 Pourquoi utiliser des CUID au lieu de chiffres (1, 2, 3) ?

🏗️ Mise en place

🚀 Action !

📂 Étape 3 : L'Architecture MVC (Organises ta cuisine)

🏰 Pourquoi MVC ?

🏗️ Notre structure de fichiers

⚙️ Création du client Prisma (src/lib/prisma.js)

🔐 Étape 4 : L'Authentification (Le Badge d'accès du Coach)

🧑‍🍳 Le Contrôleur d'Authentification (src/controllers/authController.js)

🧐 Ce qu'il faut retenir pour ta carrière :

📝 Étape 5 : Le CRUD des Apprenants (Gérer tes ingrédients)

🧑‍🍳 Le Chef en action (src/controllers/studentController.js)

🔥 Pourquoi c'est important d'être explicite ici ?

📢 Étape 6 : "Faire l'appel" (La fonctionnalité spéciale)

📝 Le code commenté (src/controllers/attendanceController.js) :

🚦 Étape 7 : Les Routes (Le Serveur de salle)

🛤️ Configuration des routes (src/routes/studentRoutes.js) :

🏗️ Le point final : Assembler tout dans src/index.js

🔥 Résumé pour bien comprendre :

🏆 Pourquoi cette approche est-elle "Pro" ?

📂 Rappel de ton architecture (Ton plan de travail)

🧪 À toi de jouer : Le test final avec Postman !

📚 Pour approfondir (Tes sources de savoir)

🚀 Prochaines étapes & Communauté

SUR LE CHEMIN DU HACKING ! Kali Academy, trois mois d’initiation 👺

Introduction

Sur quoi est basé notre infrastructure numérique ?

GNU/Linux, l'OS des Hackers

Git, la collaboration facilitée

les licences opens sources, le droit en ingénierie

Wikimédia, écosystème open source par excellence

Initier un projet open source

Git & GitHub, de l'historique aux dépôts distants

COMMENT RÉSOUDRE L’ERREUR 403 DE GIT ?

C'est quoi l'erreur 403 ?

Comment le résoudre ?

Comment faire sa première contribution dans le monde de l’Open Source

Étape 1: Choisissez un Projet qui Vous Passionne

Étape 2: Comprenez le Projet

Étape 3: Communiquez avec la Communauté

Étape 4: Trouvez une Tâche

Étape 5: Installez l’Environnement de Développement

Étape 6: Faites Votre Première Contribution

Étape 7: Soumettez Votre Contribution

Étape 8: Apprenez de l’Expérience

Conclusion

Comment sécuriser son compte Facebook ?

Pourquoi sécuriser son compte Facebook ?

Pourquoi les pirates chercheraient à contrôler votre compte Facebook ?

Comment les pirates prennent le contrôle de votre compte ?

⚙️ Création du client Prisma (`src/lib/prisma.js`)

🧑‍🍳 Le Contrôleur d'Authentification (`src/controllers/authController.js`)

🧑‍🍳 Le Chef en action (`src/controllers/studentController.js`)

📝 Le code commenté (`src/controllers/attendanceController.js`) :

🛤️ Configuration des routes (`src/routes/studentRoutes.js`) :

🏗️ Le point final : Assembler tout dans `src/index.js`