Quelques pistes pour l'organisation du cours de NSI en Première

I. Rappel de la structure officielle

  1. Histoire de l'informatique
  2. Représentation des données : types et valeurs de base (entiers, réels, booléens, chaînes de caractères)
  3. Représentation des données : types construits (tuples, tableaux, dictionnaires)
  4. Traitement des données en tables (préparatoire aux bases de données, vues en terminale)
  5. Interactions entre l’homme et la machine sur le web : distinguer partie statique (html) dynamique côté client (javascript) et dynamique côté serveur ; transmission de paramètres client → serveur
  6. Architectures matérielles et systèmes d’exploitation : structure d’un ordinateur, circuits combinatoires, protocoles réseau, systèmes d’exploitation, périphériques
  7. Langages et Programmation : structures de contrôle classiques, typologie et diversité des langages, préconditions et post-conditions, tests, utilisation d’une bibliothèque et de sa documentation
  8. Algorithmique : présentation de quelques algos classiques, complexité, preuve de terminaison

A priori, 100 heures réparties sur 8 sujets : 12,5 heures/sujet.

II. Suggestion de décomposition horaire

Le tableau suivant donne une idée de la répartition en volume horaire ; il ne s'agit pas d'un planning à suivre. Par exemple, la partie "Histoire de l'informatique" peut tout à fait, comme cela est d'ailleurs suggéré dans le programme, être en partie répartie sur l'année au fur et à mesure de l'introduction de certains concepts.

bloctitrevolume horaireDétails
1Algorithmique et programmation de base32h
  1. Représentation des données : types et valeurs de base ; opérateurs sur les données simples en Python
  2. Structures de contrôle de base, variable et nommage des variables
  3. Représentation des données : types construits
  4. Algos de base sur les tableaux, complexité
  5. Fonctions, pré et post conditions, structures de contrôles avancées, tests
2Histoire de l'informatique4h

Le volume horaire peut éventuellement être réduit, dans la mesure où ce thème se retrouvera a priori dans le programme de Terminale. Il faut donc trouver une façon de segmenter les choses. Le programme suggère que ces aspects soient abordés au fur et à mesure de leur rencontre dans le cadre des autres points abordés. Cela risque de mener à quelque chose de difficile. Je suggèrerais plutôt la chose suivante :

  • En Première, les grandes dates, puis détailler -> 1970
  • En Terminale : de 1970 à nos jours
3Architectures matérielles16h
  1. Structure d'un ordinateur (ne pas détailler carte mère et microprocesseur, vus en Terminale)
  2. Circuits combinatoires et assembleur
  3. Périphériques
  4. Systèmes d'exploitation (gestion des ressources et processus vues en Terminale)
  5. Réseaux
4Applications Web16h
  1. Structure d'une page : HTML
  2. Mise en forme : CSS
  3. Aspect dynamique côté client : javascript
  4. Interaction client/serveur : protocole HTTP, passage de paramètres
5Algorithmique avancée16h
  1. Démarche de programmation (spécification, tests, démarche ascendante et descendante, développement, débuggage, qualité de code)
  2. Algorithmes avancés
  3. Preuve de terminaison
6Traitement de données en tables16h
  1. Lecture de fichiers en Python
  2. Notion de cohérence dans une table
  3. Algorithmes de base (recherche, tri)

III. Suggestion d'organisation

A. Travail sur projet(s)

1. Organisation

Il est demandé que le quart du volume horaire soit consacré à des projets. Comme la réalisation d'un projet nécessitera d'avoir déjà quelques compétences en algorithmique, il n'est pas pensable de commencer des projets trop tôt. Par ailleurs, bloquer une longue période pour une réalisation de projet risque de plutôt perdre les élèves. Deux façons de procéder peuvent être envisagées :

Un seul et unique projet
En fonctionnant ainsi, il s'agira d'un projet d'environ 35 heures. Je suggère alors de consacrer environ 2h par semaines à partir de la moitié de l'année au projet. Le risque est d'avoir un sentiment profond d'échec si cela ne mène finalement à rien de satisfaisant.
2 projets
Dans ce cas, le premier projet devra être un projet relativement court (8h), d'initiation à la démarche projet et de concrétisation des premiers apprentissages. Il pourra se dérouler vers la fin du premier semestre. Le deuxième projet sera quant à lui un projet plus long (27h), qui permettra d'aboutir à une application plus fonctionnelle.

2. Sujet de projet

Le sujet d'un projet dans le cadre d'un enseignement de lycée doit être un projet motivant pour l'élève, et faisable avec le temps imparti et les connaissances de l'élève. Je suggère donc que les élèves soient libres de choisir parmi une liste proposée par l'enseignant. Le fait de laisser les élèves proposer leur propre sujet en première est un choix de l'enseignant, mais il est impératif de vérifier la faisabilité d'un sujet proposé par les élèves, et d'expliquer la non faisabilité le cas échéant.

Les sujets proposés peuvent être pris dans différents domaines :

Plus il y aura de sujets, plus il y a de chances que les élèves trouvent un sujet qui les motive. Ne pas hésiter à travailler en réseau pour partager des idées de projet.

3. Démarche pour mener le projet

Afin d'éviter l'échec, utiliser une démarche itérative, et pourquoi pas Agile, est nécessaire.

Réunion de lancement

Le lancement d'un projet devra consister en une première séance pour déterminer notamment :

Cette réunion doit notamment permettre d'établir une priorité des fonctionnalités à implanter, par exemple en essayant de maximiser le retour sur investissement : importance/charge. Par ailleurs, cette réunion peut être l'occasion de réfléchir à l'architecture générale de l'application et à une première répartition des tâches. Enfin, la réunion doit se terminer par une affectation des fonctionnalités à implanter pour la semaine suivante à chacun des membres du projet.

Par la suite, chaque séance doit commencer par une réunion-bilan sur le travail fait par rapport à ce qui était à faire (10 minutes), et une nouvelle répartition de tâches pour la semaine à venir.

4. Évaluation du projet

Évaluer un projet est un problème toujours compliqué. Dans l'idéal, une évaluation devrait reposer sur :

Il est préférable de ne pas être trop ambitieux sur les fonctionnalités à implanter et de privilégier la qualité du travail.

B. Évaluation

Le problème de l'évaluation en informatique est un problème difficile. Les personnels enseignant l'informatique depuis des années dans le supérieur continuent de se poser des questions sur le sujet.

Une évaluation purement théorique est loin d'être satisfaisante. Travailler sur machine est une compétence essentielle de la discipline, et celle-ci doit être prise en compte.

Toutefois, l'évaluation sur machine reste un problème compliqué :

Le choix fait par le ministère pour évaluer les élèves qui arrêtent la spécialité à la fin de la première est celui d'un QCM. C'est un choix que j'estime plutôt judicieux, même si au final on aura du mal, je pense à estimer ainsi à quel point le cours a développé la "pensée informatique" des élèves.

L'utilisation des QCM dans le cadre du cours permet d'effectuer une partie de l'évaluation. Il est tout à fait possible, dans des QCMs, de demander de l'évaluation de code, ou d'élargir le QCM à des questions à trous. L'avantage d'évaluer via un QCM est que cela permet de reconnaître le travail des élèves qui ont assimilé les concepts, mais qui ont encore du mal avec la pratique.

Dans le cadre des évaluations de cours, par contre, évaluer du code produit par les élèves restent indispensable. Le barème doit alors être clair dès le départ et suffisamment détaillé pour qu'il n'y ait quasiement qu'une façon de noter une copie donnée (même si, à chaque fois, on tombera sur des cas non prévus)

C. Structure des cours

Comme cela a déjà été exposé, il est important de varier la structure des cours. Toutefois, les objectifs d'un cours doivent être clairs non seulement pour l'enseignant, mais également pour l'élève. Par contre, pour ce dernier, suivant les cas, il est possible de ne lui présenter les objectifs qu'a posteriori, une fois qu'il a assimilé ce dont il s'agissait.

IV. Quelques structures de cours envisageables

A. Exploration en mode "informatique débranchée"

1. Présentation générale

Ce type de cours permet de mener assez facilement des apprentissages suivant la théorie des situations didactiques. On commence par faire manipuler aux élèves des objets concrets pour les amener à formuler des règles. C'est aussi une façon d'introduire des métaphores qui aideront à la compréhension et qui resteront.

L'enseignant intervient très peu au cours de la séance. par contre, il peut reprendre la main au moment de la formalisation, puis relancer une série d'execices dans le système formalisé.

Une séance de 2 heures peut être décomposée ainsi :

Bien sûr, ces temps ne sont donnés qu'à titre indicatifs. Dans certains cas, il faudra laisser beaucoup plus de temps à l'exploration, tandis que dans d'autres, on souhaitera diviser par 2 les temps indiqués.

2. Exemples d'utilisation

a. Les concept de variable informatique et d'affectation

Comme cela a déjà été dit, ces 2 concepts sont plus compliqués qu'il n'y paraît, pour plusieurs raisons :

Même si ce concept est sensé avoir déjà été assimilé au collège, y revenir peut s'avérer nécessaire, surtout que s'ils n'ont vu la programmation que via Scratch, ils n'auront pas écrit x = x + 1 mais : affectation en sratch, ce qui n'a pas grand chose à voir.

Présenter des boîtes nommées et des cartes représentant des chiffres est une façon d'aider, en mode débranché, à intégrer les notions de variable et d'affectation. On peut amener les élèves à écrire des "instructions" un peu lourde au départ, puis à simplifier leur écriture progressivement :

  1. stocker dans boîte bleue la valeur contenue dans boîte rouge
  2. stocker dans bleue la valeur contenue dans rouge
  3. bleue reçoit la valeur contenue dans rouge
  4. bleue reçoit rouge
  5. bleue ← rouge
  6. bleue = rouge

Quand on leur demande ensuite de formaliser "augmenter la valeur stockée dans la boîte bleue de 1" (stocker dans boîte bleue la valeur contenue dans boîte bleue + 1) et d'effectuer la même suite de transformations, il y a de fortes chances qu'ils trouvent toute naturelle l'écriture bleue = bleue + 1.

b. Les concept de référence et de tas

On organise la classe en groupes de 5. Et pour chaque groupe, on prépare 4 exemplaires d'un même texte. l'élève A est au départ le seul à posséder le livre. l'élève B joue le rôle de photocopieuse et reçoit les 3 autres exemplaires. Le but est que les les élèves C, D et E puissent avoir au contenu du livre sans déranger A.

On envisage un premier cas de figure : lorsqu'un élève veut disposer du texte, il va à la "photocopieuse" (B) qui, au bout d'une minute (cela prend du temps de photocopier) remet la copie à l'élève.

Au cours du scenario, on envisage ce qu'il se passe en cas de modification du document par B après qu'il a récupéré sa copie, ou par A après que tous les autres élèves ont récupéré leur copie.

À la fin du scenario, on compare les textes de chacun, le "temps" pris par le scenario, et le nombre de feuilles utilisées

On envisage un deuxième cas de figure : le document, numéroté, est posé sur un bureau parmi d'autres documents numérotés. Quand un élève veut disposer du document de A, A lui donne juste le numéro du document

Comme dans le cas précédent, on envisage des modifications du document par l'un ou l'autre des propriétaires.

À la fin du scenario, on refait les mêmes évaluations que dans le premier cas

On termine par un dernier cas : on a plusieurs documents, et chacun les appelle comme il veut.

On peut ensuite illustrer tout cela avec Python Tutor, comprendre ce qui est géré par valeur et ce qui est géré par référence en Python, et finir en faisant faire des schémas mémoires aux élèves.

B. Apprentissage à partir de codes existant

1. Présentation générale

Dans ce type de cours, on va donner aux élèves un ou plusieurs programmes qu'il vont devoir dans un premier temps exécuter et comprendre. Dans un deuxième temps, on demandera d'apporter des modifications de plus en plus complexes aux programmes en question. Enfin, on leur demandera d'écrire de zéro un programme.

Ce format de cours peut par exemple être utilisé pour découvrir une API particulière, ou encore une façon de programmer. Les avantages sont les suivants :

2. Exemples d'utilisation

a. Découverte de la bibliothèque matplotlib

On peut commencer à donner quelques exemples de tracés faits via cette bibliothèque. Ensuite, Il devient possible de faire modifier certains programmes pour modifier les tracés (changer les couleurs, changer les axes, changer la fonction tracée, etc.) Enfin, on peut donner une figure en expliquant ce qu'elle représente, puis demander d'écrire le programme permettant d'obtenir le résultat en question.

b. Découverte du style fonctionnel pour les traitements de listes

L'idée est d'apprendre à passer du style impératif classique (avec 2 instanciations différentes dans l'exemple qui suit) : 

# déterminer le 5ème nombre pair d'une liste
from random import randint

liste = []
for i in range(0,100):
    valeur = randint(0,50)
    liste.append(valeur)

print(liste)

def reponse(liste):
    nbPair = 0;
    for valeur in liste:
        if valeur % 2 == 0:
            nbPair = nbPair + 1
        if nbPair == 5:
            return valeur
    raise NonTrouve

def reponse2(liste):
    listePairs = []
    for valeur in liste:
        if valeur % 2 == 0:
            listePairs.append(valeur)
    try:
        return listePairs[4]
    except:
        raise NonTrouve

print("A : ",reponse(liste))
print("B : ",reponse2(liste))

à un style plus fonctionnel :

  # déterminer le 5ème nombre pair d'une liste
  from random import randint
  liste = [randint(0,50) for i in range(0,100)]

  def reponse3(liste):
      try:
          return list(filter(lambda x: x % 2 == 0, liste))[4]
      except:
          raise NonTrouve

  print(liste)

  print("C : ",reponse3(liste))

Cela peut permettre d'introduire progressivement ou de mettre en pratique les notions suivantes :

C. Travail en groupe selon la méthode du puzzle

1. Présentation générale

On rappelle que ce type de cours se déroule en 2 temps :

Ce type de cours est particulièrement adapté à des domaines vastess constitués de multiples parties pouvant s'apprendre indépendamment les unes des autres.

2. Exemple d'utilisation : développement d'interfaces graphiques en Python

Entre le fait qu'il ne s'agit pas d'un sujet fondamental du cours, et la multitudes de choses différentes qui sont à connaître pour développer une interface graphique, ce sujet convient très bien ce type de travail. On peut alors découper le sujet en l'ensemble des domaines d'expertise suivant :

Le travail de restitution peut alors être de réaliser une mini application graphique, qui peut par exemple constituer en la saisie des coordonnées de 2 points, puis au dessin de ces 2 points dans un repère orthonormé via un bouton ou un item de menu.