Concrètement?#

Jusqu’ici, nous avons vu de la narration: raconter une histoire

Maintenant, voici un petit calcul mathématique :

from sympy import *
x = symbols('x')

integrate( x/(x**2+2*x+1), x)

Un peu de visualisation de données :

from ipyleaflet import Map, Marker
#center = (48.70180933810075, 362.16683685639214)
center = (48.842417580826314, 362.3446074074784)
m = Map(center=center, zoom=15)
marker = Marker(location=center, draggable=True)
m.add_layer(marker);
m

Un peu d”interaction:#

from ipywidgets import Button, IntSlider, HBox, Label 
slider = IntSlider(value=3, vmin=0, vmax=10)
button = Button(description="Click me!")
label = Label()
def on_click(event):
    label.value = str(slider.value)
button.on_click(on_click)
HBox([slider, button, label])

Un peu de programmation, avec visualisation:

from laby.global_fr import *
Laby("1b")

debut()
avance()
droite()
avance()
prend()

Exemple : transmettre des idées et des faits à via la visualisation interactive de données#

2006: TED talk Les meilleures stastistiques que vous ayez vues de Hans Rosling

Maintenant au bout des doigts des enseignants et étudiants pour explorer :

from wealth_of_nation import application
application

(tiré de la documentation de bqplot)

Exemple : Étude d’un algorithme de parcours de graphes#

%run -i graph_networkx

def parcours_visualisation(G, u):
    """
    INPUT:
    - 'G' - un graphe
    - 'u' - un sommet du graphe
    
    OUTPUT: la liste des sommets `v` de `G`
            tels qu'il existe un chemin de `u` à `v`
    """
    marked = {u} # L'ensemble des sommets déjà rencontrés
    todo   = {u} # L'ensemble des sommets déjà rencontrés, mais pas encore traités
    
    player.player.reset(copy.deepcopy(locals()))
    
    while todo:
        # Invariants:
        # - Si `v` est dans `marked`, alors il y a un chemin de `u` à `v`
        # - Si `v` est dans `marked` et pas dans `todo`
        #   alors tous les voisins de `v` sont dans dans `marked`
        v = todo.pop()
        # Observation des variables locales
        player.set_value(copy.deepcopy(locals()))
        for w in G.neighbors(v):
            
            if w not in marked:
                marked.add(w)
                todo.add(w)
                # Observation des variables locales
                player.set_value(copy.deepcopy(locals()))
        v = None
        # Observation des variables locales
        player.set_value(copy.deepcopy(locals()))
    return marked

G = examples.parcours_directed()
parcours_visualisation(G, "A")

{'A', 'B', 'C', 'D', 'F', 'G', 'H'}

player

Massivement adopté pour l’enseignement#

• Data 8: science des données pour tous les étudiants à UC Berkeley

• 500k élèves des lycées utilisant Capytale

• Livre teaching and learning with Jupyter, Barba et al.

Exemple : à Paris-Saclay#

• En Licence, Master, Doctorat, recherche, …

  • 600/1000 étudiants de L1 de la faculté des sciences

  • 8000 utilisateurs

• En Physique, Math, Info, Géosciences, Agronomie, Chimie, Médecine, STAPS, Droit, …

• Pour:

  • La programmation (un peu)

  • Le calcul
    Exemple: Méthodes Numériques en L1-L3 de physique

  • La science des données, l’IA

  • ParcourSup!

• Avec Python, C++, SageMath, R, shell, …

Bénéfices#

• Autonomie et personnalisation
  grâce à la structure narrative, à la micro-scénarisation, aux retours immédiats
  $⟹$ massification, gestion hétérogénéité

• Engagement
  grâce à l’interaction et la liberté d’exploration

• Flexibilité
  n’importe où, n’importe quand, sur n’importe quel terminal
  $⟹$ hybridation, publics empêchés

Bémols#

⚠ le flot routinier des carnets ⚠#

• Défile, défile, défile. Exécute, exécute, exécute.

• Penser?

⚠ la pagaille des carnets ⚠#

• Une feuille de papier (ou un tableau) est un dispositif très flexible:
  gribouiller, dessiner, esquisser, calculer, écrire, composer, …

• Une utilisation adéquate demande de la formation!

Les carnets ne sont pas différents!

⚠ accompagner, oui, mais pas trop ⚠#

• Ils prennent l’habitude d’être très accompagnés
  $⟹$ un peu moins débrouillards

Bonnes pratiques#

• Raconter une histoire :

  • carnets courts : un carnet = une histoire unitaire
    (favorise aussi la réutilisation)

  • Externaliser le code ne faisant pas partie de la narration
    Note: JupyterLab fournit aussi un éditeur de code raisonnable

• Micro-scénariser les activités des étudiants

  • avec une attention à la charge cognitive, au temps d’attention

  • avec des carnets préstructurés (ou pas!), au rôle bien défini

  • avec une variété d’actions: lire, essayer, expérimenter, coder, débogguer, prendre des notes, …, s’arrêter et réfléchir!

  • avec interactions et retours visuels

• Former les étudiants, les équipes pédagogiques

• Les carnets ne remplacent pas les outils spécialisés!
  IDE (programmation seule), traitement de texte (narration seule), …

Diapos interactives#

• RISE

• JupyterLab-deck (presque là)

Mini applications interactives (avec les widgets Jupyter)#

from ipywidgets import Button, IntSlider, HBox, Label
slider = IntSlider(value=3, vmin=0, vmax=10)
button = Button(description="Click me!")
label = Label()
def on_click(event):
    label.value = str(slider.value)
button.on_click(on_click)
HBox([slider, button, label])

Comment favoriser la robustesse des exercices?#

Un défi avec les exercices sur ordinateur : le diable est dans les détails!

• Mon exercice est-il vraiment faisable par mes étudiants aujourd’hui?

• Même après la dernière mise à jour?

• Même après ma retouche cosmétique?

• Mes solutions sont-elles à jour?

Avec 3 $\times$ 30 étudiants en TP : très difficile de signaler des erratum

Une pièce du puzzle#

1. Rédiger l’exercice avec solutions :

   def max(x,y):
       ### BEGIN SOLUTION
       if x > y:
           return x
       else:
           return y
       ### END SOLUTION
   

   Mais aussi: tests, notes aux enseignants, …

2. Extraire automatiquement l’exercice pour les étudiants :

   def max(x,y):
       // REMPLACER CETTE LIGNE ET LA SUIVANTE PAR VOTRE RÉPONSE
       raise NotImplementedError();
   

   Par exemple avec nbgrader.

3. Tester automatiquement la version enseignant! Par intégration continue!

4. Publier:

   • exercice

   • solution

   • solution annotée pour les enseignant

Carnets comme fichiers texte (with jupytext)#

Exemple

Vers un standard Jupyter?

• Jupyter Extension Proposal: Markdown based notebooks https://github.com/jupyter/enhancement-proposals/pull/103
  Initié lors d’un atelier Jupyter sur le format des carnets mars 2023

Texte structuré riche (avec MyST)#

Publication (avec jupyter-book ou MySTMD)#

Comment produire un site web statique depuis une collection de carnets et documents Markdown?

Documents avec Markdown / MyST / Jupyter#

Utilise la Forge, Luc!#

Par exemple «GitHub ClassRoom».

Modèle:

• l’enseignant prépare et publie un devoir comme un dépôt git

• l’étudiant télécharge le devoir (clone)

• l’étudiant dépose sont travail comme divergence (fork) de ce dépôt git

Caveat 1: protection des données personnelles#

Caveat 2: intégration avec le système d’information de l’institution#

Solution: utiliser une forge déployée sur site#

Par exemple: GitLab

Caveat 3: la gestion de version et les forges, c’est trop compliqué pour les étudiants!#

Solution: automatiser l’interaction avec Git et GitLab!#

Travo à la rescousse!

L’interface basique pour les étudiants#

Télécharger le devoir :

    travo fetch https://gitlab.com/travo-cr/demo-assignment.git

Déposer le devoir :

    travo submit demo-assignment

L’interface graphique pour les étudiants#

from course import course
course.student_dashboard()

Propriétés#

• Un espace de stockage collaboratif partagé

• Avec authentification et gestion des droits

• Avec traçabilité forte (gestion de version: git)

• Conçu pour héberger du code

• Conçu pour la collaboration

• Conçu pour gérer des processus

• Très grande souplesse d’utilisation:

  • Interface web riche

  • Automatisation via API

Cas d’usage#

• Gestion des devoirs

• Édition collaborative du matériel pédagogique

• Édition, production et hébergement site web du cours

• Discussions pédagogiques par tickets

• Interactions étudiants par tickets?

Testé sur le terrain#

• Trivial à utiliser pour les étudiants

• Testé sur des cours à toute échelle (10-250 étudiants) à tous les niveaux

Fonctionnalités riches#

• équipes pédagogiques, groupes étudiants, sessions, travail de groupe, gestion des droits, …

• soutien l’autocorrection par intégration continue, la détection de plagiat

• intégration avec Jupyter et nbgrader

• toute la puissance de la gestion de version et des forges!!!

Léger, flexible, modulaire, extensible, soutenable, distribué, respectueux des données personnelles#

• Juste une petite bibliothèque Python

• API shell, API Python, interface Jupyter

• S’adapte à vos processus

• S’adapte à votre infrastructure

  • toute instance GitLab à laquelle les étudiants ont accès

  • salle de TP, ordinateur personnel, service en ligne, …

Expose progressivement les étudiants à la gestion de version, aux forges#