Objectif : Évaluer les compétences numériques essentielles pour les études et le monde professionnel. Concepts : - Informations : rechercher, vérifier et exploiter des données. - Données : gérer, protéger et organiser ses fichiers. - Communication : interagir et partager en ligne. - Collaboration : travailler en équipe avec des outils numériques. - Sécurité : protéger ses comptes, données et équipements. - Environnement numérique : utiliser les outils informatiques (OS, logiciels). - Création de contenu : produire et modifier des documents (texte, image, code). Compétences évaluées : - Esprit critique face aux informations (fake news, sources). - Utilisation efficace d’Internet et des outils numériques. - Protection des données personnelles (mots de passe, phishing). - Résolution de problèmes techniques simples. - Maîtrise des outils bureautiques et collaboratifs. Méthodologie : 1. Répondre à des questions interactives en ligne 2. Réaliser des exercices pratiques (recherche, manipulation) 3. Adapter les réponses selon le niveau 4. Obtenir un score par compétence 5. Passer la certification officielle surveillée Bonnes pratiques : - Vérifier ses sources - Utiliser des mots de passe sécurisés - Sauvegarder ses données - Mettre à jour ses logiciels - Faire attention aux liens suspects Glossaire : PIX, compétence numérique, cybersécurité, données personnelles, fake news, cloud, navigateur, phishing, mot de passe, certification
Objectif : Comprendre le fonctionnement du framework Symfony, créer des applications web dynamiques et sécurisées avec une architecture structurée. Concepts : - Framework : outil qui évite de réinventer la roue. - Symfony : framework PHP basé sur composants et bundles. - Composer : gestionnaire de dépendances. - Symfony CLI : outil pour gérer projets Symfony. - HTTP : requête (client) / réponse (serveur). - Kernel : cœur de Symfony, gère le cycle de requête. - Routes : définissent les URLs accessibles. - Controllers : traitent les requêtes et renvoient des réponses. - Twig : moteur de template pour générer du HTML. - AssetMapper : gestion JS/CSS. - Doctrine : ORM pour gérer base de données. - Entité : classe liée à une table. - Migration : modification de la structure BDD. - Form : création et gestion des formulaires. - EntityManager : gestion des écritures en base (persist, flush). - Validator : validation des données. - Repository : accès aux données (find, findAll…). - Sécurité : * Authentification * Autorisation - UserInterface : représentation utilisateur. - Firewall : gestion authentification. - PasswordHasher : sécurisation mots de passe. - isGranted : contrôle d’accès. - Voter : règles personnalisées d’accès. - EventDispatcher : gestion événements. - EventListener / Subscriber : écoute événements. - Fixtures : données de test. - Versioning : SemVer, rétrocompatibilité. Méthodologie : 1. Installer Symfony (Composer + CLI) 2. Créer projet 3. Définir routes 4. Créer controllers 5. Créer vues avec Twig 6. Configurer base de données 7. Créer entités (Doctrine) 8. Faire migrations 9. Créer formulaires 10. Valider données 11. Enregistrer avec EntityManager 12. Lire via Repository 13. Gérer utilisateurs et sécurité 14. Tester avec fixtures Bonnes pratiques : - Séparer logique (MVC) - Utiliser Twig pour les vues - Valider toutes les données - Utiliser les entités pour la BDD - Éviter code dupliqué - Sécuriser mots de passe - Restreindre accès (roles, voters) - Utiliser migrations proprement - Tester avec fixtures - Respecter structure Symfony Glossaire : Framework, Symfony, Composer, CLI, HTTP, Requête, Réponse, Kernel, Route, Controller, Twig, Doctrine, Entité, Migration, Formulaire, EntityManager, Validator, Repository, Authentification, Autorisation, Firewall, Voter, EventDispatcher, Fixture, SemVer
Objectif : Comprendre la gestion de versions avec Git et GitHub, collaborer efficacement et gérer les erreurs. Concepts : - Gestionnaire de versions : historique des modifications. - Git : outil de versionning. - GitHub : service d’hébergement de dépôts Git. - Dépôt (repository) : stockage du projet et de son historique. - Dépôt local : copie sur la machine. - Dépôt distant : version en ligne. - Branche : version parallèle du projet. - main : branche principale. - Index : zone intermédiaire avant commit. - Commit : sauvegarde d’une version. - SSH : authentification sécurisée par clé. - Pull Request : demande de fusion de code. - Conflit : modification concurrente à résoudre. Commandes principales : - git init : initialiser un dépôt - git clone : copier un dépôt distant - git add : ajouter fichiers à l’index - git commit -m : créer un commit - git push : envoyer vers dépôt distant - git pull : récupérer les modifications - git checkout : changer de branche - git merge : fusionner branches - git branch -d : supprimer branche - git status : état du projet - git log : historique des commits - git stash : sauvegarde temporaire Gestion des erreurs : - git reset : revenir à un état précédent - git revert : annuler un commit (avec historique) - git commit --amend : modifier dernier commit - git reflog : historique complet des actions - git blame : auteur des modifications - git cherry-pick : appliquer un commit spécifique Méthodologie : 1. Installer et configurer Git 2. Créer ou cloner un dépôt 3. Modifier fichiers 4. Ajouter avec git add 5. Commit avec message clair 6. Envoyer avec git push 7. Travailler avec branches 8. Fusionner avec merge / Pull Request 9. Corriger erreurs si besoin Bonnes pratiques : - Faire des commits fréquents - Écrire des messages clairs - Utiliser des branches pour chaque fonctionnalité - Tester avant de push - Résoudre rapidement les conflits - Ne pas utiliser reset --hard sans précaution - Sauvegarder avec stash si besoin - Collaborer via Pull Request Glossaire : Git, GitHub, Repository, Commit, Branche, Merge, Push, Pull, Clone, Index, SSH, Conflit, Pull Request, Reset, Revert, Reflog, Stash, Cherry-pick, Versioning
Objectif : Comprendre les bases de JavaScript, manipuler les données, interagir avec le DOM et gérer les événements et formulaires. Concepts : - Variables : let (modifiable), const (constante), éviter var. - Types : string, number, boolean. - Opérations : calculs, concaténation. - Objets : propriétés avec {} et accès avec . - Tableaux : liste de données, propriété length, méthodes. - Copie : * Valeur (types simples) * Référence (objets, tableaux) - Algorithme : logique pour résoudre un problème. - Conditions : if, else, switch, opérateurs de comparaison. - Boucles : for, while. - Fonctions : function, paramètres, return. - Portée : variable limitée à son bloc. - DOM : structure HTML manipulable avec JavaScript. - Sélection DOM : getElementById, querySelector. - Attributs : setAttribute, modification directe. - Création HTML : createElement, appendChild, innerHTML. - Interpolation : chaînes avec backticks. - Événements : clic, clavier… - EventListener : addEventListener. - Formulaires : input, textarea, select. - Récupération : * value (champ) * checked (case) - Soumission : événement submit, preventDefault. - Validation : règles, expressions régulières (regex). - Erreurs : * if/else * try/catch/throw Méthodologie : 1. Déclarer variables et types 2. Manipuler données (objets, tableaux) 3. Construire logique (conditions, boucles) 4. Créer fonctions 5. Manipuler le DOM 6. Ajouter/modifier éléments HTML 7. Gérer événements utilisateur 8. Créer et traiter formulaires 9. Valider données (regex) 10. Gérer erreurs Bonnes pratiques : - Nommer clairement les variables - Utiliser const par défaut - Éviter var - Indenter et commenter - Découper en fonctions - Tester avec console.log - Manipuler le DOM après chargement (defer) - Valider les données utilisateur - Gérer les erreurs proprement - Éviter innerHTML non sécurisé Glossaire : Variable, let, const, Type, String, Number, Boolean, Objet, Tableau, Fonction, Paramètre, Return, Condition, Boucle, DOM, HTML, Event, EventListener, Formulaire, Input, Regex, Validation, Try, Catch, Throw, Interpolation
Objectif : Comprendre les fondamentaux de l’intelligence artificielle, ses usages, ses enjeux et les bases du Machine Learning et du Deep Learning. Concepts : - IA : technologie permettant de résoudre des problèmes complexes comme un humain. - Big Data : ensemble de données massives (emails, photos, etc.). - Data Science : analyse et exploitation des données. - Machine Learning : apprentissage automatique à partir des données. - Deep Learning : sous-domaine du ML basé sur des réseaux de neurones. - IA générative : création de contenu (texte, image, vidéo, son). - IA généraliste : capable de réaliser plusieurs tâches (vs IA spécialisée). - Robotique : discipline différente mais souvent liée à l’IA. - Modèle : représentation mathématique des données. - Apprentissage : * Supervisé * Non supervisé * Par essai/erreur - Réseaux de neurones : systèmes inspirés du cerveau. - Convolution : analyse d’images par filtres. - Domaines : santé, éducation, écologie, transport. - Mythes : * Pas de conscience ni émotions réelles * Pas de volonté propre - Risques : * Désinformation * Cyberattaques * Biais des données - Enjeux : * Éthique * Sûreté * Réglementation * Impact écologique - Travail : * Transformation des métiers * Adaptation et formation continue - Projet IA : * Analyse * Collecte * Nettoyage * Exploration * Modélisation * Évaluation * Déploiement * Maintenance Méthodologie : 1. Définir le problème 2. Collecter les données 3. Nettoyer et préparer les données 4. Explorer les données 5. Créer un modèle (Machine Learning) 6. Entraîner le modèle 7. Tester et évaluer 8. Déployer en production 9. Maintenir et améliorer Bonnes pratiques : - Vérifier les sources et informations - Éviter les biais dans les données - Protéger les données personnelles - Être critique face aux résultats - Optimiser l’impact écologique - Tester régulièrement les modèles - Mettre à jour les systèmes IA - Respecter les règles et la réglementation Glossaire : IA, Big Data, Data Science, Machine Learning, Deep Learning, IA générative, Modèle, Algorithme, Données, Dataset, Entraînement, Prédiction, Réseau de neurones, Convolution, Biais, Éthique, Sûreté, Réglementation, Feature, Déploiement, Maintenance
Objectif : Comprendre les bases du langage C, gérer la mémoire, structurer un programme et maîtriser les concepts avancés comme les pointeurs et les structures de données. Concepts : - IDE : éditeur + compilateur + débogueur (Code::Blocks, Visual Studio, Xcode). - Programme : suite d’instructions terminées par ; exécutées dans des fonctions. - main : fonction obligatoire, point d’entrée du programme. - printf / scanf : afficher et saisir des données. - Variables : données stockées en mémoire vive (int, double, char). - Constantes : valeurs non modifiables. - Opérations : +, -, *, /, %, ++, --. - Bibliothèques : math.h, stdio.h, string.h. - Conditions : if, else if, else, switch, opérateur ternaire. - Boucles : while, do while, for. - Fonctions : paramètres, return, réutilisation du code. - Modularité : fichiers .c / .h, compilation, linker. - Portée : variables locales, globales, static. - Pointeurs : stockage d’adresses mémoire (*, &). - Tableaux : données contiguës indexées. - Chaînes : tableau de char terminé par \0. - Préprocesseur : #include, #define, macros, #if. - Structures : type personnalisé avec champs. - Enum : valeurs prédéfinies. - Fichiers : fopen, fclose, lecture/écriture. - Mémoire : malloc, free, sizeof. - Sécurité : buffer overflow, fgets vs gets. - Listes chaînées : éléments liés par adresses. - Pile : LIFO (dernier entré, premier sorti). - File : FIFO (premier entré, premier sorti). - Table de hachage : clé → index via fonction de hachage. Méthodologie : 1. Installer un IDE 2. Créer un programme avec main 3. Utiliser printf / scanf 4. Déclarer variables et types 5. Faire des calculs 6. Ajouter conditions et boucles 7. Créer des fonctions 8. Structurer en fichiers .c / .h 9. Manipuler pointeurs et tableaux 10. Gérer mémoire dynamique (malloc/free) 11. Lire/écrire fichiers 12. Implémenter structures de données Bonnes pratiques : - Toujours terminer par ; - Indenter et commenter le code - Utiliser des noms clairs - Éviter gets (sécurité) - Préférer fgets pour les chaînes - Libérer la mémoire avec free - Limiter les variables globales - Vérifier les erreurs (fichiers, malloc) - Utiliser static si nécessaire - Tester régulièrement Glossaire : IDE, Compilateur, Débogueur, Fonction, Main, Variable, Constante, Mémoire vive, Int, Double, Char, Pointeur, Adresse, Tableau, String, Préprocesseur, Macro, Structure, Enum, Fichier, Malloc, Free, Buffer overflow, Liste chaînée, Pile, File, LIFO, FIFO, Hash, Compilation, Linker
Objectif : Comprendre les bases de Python, créer et manipuler des données, et maîtriser la logique du code. Concepts : - Variable : nom + valeur, stocker des données. - Types : int, float, bool, str. - Listes : collection modifiable de données. - Tuples : collection immuable. - Dictionnaires : paires clé-valeur uniques. - Conditions : if / else / elif, opérateurs <, >, ==, and, or, not, match case. - Boucles : for, while, break, continue. - Fonctions : code réutilisable, avec ou sans paramètres, retourne des valeurs. - Modules / Packages : import / from, pip pour installer. - Extraction Web : requests, BeautifulSoup, parser, ETL. - Code structuré : DRY, responsabilité unique, docstrings, try/except. - Bonnes pratiques Web : ne pas extraire de données personnelles, scripts à mettre à jour. Méthodologie : 1. Installer Python 2. Écrire et exécuter un script 3. Déclarer des variables et vérifier types 4. Créer listes, tuples, dictionnaires 5. Ajouter conditions et boucles 6. Définir et appeler fonctions 7. Importer modules et packages 8. Extraire et parser données Web (requests, BeautifulSoup) 9. Appliquer code structuré et gérer erreurs Bonnes pratiques : - Nommer clairement les variables - Indenter et commenter le code - Tester régulièrement - Ne pas répéter le code (DRY) - Fonctions à responsabilité unique - Documenter avec docstrings - Gérer les exceptions avec try/except - Respecter l’éthique et la confidentialité lors de l’extraction Web Glossaire : Variable, Type, int, float, bool, str, Liste, Tuple, Dictionnaire, Condition, Boucle, For, While, Break, Continue, Fonction, Module, Package, Import, From, Pip, ETL, HTML, Requests, BeautifulSoup, Parser, DRY, Docstring, Try, Except, Web, Éthique
blabla
Objectif : Comprendre les bases de l’algorithmique, structurer un problème et maîtriser les principales structures de données et concepts avancés. Concepts : - Algorithme : suite d’instructions pour résoudre un problème. - Programme : ensemble d’algorithmes. - Entrée / Sortie : données en entrée → traitement → résultat. - Pseudo-code : description d’un algorithme en langage clair (Début / Fin). - Variables : stockage de données avec type (int, string, bool). - Fonctions : bloc de code réutilisable avec entrée et sortie. - Conditions : if, if/else, ET, OU. - Boucles : Tant que (while), Pour (for). - Structures de données : * Tableau : données indexées. * Liste chaînée : éléments reliés. * Table de hachage : clé-valeur. * Pile (LIFO). * File (FIFO). - Structures avancées : * Arbre binaire : nœuds avec 2 enfants max. * Graphe : sommets + arêtes. - Tri : tri à bulles, sélection, insertion. - Complexité : temps et mémoire (notation Big O). - Récursivité : fonction qui s’appelle elle-même. Méthodologie : 1. Comprendre le problème 2. Découper en sous-problèmes 3. Écrire un pseudo-code 4. Définir variables et types 5. Utiliser conditions et boucles 6. Structurer avec fonctions 7. Choisir les bonnes structures de données 8. Optimiser avec tri et complexité 9. Implémenter récursivité si nécessaire Bonnes pratiques : - Découper les problèmes complexes - Utiliser un pseudo-code clair - Choisir le bon type de donnée - Optimiser les algorithmes selon le besoin - Éviter les calculs inutiles - Tester avec différents cas - Penser à la complexité (Big O) - Bien définir la condition d’arrêt en récursivité Glossaire : Algorithme, Programme, Entrée, Sortie, Pseudo-code, Variable, Type, Fonction, Condition, Boucle, While, For, Tableau, Liste chaînée, Hash, Pile, File, LIFO, FIFO, Arbre binaire, Graphe, Sommet, Arête, Tri, Complexité, Big O, Récursivité, Pile d’exécution
Objectif : Comprendre le fonctionnement des sites dynamiques et maîtriser les bases de PHP et des bases de données. Concepts : - Site statique : HTML/CSS, contenu fixe. - Site dynamique : PHP/MySQL, contenu généré. - Client/Serveur : navigateur ↔ serveur. - Variables : stockent des valeurs ($var). - Types : string, int, float, bool. - Conditions : if / else. - Boucles : for, while. - Tableaux : stocker plusieurs données. - Fonctions : code réutilisable. - Base de données : stockage structuré. - SQL : SELECT, INSERT, UPDATE, DELETE. - PDO : connexion PHP → BDD. - Superglobales : $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES. Méthodologie : 1. Installer XAMPP 2. Créer projet dans htdocs 3. Créer fichier PHP 4. Utiliser echo, variables, conditions 5. Ajouter boucles, tableaux, fonctions 6. Créer base de données (phpMyAdmin) 7. Se connecter avec PDO 8. Faire requêtes SQL 9. Traiter formulaires et données Bonnes pratiques : - Mettre ; à chaque instruction - Indenter et commenter le code - Tester régulièrement - Lire les erreurs PHP - Sécuriser les données (htmlspecialchars) - Utiliser requêtes préparées - Toujours filtrer avec WHERE - Refuser fichiers dangereux Glossaire : Serveur, Client, PHP, MySQL, SQL, PDO, HTML, CSS, variable, boucle, fonction, GET, POST, SESSION, COOKIE, XSS, localhost, XAMPP
Objectif : Former aux sciences de laboratoire et valider des compétences scientifiques et techniques pour la poursuite d’études supérieures. Concepts : - STL : Sciences et Technologies de Laboratoire. - Spécialités : * SPCL : Physique-Chimie en laboratoire. * Biotechnologies : biologie, microbiologie, analyses. - Physique-Chimie : mesures, expériences, modélisation. - Biologie : étude du vivant, cellules, micro-organismes. - Chimie : réactions, dosages, analyses. - Mathématiques : outils scientifiques, statistiques. - Projet expérimental : démarche scientifique en laboratoire. - Sécurité : règles en laboratoire. Compétences évaluées : - Réaliser des manipulations en laboratoire - Analyser et interpréter des résultats - Utiliser des instruments scientifiques - Appliquer une démarche expérimentale - Rédiger un compte rendu scientifique - Travailler en équipe - Respecter les protocoles et règles de sécurité Méthodologie : 1. Comprendre le protocole expérimental 2. Réaliser les manipulations 3. Observer et noter les résultats 4. Analyser les données 5. Interpréter les résultats 6. Rédiger un compte rendu structuré 7. Réviser les notions théoriques Bonnes pratiques : - Respecter les consignes de sécurité - Être rigoureux dans les mesures - Vérifier les résultats - Organiser son travail - Soigner les comptes rendus - Réviser régulièrement théorie + pratique Glossaire : STL, SPCL, Biotechnologies, Expérience, Protocole, Analyse, Résultat, Mesure, Laboratoire, Sécurité, Compte rendu, Données, Interprétation
Objectif : Valider les connaissances et compétences acquises à la fin du collège et préparer la poursuite d’études. Concepts : - Français : compréhension, rédaction, grammaire. - Mathématiques : logique, calcul, résolution de problèmes. - Histoire-Géographie : repères historiques et géographiques. - EMC : citoyenneté, valeurs de la République. - Sciences : physique-chimie, SVT, technologie. - Oral : présentation d’un projet (EPI ou parcours). - Socle commun : compétences globales (langage, méthode, autonomie). Compétences évaluées : - Comprendre et analyser un texte - Rédiger correctement et argumenter - Résoudre des problèmes mathématiques - Situer des événements dans le temps et l’espace - Appliquer une démarche scientifique - S’exprimer à l’oral - Travailler en autonomie et en groupe Méthodologie : 1. Réviser les cours principaux 2. S’entraîner avec des sujets type brevet 3. Maîtriser les bases (calcul, rédaction) 4. Gérer le temps pendant l’épreuve 5. Structurer ses réponses (intro, développement, conclusion) 6. Préparer l’oral avec un support clair Bonnes pratiques : - Lire attentivement les consignes - Soigner la rédaction et l’orthographe - Justifier ses réponses - Organiser ses idées - Réviser régulièrement - S’entraîner sur des annales Glossaire : DNB, Socle commun, Épreuve écrite, Oral, Argumentation, Analyse, Problème, Repères, Méthodologie, Révision