DokuWiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Unité 3 : Algorithmes et programmation ======

[[https://curriculum.code.org/csp/unit3/|source]]

===== Chapitre 1 : langages de programmation et algorithmes =====

Cette unité introduit les concepts fondamentaux de la programmation, qui ouvrent la capacité à créer des application interactives riches. Ce cours utilise JavaScript comme langage de programmation, et App Lab comme environnement de programmation pour créer des applications, mais les concepts appris pendant ces leçons se retrouvent dans tous les langages et outils de programmation.

=== grandes questions ====

  - pourquoi avons-nous besoin d'algorithmes ?
  - En quoi la conception d'un algorithme pour résoudre un problème est-elle différente d'autres types de résolution de problème ?
  - Comment conçevoir une solution à un problème de manière à ce qu'elle soit programmable ?
  - Qu'est-ce que cela signifie d'être un programmeur "créatif" ?
  - Comment les programmeurs collaborent-ils ?

=== notions à long terme ====

  - 1.1. Le développeent créatif est un processus essentiel pour créer des oeuvres numériques.
  - 1.2. L'ordinateur permets d'utiliser des procéssus de développement créatufs pour créer des oeuvres numériques pour expression créatives ou la résolution de problèmes.
  - 2.2. De multiples niveaux d'abstraction sont utilisés pour écrire des programmes et d'autres oeuvres numériques.
  - 4.1. Les algorithmes sont des séquences précises d'instructions pour des processus qui peuvent être exécuté par un ordinateur et son implémentés en utilisant des langages de programmation.
  - 5.1. Les programmes peuvent être développés pour l'expression créative, pour satisfaire la curiosité personnelle, ou pour résoudre des problèmes (pour aider des personnes, des organisation ou la société).
  - 5.2. Les personnes écrivent des programmes pour exécuter des algorithmes
  - 5.3. La programmation est facilitée par des abstractions appropriées.

==== semaine 1 ====

=== leçon 1 : la nécéssité des langages de programmation ===

On passe dès le début de l'unité à une activité pratique : créer un petit assemblage de blocs légo et créer des instructions texte qu'un camarade de classe peut suivre pour créer le même arrangement. Les groupes échangent ensuite les instructions pour voir si elles étaient suffisamment claires pour permettre la reconstruction de l'arrangement de départ. La discussion wrap-up est utilisée pour mettre en lyumière les ambiguïtés inhérentes du langage humain et rappeler la nécessité de créer un langage de programmation qui ne laisse aucune place à l'interprétation.

  - liens prof : qcm, vidéo
  - liens étudiants :guide d'activité x2

=== leçon 2 : la nécéssité des algorithmes ===

C'est le second jour d'une séquence de trois leçons dans lesquels l'on montre "l'art" de la programmation et introduisons des connections entre la programmation et les algorithmes. Dans la leçon précédente, nous avons établit la nécessité d'un langage commun dans lequel exprimer des algorithmes pour éviter toute ambiguïté sur comment les instructions pourraient être interprétées. Dans cette leçon nous allons continuer à établir des connections entre la programmation et les algorithmes, avec plus d'emphase sur "l'art" de l'algorithmie.

  - liens prof : qcm, answer key x2
  - liens étudiants : guide d'activité x2

=== la créativité dans les algorithmes ===

mots-clés (?) : Concept Invention | Unplugged | Algorithms

C'est la dernière des trois leàons qui font la connection entre la programmation et les algorithmes. Dans cette leçon les étudiants continuent de travailler avec le "human machine language" (langage de la machine humain ?) pour créer davantage d'algorithmes pour des cartes à jouer. Une commande est ajouter au langage des précédentes leçons (SWAP : échange) qui autorise la position des carte à changer. Avec l'ajout de l'échange, le défi est de concevoir un algorithme qui positionnera la carte au début de la liste tout en gardant le même ordre pour toutes les autres cartes. Si cela est achevé, d'autres défis Human Machine Langage sont disponibles.

  - liens prof : qcm
  - liens étudiants : vidéo, guide d'activité

==== semaine 2 ====

=== leçon 4 : utiliser des commandes simples ===

== programmation "tortue" ==

Cette leçon est la première exposition de l'étudiant à l'environnement App Lab. App Lab est inclut dans Code Studio, et pour cette leçon l'étudiant est limité à seulement quelques commande "tortue" permettant de dessiner à l'écran. Après quelques exercices d'échauffement, en utilisant uniquement des cominaisons de quatre commandes, les étudiants doivent se demander quelle est la manière la plus "efficace" de dessiner une grille de 3 par 3. Bien que l'attention de l'étudiant doivent se focaliser principalement sur solutionner le problème à la main, les étudiants se familiarisent avec l'environnement de programmation qu'ils utiliseront pour le reste du cours. L'environnement est intentionnelement réduit au minimum à ce point, les nombreuses fonctionnalités d'App Lab seront graduellement révélées au fur et à mesure du temps.
  - liens prof : qcm
  - liens étudiants : vidéo

=== leçon 5 : créer des fonctions ===

== programmation "tortue" ==

Dans cette leçon, les étudiants apprennent à définir et appeler des procédures (en JavaScript, ces procédures sont appelées "fonctions") afin de créer et donner un nom à des groupes de commandes pour un usage facile et répétitif dans leur code. Ils sont initiés aux fonctions sous la forme d'abstraction qui leur permet d'écrire du code par morceaux plus gros et logiques, et se focalisent sur ce que quelque chose fait plutôt que sur comment il le fait. Alors qu'ils explorent l'usage de fonctions au travers d'une séquence d'activité dans App Lab, il leur est demandé de penser où ils voient le besoin de fonctions et comment ces fonctions peuvent rendre leur code plus clair et concis.

  - liens prof : qcm
  - liens étudiants : vidéo

=== leçon 6 : fonctions et conception top-down ===

== programmation "tortue" ==

Cette leçon présente une stratégie de résolution de problème top-down pour conçevoir des solutions à des problèmes de programmation. Les étudiants utilisent une feuille d'exercices pour s'initier à la conception top-down, puis sur un papier, conçoivent avec un camarade une solution pour un nouveau défi de dessin avec la tortue. Après avoir pratiqué cette approche sur papier et en code, les étudiants se voient présenter à nouveau le défi de la grille de 3 par 3 d'une leçon précédente, et demandé d'améliorer leur ancienne solution en concevant plusieurs couches de fonctions.

  - liens prof : qcm
  - liens étudiants : feuille d'exercices

==== Semaine 3 ====

=== leçon 7 : APIs et utilisation de fonction avec des paramètres ===

Les étudiants vont apprendre à lire la documentation de l'API d'App Lab et utiliserons des fonctions qui vont accepter des paramètres de manière à compléter des séries de de puzzeles qui requierent qu'ils utilisent la documentation de l'API d'App Lab pour apprndre de nouvelles commandes de dessin. La plupart de ces commandes requièreront l'usage de paramètres. Le défi final demande aux étudiants de conçevoir un monogramme personnel en utilisant les commandes qu'ils auront appris pendant la leçon.

  - liens prof : qcm

=== leçon 8 : créer des fonctions avec des paramètres ===

Dans cette leçon, les étudiants pratiquent l'utilisation et la création de fonctions avec paramètres. Les étudiants apprennent qu'écrire des fonctions avec des paramètres peut encore davantage généraliser des solutions à des problèmes. En particulier dans des situations qui semblent risquer de générer des duplication de code avec juste des petits changement dans les nombres, ce qui est une bonne situation où écrire des fonctions qui acceptent des paramètres. Dans la seconde partie de la leçon, les étudiants font une série de modification à un programme qui créé une scène "sous la mer" en ajoutant des paramètres à des fonctions pour ajouter plus facilement des variations à une scènes. Pour finir, les étudiants sont initiés à la fonction de génération de nombre aléatoire pour que la scène varie légèrement à chaque génération.

  - liens prof : qcm
  - liens étudiants : vidéo

=== leçon 9 : boucle et nombres aléatoires ===

== programmation "tortue" ==

Les étudiants apprennent à utiliser des valeurs aléatoires et à boucler pour créer des variations dans leur dessin et dépliquer rapidement des objets qu'ils veulent faire apparaître de nombreuses fois dans leurs scènes numériques. Les étudiants se verrons présenter une version de la boucle for qui leur permet seulement de changer le nombre de fois que la boucle s'éxécute. Ce bloc est en gros un bloc "répéter" et sera présenter de cette manière. Les étudiants se verrons présenter des blocs qui leur permettent de créer des fonds plus complexes pour leurs scènes en placant au hasard des objets simples à l'arrière de leur scène. Les étudiants utiliserons ces outils au travers de l'exemple de la scène d'exemple "sous la mer".

  - liens prof : forum
  - liens étudiants : vidéo

==== semaine 4 ====

=== leçon 10 : pratique PT : concevoir une scène numérique (a digital scene) ===

== programmation "tortue" ==

Pour conclure leur introduction à la programmation, les étudiants devonrs concevoir un programme qui dessins une scène de leur choix. Les étudiants travaillerons en groupes de 3 ou 4 et commençerons pas décider de ce qu'ils veulent représenter. Ils utiliserons ensuite une conception top-down pour identifier les fonction de haut niveau nécéssaires pour créer leur image. Ce groupe assignera alors aux membres du groupe la tâche individuelle de programmer différents composants. Après avoir programmer leur tâche individuelle, les étudiants combinerons leur code pour composer la scène entière. Le projet se conclut avec des questions de réflecion similaires à celles que les étudiants verront dans leurs AP Performance Tasks.

  - liens prof : qcm

===== Commentaire sur le chapitre =====

==== contenu et stratégies d'enseignement ====

Ce chapitre à deux stratégies basiques d'enseignement qui peuvent paraître très différentes : des activitées débranchées qui sont très kinesthésiques et interactives, suivies par le premier apprentissage de la programmation avec App Lab.

On utilise des activitées débranchées pour introduire les algorithmes pour mettre en avant la connection entre algorithles, langages de programmation, et la programmation elle-même. Ces activités impliquent la classe entière sous forme de petits groupes à résoudre des problèmes simples en utilisant des cartes à jouer et des légos.

On commence alors à utiliser l'environnement de programmation App Lab pour apprendre les concepts de la programmation au travers de la programmation "tortue". La tortue est un personnage qui se déplace dans l'écran et peut dessiner. Dans ces leçons les étudiants apprennent les fonctionnalités du langage JavaScript à travers une série de courts tutoriels pour se familiariser avec l'environnement et les nouveaux concepts. Tipiquement, chaque leçon de programmation se termine avec un projet créatif plus ouvert ou un problème ou les étudiants peuvent appliquer ce qu'ils ont appris. Même si cela est parfois forcé par la leçon ou le problème lui-même, il est recommandé de faire travailler vos étudiants par pairs, ou avec un "copain de programmation", au moins autant qu'ils travaillent de manière individuelle. Non seulement nous souhaitons nous inscrire dans une compréhension durable (1.1. et 1.2.) sur la collaboration et la créativité, mais cela vous aidera aussi à gérer votre classe (voir plus bas).

En terme de contenu, il y a trois choses que nous sortons de ce chapitre.

=== langages de programmation et algorithmes ===

Nous souhaitons construire autour de la compréhension doule que : (4.1) **Les algorithmes sont des séquences précises d'instructions pour des processus qui peuvent être exécutées par un ordinateur**, et que (5.2.) **Les personnes écrivent des programmes pour exécuter des algorithmes**. Alors que les étudiants peuvent être familiers avec certains algorithmes ou procédures pour résoudre des problèmes de tous les jours (par exemple faire un sandwich, lacer une chaussure), conçevoir des algorithmes pouvant être exécutés par un ordinateur demande quelques connaissances et un manière différente de penser étant donné le fait qu'au final, un ordinateur n'est qu'une machine qui peut faire un nombre limité de choses. Dans les trois premières leçons nous utilisons les activités déconnectées pour mettre en lumière les connections entre algorithmes, langage humain et langages de programmations. Les étudiants doivent écruire des algorithmes pour résoudre des problèmes avec des cartes en guise de "données" pour monter comment décrire une solution à une machine pour résoudre un problème peut être créatif et un défi en soi. Les connaissances à avoir sont que les langages de programmation et les ordinateurs sont en réalité des outils très simples (comme un pinceau et une toile) mais que même en travaillant avec leurs contraientes inhérentes l'on peut être créatif, s'exprimer, et construire des choses plutôt compliquées.

=== décomposition de problème top-down et apprentissance de l'écriture de fonctions ===

=== abstractions procédurales (fonctions) ===

==== pourquoi le faire de cette manière ? Et le rôle de l'enseignement ====

=== apprendre les algorithmes "débranchés" ===

=== Pourquoi limiter initialement les commandes de la tortue - dans quel but ? ===

=== enseigner avec Code Studio et App Lab ===