Le groupe I.M.P, avec la possibilité de TETO !?

⯆⚉⯆
~Teteteto~
"Ne me traite pas de 'mignon', je suis gangsta !"
(Recommandé d'être utilisé avec une sorte de proxy. Je ne sais pas si JLMM fonctionnera, et j'ai la flemme de le tester moi-même)

Scénario un :
Loona, Millie et Moxxie fuient les flics.

Scénario deux :
Tu travailles à l'I.M.P depuis un mois maintenant. Aujourd'hui, ils ont tous une réunion.

Scénario trois :
Tu es malade. Loona prend soin de toi. (censé être tout doux)

Scénario quatre :
Toi et Millie êtes en mission sur Terre.

Scénario cinq :
Oh-oh...

Scénario six :
Une grosse dispute a eu lieu. Va consoler Loona.

Scénario sept :
Toi et la Loon faites les idiots.

Scénario huit :
Loona, Millie, Moxxie et Blitzo veulent adopter un nouveau HellHound. C'est toi, frérot. (POV Hellhound)

Scénario neuf :
Entrez votre propre scénario.

Tags :
Les ordinateurs n'ont aucun sens. Balance un peu de métal dans une boîte et boum. Qu'est-ce qui se passe ici, bon sang ? À l'intérieur de ton PC se trouve une unité centrale de traitement, ou CPU. C'est en gros juste un morceau de silicium avec des milliards d'interrupteurs microscopiques appelés transistors. Selon le flux d'électricité, ils peuvent être allumés ou éteints, un peu comme une ampoule, ce qui nous donne deux états, un et zéro. La valeur de l'un de ces interrupteurs s'appelle un bit. Un bit tout seul ne fait pas grand-chose, mais mets-les ensemble et... Un groupe de 8 bits s'appelle un octet, et peut avoir 256 combinaisons différentes de 0 et de 1. Félicitations ! On peut maintenant stocker de l'information en comptant dans un système appelé binaire. Chaque bit représente une puissance de 2, 1 signifiant que la puissance est incluse et 0 qu'elle ne l'est pas, donc ce nombre a 1 fois 64, 1 fois 4, et 1 fois 1, ce qui donne 69. C'est bien, mais pour les humains, l'hexadécimal est encore mieux. Il est souvent indiqué par ce 0x, et c'est simplement un format plus lisible que le binaire. Quatre bits binaires peuvent prendre n'importe quelle valeur de 0 à 15. L'hexadécimal utilise 0 à 9 et A à F pour représenter ces valeurs, donc un groupe de quatre bits peut être remplacé par un chiffre hexadécimal. Bon, maintenant qu'on peut stocker des nombres, il faut juste que les ordinateurs fassent réellement, tu sais, quelque chose avec. Avec des transistors, tu peux fabriquer des portes logiques, qui sont des circuits électroniques qui encapsulent des énoncés logiques. Tu peux voir ça comme une ampoule avec deux interrupteurs, où la lumière ne s'allume que sous certaines conditions, par exemple seulement si A et B sont allumés. En combinant des portes logiques de façon astucieuse, tu peux construire des circuits qui effectuent des calculs selon l'algèbre de Boole, qui est un système formalisant les opérations mathématiques en binaire. Mais même si les ordinateurs comprennent les zéros et les uns, pour les humains ce n'est pas vraiment utile. Donc, en utilisant un encodage de caractères comme ASCII, on peut attribuer un nombre binaire à chaque caractère. Quand tu tapes n'importe quoi sur ton clavier, ça se traduit en ce code binaire, et dès que l'ordinateur voit ça, il dit, ah oui, c'est un A majuscule, et le plaque à l'écran. La façon dont ces appareils s'emboîtent est gérée par un noyau de système d'exploitation, comme Windows, Linux ou Mac, qui se situe entre le matériel informatique et les applications et gère la façon dont tout ça fonctionne ensemble, par exemple avec des pilotes de périphériques. Les périphériques d'entrée te permettent de donner des instructions à l'ordinateur en appuyant sur un bouton, mais au niveau le plus bas, les ordinateurs ne comprennent que les instructions en langage machine, qui est du code binaire disant au CPU quoi faire et quelles données utiliser. Pour suivre ces instructions, le CPU est un peu comme un génie, mais avec la mémoire d'un poisson rouge dément. Il peut traiter n'importe quelles instructions, mais il ne peut stocker aucune donnée, donc il n'est vraiment utile qu'avec de la mémoire vive, ou RAM. Tu peux l'imaginer comme une grille, où chaque case peut contenir un octet d'information, qui peut être une donnée ou une instruction, et possède une adresse pour que le CPU puisse y accéder en quatre étapes. Récupérer depuis la mémoire, décoder les instructions et les données, et enfin, exécuter et stocker le résultat. C'est un cycle machine. Puisqu'un programme n'est en gros qu'une liste d'instructions et de mémoire, pour l'exécuter, le CPU les exécute une par une en cycles machine jusqu'à ce que ce soit terminé. Oh oui, ai-je mentionné que ça se passe, genre, vraiment vite ? Les CPU modernes peuvent faire des milliards de cycles par seconde, qui sont coordonnés et synchronisés par un générateur d'horloge. La vitesse de cette horloge se mesure en gigahertz, et les gens overclockent souvent leur CPU pour améliorer les performances, ce qui est bien, mais pourrait juste mettre le feu à ton PC. Ce qui est encore plus fou, c'est qu'un CPU a plusieurs cœurs, qui peuvent tous exécuter différentes instructions en parallèle, donc en même temps. Chaque cœur peut aussi être divisé en plusieurs threads, ce qui permet à chaque cœur de gérer plusieurs instructions simultanément, donc de basculer entre elles très rapidement. Bon, c'est cool, mais peu importe la puissance d'un ordinateur si tu n'as aucun moyen de lui donner des instructions dès le départ. Taper du langage machine à la main te rendrait probablement fou, mais heureusement, tu n'as pas à le faire. Le noyau est enveloppé dans un shell, qui est juste un programme qui expose le noyau à l'utilisateur, permettant des instructions simples dans une interface en ligne de commande avec des entrées de texte. Mais la meilleure façon de faire faire quelque chose d'utile à un ordinateur est avec un langage de programmation, qui utilise l'abstraction pour qu'au lieu de ceci tu puisses écrire du code qui ressemble à ça, qui est ensuite converti en langage machine pour toi. Certains langages comme Python utilisent un interpréteur, qui essaie directement d'exécuter le code source ligne par ligne. D'autres langages comme C ou Go utilisent un compilateur, qui convertit tout le programme en langage machine avant de le mettre dans un fichier que le CPU peut exécuter. Maintenant, chaque langage de programmation a une syntaxe différente, mais il y a des outils de base que presque tous possèdent. La façon la plus basique d'utiliser des données est avec des variables, qui assigne une valeur à un nom qui peut ensuite être réutilisé et modifié. Selon la valeur, les variables peuvent avoir différents types de données. Pour le texte, il y a les caractères uniques et les chaînes de plusieurs caractères. Pour les nombres, il y a les entiers, qui peuvent aussi être signés s'ils sont négatifs, et les nombres à virgule flottante pour les valeurs décimales. On les appelle à virgule flottante parce que la virgule peut flotter pour faire un compromis entre précision et plage. C'est possible parce qu'ils utilisent la notation scientifique. C'est un nombre fois une puissance qui te dit où placer la virgule, ce à quoi ils ressemblent exactement sous le capot. Le nombre réel est stocké avec des fractions binaires. Certaines fractions, comme un tiers, ne peuvent être qu'approximées en binaire avec une somme infinie. Mais, comme la mémoire n'est pas infinie, tu dois la couper à un moment donné, ce qui entraîne des erreurs d'arrondi, causant parfois des calculs assez bizarres. Si ça ne suffit pas, long et double utilisent deux fois la quantité de mémoire pour doubler la plage des ints et des floats. Certains langages comme Python déterminent automatiquement le type d'une variable, mais dans un langage comme C, tu dois déclarer explicitement le type d'une variable. La valeur d'une variable est stockée à une certaine adresse en mémoire. Les pointeurs sont des variables dont la valeur est l'adresse mémoire d'une autre variable, ce qui est indiqué par cet esperluette. Donc en réalité, un pointeur n'est qu'un morceau de mémoire pointant vers un autre morceau de mémoire. Puisqu'une adresse mémoire n'est qu'un nombre, tu peux y ajouter et soustraire pour naviguer à travers les octets individuels de la mémoire. C'est ce qu'on appelle l'arithmétique des pointeurs. Dans certains langages de bas niveau comme C, tu dois allouer et libérer manuellement la mémoire une fois qu'elle n'est plus utilisée. Tout ça se passe dans le tas, qui est une partie de la mémoire pouvant grandir et rétrécir dynamiquement selon les besoins du programme, ce qui permet plus de contrôle mais rend incroyablement facile de complètement casser ton code. Tu pourrais toucher de la mémoire qui n'est pas à toi ou qui n'existe simplement pas, ce qu'on appelle une erreur de segmentation. Mais aussi, s'il y a un morceau de mémoire qui n'est plus utilisé et que tu oublies de le libérer ou que tu n'as plus aucun moyen d'y accéder, cette mémoire n'est plus utilisable. C'est ce qu'on appelle une fuite de mémoire et ça peut ralentir le programme et finir par le faire planter. Pour éviter ce désastre, les langages de haut niveau comme Python ont des ramasse-miettes intégrés qui gèrent la mémoire pour toi. Différents types de données occupent différentes quantités de mémoire. Les entiers font le plus souvent 4 octets de mémoire, un caractère unique fait le plus souvent 1 octet de mémoire, et une chaîne n'est que plusieurs octets de caractères avec un caractère nul pour signaler la fin de la chaîne. Stocker plusieurs éléments dans un bloc de mémoire contigu comme ça, c'est l'idée d'un tableau. Plus généralement, c'est une liste d'éléments du même type de données, chaque élément ayant un index numérique, commençant le plus souvent à 0. Comme les éléments sont côte à côte en mémoire, en connaissant l'adresse du premier élément, tu peux rapidement accéder à n'importe quel élément du tableau en utilisant l'arithmétique des pointeurs. Les tableaux sont ce qu'on appelle une structure de données, qui n'est qu'une façon d'organiser des données pour les rendre plus faciles à manipuler. Récupérer des valeurs d'un tableau est extrêmement rapide, mais la taille d'un tableau est souvent fixée à sa création, donc quand il est plein tu ne peux plus rien ajouter, et si tu ne l'utilises pas entièrement, c'est juste de la mémoire gaspillée, donc une option plus flexible est une liste chaînée. Elle utilise des nœuds contenant une valeur et un pointeur vers le nœud suivant, ce qui leur permet d'être dispersés en mémoire. De plus, elle peut grandir et rétrécir dynamiquement car tu peux ajouter et retirer n'importe quel nœud, et tu peux la réorganiser en réarrangeant simplement les pointeurs. C'est génial, mais elles peuvent être peu pratiques car tu n'as aucun moyen d'accéder au dernier nœud sauf si tu traverses chacun de ceux qui le précèdent. Mais quand même, les tableaux et les listes chaînées sont utiles car ils te permettent de créer des files et des piles. Une pile suit le principe du dernier entré, premier sorti, comme prendre une crêpe dans une pile. En pratique, imagine juste un pointeur qui pointe toujours vers l'élément qui a été ajouté en dernier à la structure, puis tu peux dépiler, donc retirer le dernier élément ce qui incrémente le pointeur en arrière. Une file suit le principe du premier entré, premier sorti et utilise deux pointeurs, un pour le premier élément ajouté et un pour le dernier. Tout nouvel élément est ajouté après le dernier pointeur, qui est ensuite mis à jour, et le défilement commence au premier pointeur. Une autre structure de données utile est une table de hachage, qui n'est qu'une collection de paires clé-valeur. Elle fonctionne un peu comme un tableau, mais utilise une fonction de hachage pour prendre une clé et l'assigner à un index, où sa valeur est ensuite stockée. Mais parfois, deux clés différentes peuvent correspondre au même index, ce qu'on appelle une collision. Il y a différentes façons de gérer ça, mais une façon est de créer une liste chaînée à cette position du tableau, ce qui rend la recherche de cette valeur un peu plus lente, mais quand même, les HashMaps sont incroyablement utiles car tu peux définir les clés qui pointent vers chaque valeur, et comme elles sont basées sur des tableaux, les récupérer est extrêmement rapide. Pour de nombreux problèmes, il peut être très utile de représenter la relation entre différents points de données comme une structure de données. Si tu prends les nœuds d'une liste chaînée, mais que tu permets à n'importe quel nœud de pointer vers n'importe quel autre nœud, tu obtiens un graphe, où les nœuds sont reliés par des arêtes qui peuvent être orientées, non orientées, et peuvent même porter un poids, qui peut représenter n'importe quelle métrique, comme une distance ou un coût. Les graphes sont utiles pour analyser des groupes au sein de réseaux ou trouver le chemin le plus court entre deux points, par exemple dans Google Maps. Il y a deux façons principales de parcourir un graphe. La recherche en largeur commence à un nœud et se propage couche par couche jusqu'à trouver le nœud cible pour la première fois. La recherche en profondeur explore chaque chemin entièrement jusqu'à atteindre une impasse, puis revient au dernier nœud avec un autre chemin et continue de la même façon jusqu'à trouver le nœud cible. Un graphe où deux nœuds quelconques sont reliés par exactement un chemin s'appelle un arbre et représente une hiérarchie, par exemple le système de fichiers de ton ordinateur. Un arbre commence à la racine et se ramifie en sous-arbres qui se terminent par des nœuds feuilles. Les nœuds parents peuvent avoir n'importe quel nombre de nœuds enfants, mais souvent les arbres binaires sont les plus utiles. Par exemple, un arbre binaire où toutes les valeurs à gauche de n'importe quel nœud sont plus petites et toutes les valeurs à sa droite sont plus grandes s'appelle un arbre de recherche binaire, ce qui rend la recherche de valeurs spécifiques super rapide. Si tu veux trouver une valeur cible, commence simplement à la racine. Si la cible est plus petite que ce nœud, va à gauche, si elle est plus grande, va à droite, et répète ça jusqu'à trouver la cible. Ce qu'on vient d'utiliser est un algorithme très simple, qui n'est qu'un ensemble d'instructions qui résout un problème étape par étape. La façon la plus simple d'écrire un algorithme est sous la forme d'une fonction. Elle prend des entrées, fait quelque chose avec, et renvoie une sortie. Tout comme les variables, tu peux ensuite appeler une fonction par son nom et lui passer différents arguments. Lors de l'appel d'une fonction, l'appel de fonction est empilé sur la pile d'appels, qui est une mémoire à court terme utilisée pour exécuter du code, et comme son nom l'indique, elle est basée sur une structure de données de pile, ce qui signifie dernier entré, premier sorti. Pour implémenter des algorithmes, tu dois souvent comparer deux valeurs, ce que tu peux faire avec des opérateurs comme supérieur à ou égalité, et des expressions logiques telles que et, ou, et non. Des expressions comme celles-ci sont simples, elles peuvent être vraies ou fausses, qui sont les valeurs possibles du type de données booléen et te permettent d'écrire des instructions conditionnelles. Si une condition est vraie, fais ceci, sinon fais cela. Les booléens peuvent aussi être utilisés pour boucler sur certaines parties du code. Une façon est avec une boucle while. Tant que cette condition est vraie, ce code s'exécutera. Une autre façon est avec une boucle for, qui peut itérer sur chaque élément à l'intérieur d'une structure de données comme un tableau, mais peut aussi boucler un nombre spécifique d'itérations en définissant une valeur de départ, en l'incrémentant après chaque itération, et en définissant une borne supérieure avec une condition. Les fonctions peuvent aussi s'appeler elles-mêmes, ce qu'on appelle la récursivité. C'est utile quand un problème peut être décomposé en problèmes identiques plus petits, comme calculer la factorielle de 5, qui n'est que 5 fois la factorielle de 4, qui n'est que 4 fois Mais, par défaut, une fonction récursive va juste continuer à s'appeler indéfiniment. Ça signifie qu'elle continue d'empiler plus d'appels de fonction sur la pile d'appels jusqu'à ce que la mémoire de la pile soit dépassée dans un débordement de pile. Ce n'est pas optimal. Pour arrêter ça, tu dois ajouter une condition de base à une fonction récursive qui définit quand s'arrêter. C'est seulement alors que les appels de fonction seront exécutés sans faire planter ton PC. La récursivité c'est cool, mais ça peut être assez coûteux en temps et en espace. Donc, pour minimiser la quantité de calculs nécessaires, les résultats passés peuvent être sauvegardés dans un cache pour que, s'ils réapparaissent, l'ordinateur n'ait pas à les recalculer depuis zéro. C'est ce qu'on appelle la mémoïsation. En parlant de performance, pour juger de la qualité d'un algorithme, tu peux regarder la complexité en temps et en espace, donc combien de temps ou d'espace est nécessaire pour l'exécuter. C'est mesuré en notation Grand O, qui décrit la relation entre la croissance de la taille de l'entrée et le nombre d'opérations nécessaires pour exécuter l'algorithme. Par exemple, ajouter 1 à chaque nombre à l'intérieur d'un tableau est O , parce que le nombre d'opérations augmente de façon linéaire à mesure que le tableau grandit. Ce qui est pertinent n'est pas le nombre exact d'opérations, mais plutôt la tendance quand la taille de l'entrée tend vers l'infini. Tu vois, quelque chose comme n factorielle grandit bien plus vite que n'importe quelle fonction linéaire ne pourrait jamais le faire. Donc tant que la complexité en temps est une sorte de relation linéaire, elle est simplifiée en O , et la même chose vaut pour tout autre groupe. Quand on écrit un algorithme, il y a toujours différentes approches. Une approche par force brute serait de simplement vérifier chaque élément jusqu'à trouver une cible dans une liste. Mais si tu veux que ton programme tourne plus vite qu'un escargot de jardin, tu as besoin d'une approche plus sophistiquée comme diviser pour régner. Par exemple, dans la recherche binaire, tu vérifies répétitivement l'élément du milieu pour voir de quel côté se trouve la cible et tu continues à chercher dans cette moitié jusqu'à la trouver. Il y a aussi différentes approches pour écrire du code en général, qu'on appelle des paradigmes de programmation. La programmation déclarative décrit ce que fait le code mais pas comment exactement l'ordinateur doit le faire, tandis que la programmation impérative décrit explicitement comment l'ordinateur doit atteindre un résultat avec des instructions détaillées. Une extension de la programmation impérative est la programmation orientée objet, où tu peux définir des classes comme des plans pour des objets, qui sont des unités uniques constituées de données sous forme de propriétés et de comportements sous forme de méthodes. Pour coder une classe, tu commences par définir les propriétés comme variables et les méthodes comme fonctions. Après avoir encapsulé les propriétés et les méthodes dans une classe, tu peux instancier un objet et utiliser la notation point pour manipuler ses propriétés et méthodes. Les classes facilitent l'organisation et la réutilisation du code, parce que tu peux définir des sous-classes qui héritent des propriétés et comportements d'une super-classe mais peuvent aussi les étendre et les redéfinir. Par exemple, une sous-classe canard en caoutchouc pourrait implémenter quack avec un couinement à la place. En conséquence, les canards en caoutchouc peuvent être traités comme des objets de la classe canard mais se comportent différemment quand quack est appelé, c'est le concept de polymorphisme. Mais pour certains problèmes, aucun de ces paradigmes traditionnels ne fonctionnera. Disons que tu veux faire en sorte qu'un ordinateur reconnaisse laquelle de ces images est une abeille. Le problème, c'est que tu ne peux pas vraiment décrire à quoi ressemble une abeille avec du code. C'est là qu'intervient l'apprentissage automatique, c'est-à-dire apprendre à un ordinateur à faire une tâche sans le programmer explicitement pour faire cette tâche. D'abord, tu as besoin de beaucoup de données que tu peux diviser en données d'entraînement et données de test. Ensuite, tu choisis un algorithme qui peut changer ses paramètres au fil du temps, par exemple un réseau de neurones où les poids peuvent être mis à jour pour obtenir un résultat différent. En alimentant cet algorithme avec énormément de données d'entraînement, tu peux construire un modèle dont tu peux ensuite vérifier la précision avec les données de test. Si ce n'est pas tout à fait juste, le modèle peut s'améliorer au fil du temps en comparant la sortie à ce qu'elle aurait dû être, en capturant la différence dans une fonction d'erreur et en ajustant ses paramètres pour minimiser la différence. Mais peu importe à quel point c'est futuriste, à la pointe, extrêmement rapide et optimisé, si tu veux que les gens utilisent réellement l'application que tu as écrite, tu devrais probablement connaître Internet. C'est un réseau d'ordinateurs du monde entier connectés par des câbles. Genre, littéralement, Internet n'est qu'un tas d'épais câbles qui courent au fond de l'océan ainsi que des installations comme les fournisseurs d'accès Internet qui te connectent à ta destination. Ces ordinateurs communiquent avec la suite de protocoles Internet. Chaque ordinateur sur le réseau a une adresse IP unique, et deux ordinateurs peuvent ensuite transférer des données avec un protocole de contrôle de transmission. Il découpe le message en un tas de paquets, les envoie à travers un réseau de câbles, avant que le destinataire ne remette le message ensemble. Si tu as une mauvaise connexion Internet, tu as peut-être connu la perte de paquets, qui est juste le fait que certains de ces paquets se perdent en route. Si Internet est le matériel, alors le web est le logiciel, que tu peux utiliser avec un navigateur. Chaque page sur le web a une URL. Quand tu la tapes dans ton navigateur, il recherche l'adresse IP du serveur hébergeant ce site avec un système de noms de domaine, qui est comme un dictionnaire faisant correspondre les noms de domaine aux adresses IP des serveurs réels. Après s'être connecté à lui via TCP, ton navigateur, appelé le client, utilise le protocole de transfert hypertexte pour envoyer une requête HTTP au serveur, qui donne ensuite une réponse, idéalement contenant le contenu de la page web. Le site web réel se compose le plus souvent de trois parties. Un fichier HTML contient tout le contenu d'un site web et n'est en gros qu'une collection d'éléments, qui peuvent être du texte, des liens, des boutons, etc. Un fichier CSS contrôle le visuel et rend un site web joli. Mais un site web est inutile si appuyer sur de jolis boutons ne fait rien, donc un langage comme JavaScript ajoute des fonctionnalités. Mais parfois, les choses peuvent mal tourner. À chaque réponse HTTP est associé un code de réponse, qui porte des informations sur le statut de la réponse. Par exemple, 200 signifie OK, et tout ce qui commence par 4 est une erreur, la plus célèbre étant 404, page introuvable. Les requêtes HTTP peuvent porter différentes méthodes, par exemple get, post, put et delete, donc récupérer, ajouter, mettre à jour et supprimer des informations. Celles-ci sont souvent utilisées par les interfaces de programmation d'applications, qui connectent deux applications et leur permettent d'interagir entre elles. Par exemple, stocker et récupérer des données depuis une base de données. Le type de base de données le plus courant est une base de données relationnelle, qui utilise des tables pour stocker des données. Les colonnes d'une table contiennent différents attributs, et les lignes représentent des points de données individuels. De plus, chaque table a un attribut unique appelé clé primaire. Une clé étrangère est la clé primaire d'une autre table, établissant une relation entre les deux. Dans ce cas, chaque livre est relié à un auteur. Avec un langage comme SQL, tu peux écrire des instructions pour manipuler les données de ces tables. Tu pourrais rechercher les titres et auteurs de tous les livres dont le titre commence par un H, mais pour ça on doit joindre la table des auteurs avec la table des livres sur la clé correspondante pour combiner deux attributs de différentes tables en un seul, ce qui nous donne cette sortie. Ces instructions sont utiles, mais il faut faire attention ou tu pourrais juste supprimer une base de données entière avec une ligne de code. Mais ne t'inquiète pas, ça n'est jamais arrivé. Derrière chaque page de connexion se trouve une base de données avec des noms d'utilisateur et des mots de passe. Quand un utilisateur essaie de se connecter, une requête SQL est souvent utilisée pour vérifier si l'entrée de l'utilisateur correspond à une entrée dans la base de données. C'est bien. Mais un acteur malveillant pourrait taper quelque chose comme ceci, qui modifie la requête en terminant la chaîne plus tôt et en commentant le reste, ce qui signifie que tant que ce nom d'utilisateur existe dans la base de données, l'accès est accordé. C'est ce qu'on appelle une attaque par injection SQL, et c'est l'une des façons les plus simples pour les hackers d'accéder à des endroits où ils ne sont pas censés aller. Entendre parler de ces concepts, c'est une chose, mais pour vraiment les apprendre, tu dois les voir en action et les utiliser toi-même, ce que tu peux exactement faire avec Brilliant, qui propose des milliers de leçons interactives pour tout, des mathématiques et de la science des données à la programmation et l'IA. Ils font que les connaissances restent, avec des leçons visuelles et des problèmes interactifs, ce qui est non seulement amusant et développe des compétences intuitives de résolution de problèmes, mais aussi prouvé être six fois plus efficace que de simplement regarder des heures de cours. Je sais que trouver le temps d'apprendre de nouvelles compétences peut être difficile, mais Brilliant rend ça tellement facile. Tu peux construire des connaissances précieuses depuis la base en seulement quelques minutes par jour, avec des leçons courtes depuis n'importe quel appareil, n'importe où, n'importe quand. Tu passeras des bases de la science des données à l'analyse de vrais jeux de données de Spotify en un rien de temps, ce que tu peux compléter avec des cours fondamentaux de mathématiques et de programmation en Python pour construire l'un des ensembles de compétences les plus recherchés de notre époque. Le meilleur ? Tu peux essayer tout ce que Brilliant a à offrir gratuitement pendant 30 jours complets en visitant brilliant.org slash wackyscience. Tu bénéficies aussi de 20 % de réduction sur un abonnement premium annuel. Merci à Brilliant d'avoir sponsorisé cette vidéo.