Developpeur Web FullStack JS

Parcours developpeur web fullstack js

Bienvenue dans ce voyage captivant du développement web ! Votre parcours en tant que développeur fullstack commence ici, et chaque étape que vous franchirez vous rapprochera un peu plus de la maîtrise complète de cet univers passionnant.

Des premiers jours à la découverte du HTML et du CSS jusqu’à la réalisation d’un projet complet MERN, chaque moment de ce périple vous permettra d’explorer des concepts fondamentaux, de maîtriser des technologies essentielles, et de développer des compétences qui vous propulseront vers des horizons toujours plus vastes.

Les défis qui vous attendent ne sont pas seulement des étapes à franchir, mais des opportunités d’apprentissage, de créativité, et de réalisation personnelle. Chaque ligne de code que vous écrirez sera un pas de plus vers la création d’applications web impressionnantes et l’accomplissement de vos objectifs.

Gardez à l’esprit que chaque développeur a commencé quelque part, et votre détermination et votre passion vous guideront tout au long de ce parcours. Chaque jour apporte de nouvelles connaissances, de nouvelles compétences, et de nouvelles possibilités. Vous êtes sur le point de vivre une aventure palpitante, et le monde du développement web n’attend que vous pour créer, innover, et transformer des idées en réalité.

Alors, préparez-vous à plonger dans le HTML, le CSS, JavaScript, React, Node.js, MongoDB, et bien d’autres encore. Vous êtes sur le point de devenir un développeur fullstack accompli, prêt à relever les défis de l’industrie du web et à construire un avenir rempli de réussite.

Que ce voyage soit une source de motivation constante, d’inspiration infinie, et de satisfaction inégalée. Le monde numérique est à portée de main, et chaque ligne de code que vous écrivez est une étape vers un avenir radieux. Alors, en avant vers l’aventure du développement web ! 🚀💻✨

Jour 1 à 7 

La Découverte du HTML

Au tout début de mon parcours de développement fullstack, je me suis plongé dans le monde du HTML, la base de la création web. Le HTML, acronyme de Hypertext Markup Language, est un langage de balisage qui permet de structurer le contenu d’une page web. Voici les principales notions que j’ai explorées :

  1. Document HTML : Un document HTML est le fichier principal qui contient la structure de la page web.
  2. Tags : Les balises HTML sont utilisées pour encadrer différents éléments sur la page. Par exemple, <h1> définit un titre de premier niveau.
  3. Attributes : Les attributs sont utilisés pour fournir des informations supplémentaires aux balises. Par exemple, href dans <a href="lien.html">.
  4. Layout : La structure de la page web, définie par des balises comme <header>, <nav>, <main>, et <footer>, organise le contenu de manière logique.
  5. Entities : Les entités HTML, telles que &lt; (qui représente « <« ), sont utilisées pour afficher des caractères spéciaux dans le texte.
  6. Media : Les balises <img>, <audio>, et <video> permettent d’intégrer des médias sur la page.
  7. Forms : Les formulaires HTML sont créés avec <form> et peuvent contenir des éléments tels que des champs de texte, des boutons, et des cases à cocher.
  8. Graphics : Les graphiques peuvent être insérés avec <canvas> pour le dessin et <svg> pour les graphiques vectoriels.
  9. Event : Les événements tels que les clics de souris peuvent être gérés avec JavaScript en utilisant des attributs tels que onclick.
  10. API : L’interface de programmation d’application (API) du navigateur permet d’interagir avec le navigateur, par exemple pour manipuler le DOM.
  11. Canvas : <canvas> permet de dessiner des graphiques et des animations directement dans la page.
  12. Semantic : L’utilisation de balises sémantiques comme <article>, <section>, et <aside> améliore l’accessibilité et la signification du contenu.

Pendant cette première semaine, j’ai écrit du code HTML pour créer une page de base, en utilisant ces concepts pour structurer mon contenu de manière appropriée.

Exemple :

<!DOCTYPE html>
  <html>
    <head>
      <title>Ma Page Web</title>
    </head>
  <body>
    <header>
      <h1>Mon Titre</h1>
    </header>
    <nav>
      <ul>
        <li><a href= »# »>Accueil</a></li>
        <li><a href= »# »>À propos</a></li>
      </ul>
    </nav>
  <main>
     <section>
       <h2>Section principale</h2>
       <p>Ceci est un paragraphe.</p>
     </section>
  </main>
  <footer>
    <p>Copyright © 2023</p>
    </footer>
  </body>
</html>

 

Cela a posé les bases pour la suite de mon apprentissage, en me permettant de comprendre comment structurer une page web de manière efficace.

Jour 8 à 14 

La Découverte du CSS

Après avoir solidifié mes connaissances en HTML, j’ai plongé dans le monde du CSS, le langage qui permet de styliser et de mettre en forme une page web. Voici un aperçu des concepts que j’ai explorés pendant cette période :

  1. Selectors : Les sélecteurs CSS sont utilisés pour cibler des éléments HTML spécifiques et leur appliquer des styles. Par exemple, h1 cible tous les titres de niveau 1.
  2. Declaration : Les déclarations CSS définissent les styles à appliquer aux éléments sélectionnés. Par exemple, color: blue; définit la couleur du texte en bleu.
  3. Box Model : Le modèle de boîte CSS comprend le contenu, la marge, la bordure et le rembourrage autour d’un élément HTML.
  4. Fonts : La propriété font-family permet de spécifier la police de caractères, tandis que font-size définit la taille de la police.
  5. Floats : La propriété float permet d’aligner les éléments à gauche ou à droite par rapport à leur conteneur.
  6. Positioning : Les valeurs relative, absolute, et fixed définissent comment les éléments sont positionnés par rapport à leur conteneur ou à la fenêtre du navigateur.
  7. Display : La propriété display permet de contrôler le comportement de l’élément, par exemple display: none; le rend invisible.
  8. Flexbox : Le modèle de mise en page flexible de CSS, activé avec display: flex;, simplifie la création de mises en page complexes.
  9. Grid : La disposition en grille avec display: grid; offre un contrôle précis sur la disposition des éléments.
  10. Animation : Les animations CSS permettent de créer des transitions en douceur entre les états des éléments.
  11. Transition : Les transitions CSS permettent de créer des effets de transition lorsque les propriétés CSS changent.
  12. Pseudo Class : Les pseudo-classes comme :hover ou :active ciblent les états spécifiques des éléments.
  13. Pseudo Element : Les pseudo-éléments comme ::before et ::after permettent d’ajouter du contenu à un élément.
  14. Media Query : Les requêtes média (@media) permettent de rendre une page web réactive en fonction de la taille de l’écran.

Pendant cette période, j’ai créé des feuilles de style CSS pour donner vie à ma page HTML. Voici un exemple de code CSS pour styler un élément HTML :

/* Sélectionne tous les paragraphes */
p {
  font-size: 16px;
  color: #333;
  margin: 10px;
}

/* Sélectionne les liens au survol de la souris */
a:hover {
  text-decoration: underline;
}

/* Crée une classe personnalisée */
.my-class {
  background-color: lightblue;
  padding: 10px;
}

 

Cette étape m’a permis de comprendre comment rendre ma page web attrayante et esthétiquement agréable pour les utilisateurs.

La suite de mon parcours m’a conduit à choisir entre les frameworks CSS populaires tels que Bootstrap, Tailwind CSS, et Bulma. J’ai opté pour Tailwind CSS en raison de sa flexibilité et de sa simplicité.

Jour 15 à 21 : Découverte de Tailwind CSS

Au cours de cette période, j’ai plongé dans Tailwind CSS, un framework CSS basé sur des classes utilitaires. Voici ce que j’ai appris :

  1. Installation : J’ai appris comment installer Tailwind CSS dans mon projet en utilisant npm ou en liant le CDN.
  2. Configuration : J’ai configuré Tailwind CSS pour personnaliser les classes et les styles selon les besoins du projet.
  3. Content : J’ai utilisé les classes pour styliser le contenu HTML, en modifiant la couleur, la typographie, la taille, etc.
  4. Theme : Le fichier de configuration permet de personnaliser le thème global de l’application, comme les couleurs et les polices par défaut.
  5. Propriété : Tailwind offre une grande variété de classes pour manipuler les propriétés CSS, telles que bg-blue-500 pour définir la couleur de fond bleue.
  6. Responsive : Les classes responsives de Tailwind, comme md:text-xl, permettent d’ajuster le style en fonction de la taille de l’écran.

Tailwind CSS a simplifié le processus de stylisation de ma page web en me permettant d’ajouter rapidement des styles en utilisant des classes prédéfinies.

Exemple :

<!– Utilisation de Tailwind CSS –>
<div class= »bg-blue-500 p-4 md:p-8 text-white »>
  <h1 class= »text-2xl md:text-4xl »>Mon Titre</h1>
  <p class= »mt-4″>Un paragraphe stylisé avec Tailwind CSS.</p>
</div>

 

Cela m’a permis de gagner du temps tout en maintenant un code propre et lisible. Tailwind CSS est devenu un outil précieux dans mon arsenal de développement web.

Jour 22 à 28 

La Découverte du SCSS

Après avoir maîtrisé Tailwind CSS, j’ai souhaité explorer un préprocesseur CSS, et j’ai choisi SCSS (Sass) pour ses fonctionnalités avancées. Voici un aperçu de ce que j’ai appris pendant cette période :

  1. Variable : Les variables en SCSS permettent de stocker des valeurs réutilisables pour les couleurs, les tailles, les marges, etc. Cela simplifie la maintenance du code en cas de changements fréquents.

$primary-color: #3498db;

.button {
  background-color: $primary-color;
}

  1. Boucle : Les boucles @for, @each, et @while permettent de générer du code CSS de manière dynamique, par exemple pour créer des grilles ou des séries de classes.
@for $i from 1 through 5 {
  .column-#{$i} {
    width: 20% * $i;
  }
}
  1. Fonctions : Les fonctions SCSS personnalisées peuvent être définies pour effectuer des calculs ou des opérations de transformation sur les valeurs.

@function calculate-width($value) {
@return $value * 2;
}

.element {
width: calculate-width(10px);
}

  1. Imports : SCSS permet d’importer des fichiers partiels pour organiser le code en modules réutilisables.
@import « variables »;
@import « buttons »;
  1. Mixins : Les mixins sont des blocs de code réutilisables qui peuvent être inclus dans d’autres sélecteurs, permettant de partager des styles.

@mixin button-styles {
  background-color: $primary-color;
  color: white;
  padding: 10px 20px;
}

.button {
  @include button-styles;
}

  1. Nesting : En utilisant la syntaxe de SCSS, il est possible de créer des sélecteurs imbriqués pour organiser le code de manière plus claire.
.container {
  h1 {
    font-size: 24px;
  }
p {
  font-size: 16px;
  }
}

La maîtrise de SCSS m’a permis de structurer mon code CSS de manière plus efficace et de réduire la duplication. Cela a également facilité la maintenance de projets plus importants en gardant le code propre et modulaire.

La suite de mon parcours m’a amené à découvrir le monde de la programmation côté client avec JavaScript.

Jour 29 à 42 : La découverte de JavaScript

JavaScript est un langage de programmation essentiel pour le développement web côté client. Voici ce que j’ai appris lors de cette étape :

  1. Syntaxe : Les bases de la syntaxe JavaScript, y compris la déclaration de variables (var, let, const), les opérations mathématiques, et les structures de contrôle (if, for, while).
let num1 = 10;
let num2 = 5;
let sum = num1 + num2;
  1. Variable : Comprendre les différents types de données, tels que les nombres, les chaînes de caractères, les tableaux, et les objets.
let name = « John »;
let numbers = [1, 2, 3];
let person = { firstName: « John », lastName: « Doe » };
  1. Scopes : Comprendre les scopes global et local, ainsi que la portée des variables.

let globalVar = « Je suis une variable globale »;

function exampleFunction() {
  let localVar = « Je suis une variable locale »;
}

  1. Strict Mode : L’utilisation de "use strict" améliore la qualité du code en rendant les erreurs plus visibles.
« use strict »;
  1. Comments : L’ajout de commentaires dans le code pour expliquer le fonctionnement et la logique.
// Ceci est un commentaire
  1. DOM (Document Object Model) : Manipuler le DOM pour interagir avec les éléments HTML à l’aide de JavaScript.
let element = document.getElementById(« myElement »);
element.innerHTML = « Nouveau contenu »;
  1. Closure : Comprendre les fonctions de fermeture qui capturent des variables dans leur environnement lexical.

function outer() {
  let outerVar = « Je suis une variable externe »;

function inner() {
  console.log(outerVar);
}

return inner;
}

let closureFunc = outer();
closureFunc(); // Affiche « Je suis une variable externe »

  1. Hoisting : Comprendre le hoisting des déclarations de variables et de fonctions.
console.log(myVar); // undefined
var myVar = 5;
  1. Class : La création de classes en JavaScript pour organiser le code et créer des objets.

class Person {
  constructor(name) {
    this.name = name;
  }
  sayHello() {
    console.log(`Bonjour, je m’appelle ${this.name}`);
  }
}

let person = new Person(« Alice »);
person.sayHello(); // Affiche « Bonjour, je m’appelle Alice »

  1. Shadow DOM : La notion de Shadow DOM pour encapsuler les styles et le comportement dans les composants web.
  2. Operators : Utilisation des opérateurs arithmétiques, de comparaison, et logiques.
  3. Fetch / Ajax : Effectuer des requêtes HTTP asynchrones pour récupérer des données depuis un serveur.
fetch(« https://api.example.com/data »)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));
  1. Conditional : Utilisation des déclarations conditionnelles if, else if, et else pour prendre des décisions en fonction des conditions.
let age = 25;
if (age >= 18) {
  console.log(« Vous êtes majeur. »);
} else {
  console.log(« Vous êtes mineur. »);
}
  1. Loops : Les boucles for, while, et do...while pour répéter des actions.
for (let i = 0; i < 5; i++) {
  console.log(i);
}
  1. Function : La création et l’appel de fonctions pour encapsuler la logique réutilisable.

function add(a, b) {
  return a + b;
}

let result = add(3, 5); // result vaut 8

  1. Callbacks : La compréhension des callbacks pour gérer les opérations asynchrones.

function fetchData(callback) {
  setTimeout(() => {
  callback(« Données reçues »);
}, 1000);
}

fetchData(data => {
  console.log(data);
});

  1. Events : La gestion des événements tels que les clics de souris, les saisies clavier et les événements de formulaire.
let button = document.getElementById(« myButton »);
button.addEventListener(« click », () => {
console.log(« Bouton cliqué ! »);
});
  1. Promises : Utilisation des promises pour gérer les opérations asynchrones de manière plus lisible et robuste.

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(« Données reçues »);
    }, 1000);
  });
}

fetchData()
  .then(data => console.log(data))
  .catch(error => console.error(error));

  1. Async / Await : L’utilisation d’async et await pour simplifier la gestion des promesses et rendre le code asynchrone plus lisible.
async function fetchData() {
  try {
    let data = await fetchDataFromServer();
    console.log(data);
  } catch (error) {
    console.error(error);
  }
}

Cette phase m’a permis de comprendre la logique et les bases de la programmation JavaScript, qui sont essentielles pour créer des applications web interactives et dynamiques.

La prochaine étape de mon parcours m’a conduit à choisir un framework JavaScript pour développer des applications front-end. J’ai opté pour React.

Jour 43 à 56 : Découverte de React

React est une bibliothèque JavaScript populaire pour la création d’interfaces utilisateur interactives. Voici ce que j’ai appris lors de cette période :

  1. JSX (JavaScript XML) : Comprendre comment utiliser JSX pour décrire la structure de l’interface utilisateur.
const element = <h1>Bienvenue à React</h1>;
  1. Le DOM Virtuel (Virtual DOM) : Comprendre comment React utilise un DOM virtuel pour optimiser les mises à jour du DOM réel.
  2. Composant : La création de composants réutilisables en React, qui sont des blocs de construction de l’interface utilisateur.
function Button(props) {
  return <button>{props.label}</button>;
}
  1. Route : L’utilisation de React Router pour gérer la navigation entre différentes vues dans une application.
  2. Props : Passer des données aux composants enfants à l’aide des propriétés (props).
function Welcome(props) {
  return <h1>Bienvenue, {props.name}</h1>;
}
  1. Children / Parent : Comprendre comment les composants peuvent avoir des composants enfants et communiquer avec eux.
  2. Événement : Gérer les événements utilisateur tels que les clics de souris dans les composants React.

function MyButton() {
  function handleClick() {
    alert(« Bouton cliqué ! »);
}

return <button onClick={handleClick}>Cliquez-moi</button>;
}

  1. Hooks : Utilisation des hooks tels que useState et useEffect pour gérer l’état et les effets dans les composants fonctionnels.

import React, { useState, useEffect } from ‘react’;

function Counter() {
  const [count, setCount] = useState(0);

useEffect(() => {
  document.title = `Compteur : ${count}`;
}, [count]);

return (
<div>
  <p>Compteur : {count}</p>
  <button onClick={() => setCount(count + 1)}>Incrémenter</button>
</div>
);
}

  1. setState : Mettre à jour l’état d’un composant en utilisant la méthode setState.
  2. Context : Gérer l’état global de l’application avec React Context.
  3. Test unitaire : Écrire des tests unitaires avec des bibliothèques comme Jest pour s’assurer que les composants React fonctionnent correctement.

React est devenu un outil clé dans mon parcours de développement, me permettant de créer des interfaces utilisateur réactives et modulaires.

Après avoir acquis de solides compétences en développement front-end avec React, j’ai continué mon parcours en explorant le développement côté serveur avec Node.js.

Jour 57 à 59 : Découverte de Node.js

Node.js est un environnement d’exécution JavaScript côté serveur. Voici ce que j’ai appris lors de cette période :

  1. Environnement : Comprendre comment configurer un environnement Node.js sur ma machine.
  2. CLI (Command Line Interface) : Utilisation de la ligne de commande Node.js pour exécuter des scripts et gérer des packages.
  3. Communication Serveur : Création d’un serveur HTTP en utilisant le module http de Node.js pour gérer les demandes et les réponses.

const http = require(‘http’);

const server = http.createServer((req, res) => {
  res.writeHead(200, { ‘Content-Type’: ‘text/html’ });
  res.end(‘Hello, Node.js!’);
});

server.listen(3000, () => {
  console.log(‘Serveur en cours d\’écoute sur le port 3000’);
});

  1. Déploiement : Comprendre les différentes options de déploiement pour les applications Node.js, y compris les services d’hébergement et les plateformes cloud.
  2. Express.js : Exploration d’Express.js, un framework web pour Node.js, pour simplifier la création d’applications web robustes.

Node.js m’a ouvert la porte à la création de serveurs web et à la gestion des opérations côté serveur, ce qui est essentiel pour le développement fullstack.

Jour 60 à 63 : Découverte de GitHub

GitHub est une plateforme de développement collaboratif qui utilise Git pour la gestion de versions. Voici ce que j’ai appris pendant cette période :

  1. Commit : La création de commits pour enregistrer les modifications apportées à un projet.
git commit -m « Ajout de nouvelles fonctionnalités »
  1. Branch : La création de branches Git pour travailler sur des fonctionnalités ou des correctifs isolés.
git branch feature-xyz
  1. Remote : L’ajout de dépôts distants (remote) pour collaborer avec d’autres développeurs.
git remote add origin https://github.com/utilisateur/projet.git
  1. Historique : L’affichage de l’historique des commits avec git log.
  2. Fork : La création d’un fork d’un projet sur GitHub pour contribuer à des projets open source.
  3. Pull : La création de pull requests pour soumettre des modifications à un projet.

GitHub est un outil essentiel pour le travail collaboratif et la gestion de versions, ce qui est crucial dans le développement de logiciels professionnels.

Après avoir acquis une solide compréhension de Node.js et de GitHub, j’ai exploré les bases de données en choisissant MongoDB comme système de gestion de base de données NoSQL.

Jour 64 à 70 : Découverte de MongoDB

MongoDB est une base de données NoSQL orientée document. Voici ce que j’ai appris lors de cette période :

  1. JSON : Comprendre que MongoDB stocke des données sous forme de documents JSON (JavaScript Object Notation).
  2. NoSQL : Comprendre les avantages et les inconvénients des bases de données NoSQL par rapport aux bases de données relationnelles.
  3. Schéma : Comprendre la flexibilité des schémas dans MongoDB, où chaque document peut avoir sa propre structure.
  4. Document : Manipuler des documents MongoDB, qui sont similaires à des enregistrements dans une base de données relationnelle.
  5. Collection : Regrouper des documents similaires dans des collections MongoDB.
  6. Graphe : Explorer les fonctionnalités de base de données orientée graphe de MongoDB, telles que la recherche de relations.

MongoDB m’a permis de stocker et de récupérer des données de manière flexible, ce qui est utile pour des applications qui évoluent rapidement.

Après avoir exploré ces concepts fondamentaux, je suis passé à la réalisation d’un projet complet MERN (MongoDB – Express.js – React – Node.js) au cours des jours 70 à 100 de mon parcours. Ce projet m’a permis d’appliquer toutes les compétences que j’avais acquises jusqu’à présent pour créer une application web fonctionnelle et interactive.

Au fil de ce parcours, j’ai acquis une solide compréhension du développement fullstack, en passant par les technologies front-end et back-end, la gestion de bases de données, la gestion de versions, et bien plus encore. Mon aventure en tant que développeur fullstack continue, avec une base solide pour explorer davantage de technologies et de projets passionnants.

Jour 70 à 100

Réalisation d’un projet complet MERN

Au cours des jours 70 à 100 de mon parcours, j’ai entrepris la réalisation d’un projet complet MERN, en utilisant MongoDB, Express.js, React, et Node.js pour créer une application web fonctionnelle et interactive. Voici un aperçu de mon expérience lors de cette étape cruciale :

  1. MongoDB : J’ai utilisé MongoDB pour concevoir la base de données de mon application. J’ai créé des collections et des schémas de données adaptés aux besoins de mon projet.
  2. Express.js : Pour la partie serveur de mon application, j’ai développé des routes et des API en utilisant Express.js. J’ai configuré des points d’accès pour récupérer, ajouter, mettre à jour et supprimer des données depuis la base de données.
  3. React : J’ai créé des composants React pour construire l’interface utilisateur de mon application. J’ai utilisé des composants fonctionnels et de classe pour afficher des données, gérer des formulaires, et interagir avec l’utilisateur.
  4. Node.js : Mon serveur Node.js a été configuré pour gérer les requêtes HTTP provenant de l’application front-end et pour interagir avec la base de données MongoDB.
  5. Gestion d’état : J’ai mis en place une gestion d’état efficace en utilisant les hooks et le contexte de React pour partager des données entre les composants et maintenir une expérience utilisateur cohérente.
  6. Authentification : J’ai intégré un système d’authentification en utilisant des sessions ou des tokens JWT (JSON Web Tokens) pour permettre aux utilisateurs de s’inscrire, de se connecter et d’accéder à des fonctionnalités spécifiques.
  7. Validation des données : J’ai mis en place une validation côté serveur et côté client pour garantir que les données entrées par les utilisateurs sont correctes et sécurisées.
  8. Interface utilisateur responsive : J’ai utilisé CSS, avec ou sans l’aide de bibliothèques comme Tailwind CSS, pour rendre l’application adaptée aux différentes tailles d’écran.
  9. Tests unitaires : J’ai écrit des tests unitaires pour vérifier le bon fonctionnement de mes composants React et de mes routes Express.js.
  10. Déploiement : J’ai appris à déployer mon projet sur une plateforme cloud ou un serveur en production, en configurant correctement l’environnement et en optimisant les performances.
  11. Gestion de version : J’ai continué à utiliser Git et GitHub pour suivre les modifications de code, collaborer avec d’autres développeurs si nécessaire, et déployer les mises à jour de l’application.
  12. Maintenance : J’ai acquis des compétences essentielles en matière de maintenance, de débogage et de résolution de problèmes pour garantir que mon application reste stable et performante.
  13. Sécurité : J’ai pris en compte les principes de sécurité lors de la conception de mon application, en m’assurant de protéger les données sensibles et d’éviter les vulnérabilités.
  14. Optimisation : J’ai optimisé mon application pour des temps de chargement rapides, une utilisation efficace des ressources et une expérience utilisateur fluide.

La réalisation de ce projet MERN a été une expérience d’apprentissage précieuse qui m’a permis d’appliquer toutes les connaissances et compétences que j’avais acquises tout au long de mon parcours. J’ai pu voir comment les différentes parties de la pile technologique interagissent pour créer une application web fonctionnelle, ce qui a renforcé ma confiance en tant que développeur fullstack.

Mon parcours de développement continue, avec l’exploration de nouvelles technologies, la participation à des projets plus complexes et la croissance constante de mes compétences en tant que développeur fullstack. L’avenir est prometteur, et je suis impatient de relever de nouveaux défis passionnants dans le monde du développement web.

Retour blog

1 Commentaire

  1. Eric sur 11 septembre 2023 à 15h33

    Ceci n’est pas mon parcours mais j’aurai pu le faire comme celui la ^^.

    Réponse

Soumettre un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Autres articles