Rzine

Articles méthodologiques notebook, pour les sciences humaines et sociales

Hugues Pecout (CNRS, UMR Géographie-Cités)

Séminaire de Méthodologie (MetSem) - RésIn, SciencePo Paris

Caption Découverte d’une pratique

Ingénieur d’études en sciences de l’info. géographique
CNRS - UMR Géographie-Cités (FR CIST jusqu’en 2022)

  • Géomatique, analyse spatiale, cartographie
  • Formation classique aux logiciels SIG clic-bouton
  • 2015 : spécialisation dans l’utilisation du langage R

L’utilisation d’un langage de programmation m’a conduit à de nouvelles pratique, méthodes, organisation de travail, outils…

  • La programmation lettrée - Literate programming
  • Les documents computationnels - Rmarkdown/Quarto
  • Les forges logicielles - GithuB/GitLab

Caption Literate programming ?

La programmation lettrée est une approche de la programmation qui se veut différente du paradigme de programmation structurée.

« Nous devons changer notre attitude traditionnelle envers la construction des programmes : au lieu de considérer que notre tâche principale est de dire à un ordinateur ce qu’il doit faire, appliquons-nous plutôt à expliquer à des êtres humains ce que nous voulons que l’ordinateur fasse. (…)

Celui qui pratique la programmation lettrée peut être vu comme un essayiste, qui s’attache principalement à exposer son sujet dans un style visant à l’excellence. Tel un auteur, il choisit, avec soin, le dictionnaire à la main, les noms de ses variables et en explique la signification pour chacune d’elles. Il cherche donc à obtenir un programme compréhensible parce que ses concepts sont présentés dans le meilleur ordre possible. Pour cela, il utilise un mélange de méthodes formelles et informelles qui se complètent. »

D. Knuth, « Literate Programming », The Computer Journal, British Computer Society, vol. 27, no 2,‎ 1984, p. 97–111

Le paradigme de la programmation lettrée, pensé et mis en oeuvre par Donald Knuth (1977-78), s’éloigne dans son écriture de l’ordonnancement imposé par l’ordinateur, et à la place autorise les développeurs à utiliser un ordre imposé par la logique et le fil de leur pensée.

Quelques lignes de code…

library(ggplot2)
ggplot(data = iris, 
       aes(x = cut(Sepal.Length, breaks = c(min(Sepal.Length), 5, 6, 7, max(Sepal.Length)), 
                   include.lowest = TRUE, labels = c("Bas","Bas+","Haut","Haut+")))) +
  geom_bar() + xlab("") + ylab("") + ggtitle("Répartition par classe") +
  theme(plot.title = element_text(size=27), axis.text=element_text(size=19))

…En programmation lettrée

#----------------------------------------------------------------------
#         Représentation graphique de la répartition d'individus
#                     discrétisés en quatre classes 
#
#                              H. Pecout
#                            20 juin 2024
#----------------------------------------------------------------------

#------------ Discrétisation la variable Sepal.Length -----------------

## Statistiques sur la série statistique 'Sepal.Length'
summary(iris$Sepal.Length)

## Histogramme de la distribution
hist(iris$Sepal.Length)

## Choix des bornes de classes (amplitude égale)
bornes_des_classes <- c(min(iris$Sepal.Length), 5, 6, 7, 
                        max(iris$Sepal.Length))

## Choix des noms de classes
nom_des_classes <- c("Trés petites","petites","grandes","Très grandes")

## Discrétisation de la variable 'Sepal.length'
iris$classe  <- cut(iris$Sepal.Length,
                    breaks = bornes_des_classes,
                    labels = nom_des_classes,
                    include.lowest = TRUE)



#---------- Représentation graphique de la distribution --------------

## Library pour la représentation graphique
library(ggplot2)

## Représentation graphique de la distribution
ggplot(data = iris, aes(x = classe)) +  # Choix des données et de la variable à représenter
  geom_bar() +  # Choix du type de représentation
  xlab("") +    # Suppression du nom de l'axe x
  ylab("") +    # Suppression du nom de l'axe y
  ggtitle("Répartition par classe") +  # Titre du graphique
  theme(plot.title = element_text(size=27),  # Taille de la police titre 
        axis.text=element_text(size=19))     # Taille des labels d'axe

Caption LP + document computationnel

Il est possible de faire de la programmation lettrée dans n’importe quel type de document…
Le document computationnel est l’environnement parfait pour mettre en oeuvre ce paradigme.

Un document computationnel permet de combiner du langage naturel et du langage de programmation :

  • Le texte peut être mis en forme
  • Le code peut être affiché, éxécuté et les résultats affichés

La programmation lettrée et les documents computationnels sont apparus à la même période, celle de l’émergence du concept de recherche reproductible !

Caption Document computationnel ?

Définition : interface de programmation qui permet de combiner des sections en langage naturel et des sections en langage informatique.

En raison de l’évolution et de la diversité des outils logiciels disponibles dans ce domaine, il existe de nombreuses dénominations pour les documents computationnels .

Cela reflète la diversité de leurs caractèristiques, de leurs fonctionnalités, des approches différentes de conception et d’utilisation.

C’est la raison pour laquelle, les noms propres des différents dispositifs son souvent utilisés (ex : carnet Jupyter, Observable, Rmarkdown, Quarto…)

  • Article exécutable
  • Bloc-code (Arthur Perret, 2021)
  • Document computationnel
  • Document électronique interactif
  • Cahiers de programmation
  • Cahier électronique d’analyse
  • Calepin électronique
  • Carnet de code
  • Manifeste algorithmique
  • Notebook

Caption Anatomie d’un notebook

Un fichier texte (.rmd, .qmd, .ipynb…)

Caption Un outil, plusieurs pratiques

La mise en forme du texte se fait à l’aide d’un langage de balisage (Markdown, html…)

Caption Notebook + forges logicielles

Une forge logicielle est un système de gestion de rédaction, de partage et de maintenance collaborative de (fichier) texte. Bien que son usage premier soit pour le développement de logiciels, une forge peut aussi être utilisée pour la rédaction de documentation, de rapports ou présentation (LaTeX, Markdown, Notebook…), ainsi que pour la réalisation de sites web.

Les forges logicielles, comme GitHub ou GitLab, sont parfaites pour :

➡️ Versioner les codes sources de notebook
➡️ Archiver et partager le code source des notebook

➡️ Compiler un notebook - Continuous Integration
➡️ Déployer un notebook compilé en HTML - Continuous Deployment

Un exemple ?

Caption Ceci est un notebook (Quarto)

Chunk de code R (exécuté et affiché)

##------------------------ PACKAGES utilisés --------------------------## 

# install.packages("sf")
# install.packages("leaflet")

# Chargement des librairies
library(sf)
library(leaflet)



##----------------- Création d'un objet sf (point) --------------------## 

# Cordonnées de Sciences Po - Campus 1, Saint-Thomas
lat = 48.856172645935274
lng = 2.328557196883221
 
# Création d'un point
ptsfg <- st_point(c(lng, lat)) 

# Ajout du système géographique de référence
ptsfc <- st_sfc(ptsfg, crs = (4326))

# Création de l'attribut "name"
ptdf <- data.frame(id= 1, name = "Sciences Po - Campus 1, Saint-Thomas")

# Création de l'objet sf ponctuel
Here <- st_sf(ptdf,geometry = ptsfc)



##--------------------- Création carte dynamique ----------------------## 

# Lien vers une photo du campus
file <- 'https://paris-promeneurs.com/wp-content/uploads/2022/07/hotel-artillerie4-800.jpg'

# Construction du marker
icons <- awesomeIcons(icon = 'ios-people',
                      iconColor = 'white',
                      library = 'ion',
                      markerColor = 'blue')


# Affichage du point - carte interactive
mamap <- leaflet(Here) %>%
            setView( lat = lat, lng = lng, zoom = 13) %>% 
            addProviderTiles("GeoportailFrance.orthos") %>%
            addAwesomeMarkers(icon = icons,
                              popup = paste("<img src =", file, ">", 
                                            "<p style='text-align:center;'>Sciences Po</br>Campus Saint-Thomas</a></p>"))

Caption Ceci est un notebook (Quarto)

Affichage du résultat :

Caption Partagé et déployé via GitLab (HumaNum)


Rzine

Caption Le projet Rzine

  • Ancré dans les activités de la Fédération de Recherche CIST
  • 5 membres fondateurs issues de 4 laboratoires différents
  • Projet interdisciplinaire, collectif et à portée pédagogique
  • Projet exploratoire démarré en 2018 (3 ans, renouvelable)
  • Aucune obligation de résultats ni de livrables
  • Pas de budget propre ni de personnel alloué

Objectif annoncé

Produire de la documentation sur la pratique de R en SHS et contribuer à une montée en compétence collective

Caption Des expériences antérieures


Caption Une année d’exploration

  • Points forts et faibles de la communauté d’utilisateur·rices ?
  • Uilisation de R dans les différentes disciplines SHS ?
  • Accessibilité à des ressources gratuites, francophones ?
  • Format et type de ressource à disposition ? Orientée SHS ?
  • Bonnes pratiques (et mauvaises) existantes ?

Bilan

Communauté active, beaucoup de ressources, langage commun à plusieurs disciplines, de très bonnes initiatives francophones… et le document computationnel comme principal format des ressources disponibles.

Caption … De nouveaux objectifs !

I. Mise en avant de l’existant : Rzine.fr

  • Référencer les initiatives existantes et les acteurs de la communauté
  • Favoriser la diffusion et le partage de ressources diverses
  • → Dessiner les contours de la pratique de R en SHS (et ST)

II. Favoriser le partage de méthodes reproductibles

  • Encourager l’utilisation de la programmation lettrée et des Notebooks
  • Initier et former à l’utilisation des forges et du déploiement (CI/CD).
  • → Offrir un espace de partage normalisé : Collection de publication

Caption Du renfort


  • 2018 - Hugues Pecout (IE CNRS, UMR Géographie-Cités)
  • 2018 - Timothée Giraud (IR CNRS, UAR RIATE)
  • 2018 - Sébastien Rey-Coyrehourcq (IR Univ. de Rouen-Normandie, UMR IDEES)
  • 2018 - Marion Le Texier (MCF Université Paul Valéry - Montpellier 3, LAGAM)
  • 2018 - Laurent Beauguitte (CR CNRS, UMR Géographie-Cités)
  • 2020 - Grégoire Le Campion (IE CNRS, UMR Passages)
  • 2020 - Ronan Ysebaert (IE Université de Paris Cité, UAR RIATE)
  • 2020 - Violaine Jurie (IE Université de Paris Cité, Géotéca)
  • 2021 - Marion Gentilhomme (IE Université Paris 1 Panthéon-Sorbonne, FR CIST)
  • 2022 - Raphaëlle krummeich (IR Univ. de Rouen-Normandie, UMR IDEES)
  • 2023 - Sébastien Plutniak (CR CNRS, UMR CITERES)
  • 2023 - Marion Maisonobe (CR CNRS, UMR Géographie-Cités)
  • 2023 - Julie Gravier (CR CNRS, UMR ThéMA)


Différents statuts & profils, mais encore trop de géographes !





+ de 10 membres mais aucun avec du temps de travail officiellement alloué au projet

Rzine.fr

Les articles de méthode Rzine

Caption Objectifs

L’ouverture de la science ne se limite pas aux données et aux articles

  • Offrir un espace de publication qui permet de valoriser des méthodes.
  • Diffuser des méthodes associées à du code, qui permet de les ré-appliquer.
  • Contribuer à la diffusion de méthodes innovantes ou restées confidentielles.
  • Favoriser les échanges entre les disciplines de SHS.

Et surtout…

  • Promouvoir la pratique de la programmation lettrée, des notebooks et des forges
  • Contribuer à la diffusion de bonnes pratiques en matière de reproductibilité.

:

Caption Caractèristiques

  • Collection ouverte à tou·te·s
  • Périmètre interdisciplinaire, SHS et ST
  • Permet de valoriser une méthode mise en application avec R
  • Ancrage thématique et (si possible) approche transdisciplinaire
  • Publications en Notebook (Rmarkdown, HTML)
  • Publications soumises à comité de lecture
  • Processus de relecture transparent sur GitHub
  • Processus de d’édition sur GitHub/GitLab
  • Publications open source (licences très permissives)
  • Fourniture des informations & matèriel nécessaires à la reproductibilité
  • Utilisation de données libres , dans le respect du RGPD
  • Stockage et diffusion sur Rzine.fr (DOI, HAL, Nakala)


le comité éditorial s’engage à accompagner les auteur·es (et relecteur·rices) dans le processus de publication, voire à les former (rmarkdown, GitHub)

Caption Pourquoi un notebook ?

L’utilisation des notebooks n’est pas indispensable pour un article comportant du code.
L’usage simple du markdown pourrait aussi être une solution, ex : Programming Historian

L’utilisation du notebook (code executé à la compilation du document) permet de :

  • Intégrer automatiquement les résultats générés
  • Vérifier automatiquement de la bonne éxecution du code (auteur·es)
  • Vérifier automatiquement de la bonne éxecution du code (éditeur·rices)
  • Vérifier la pérennité du code et sa mise à jour
  • Plus d’interactivité (HTMl incluant du javascript) (Ex : tableau de données)
  • Intégrer automatiquement les informations précises sur l’environnement utilisé

La transposition d’un bout de code dans un format d’article est plus simple et efficace avec un notebook, car il n’est pas nécessaire de basculer d’un outil (Langage de programmation) à un autre (logiciel de traitement de texte).

Caption Un contenu délibérément flou…

Document qui présente une méthodologie, un type d’analyse, une fonctionnalité, ou encore le traitement d’un certain type de données réalisé avec R, de façon reproductible et didactique (literate programming) afin d’en faciliter son application pratique.


Un article peut être fortement axé sur un aspect technique ou méthodologique, mais elle doit impérativement s’ancrer dans une thématique des sciences humaines, sociales ou territoriales.


Un article doit être intelligible par des personnes issues de différentes disciplines.


Donner une importante liberté aux auteur·es intérréssé·es par ce format devrait permettre de dégager des tendances, des pratiques, des besoins, des envies, ect…

Les caractèristiques des premiers articles nous permettront de proposer des règles plus précises et une meilleure standardisation de ces articles de méthodes en format notebook.

Datapapers & articles de mèthode

Parce que les méthodes sont aussi hétéroclites que les données, la standardisation des articles de méthodes est aussi complexe que celles des datapapers !


Caption Processus éditorial

Caption Prototype

Caption Les pemières publications

Premier bilan

Caption Positif vs négatif

  • Idéal pour la valorisation d’analyse/traitement de données en programmation
  • Intéresse différents profils (IT, doctorant·es, MCF)
  • Permet de partager un aspect de la recherche trop peu souvent valorisé
  • Il existe déjà un public prêt à s’emparer de cette pratique (formé ou non)
  • Ce type de publication semble répondre à un besoin (soumissions spontanées)
  • L’aspect technique n’est pas un frein important pour les auteur·es
  • Le processus de relecture via des issues sur GitHub est efficace
  • L’interactivité d’un document HTML est un plus par rapport au PDF

  • Il est indispensable de limiter la longueur des articles
  • Le dosage entre méthodologie, thématique et code doit être mieux maîtrisé.
  • Le code doit garder une place centrale dans l’article
  • Un code a parfois besoin d’être “dégradé” pour être présenté de manière otpimale (PL)
  • Une méthode ne doit pas être noyée dans une chaîne de traitement complète
  • Certains articles présentent des dépendances externes à R
  • L’approche transdisciplinaire présente des limites
  • Le poids des fichiers de données utilisés peut être problématique
  • Comment gérer des données déjà mises à disposition librement ?
  • Eviter d’inclure trop d’interactivité dans une page HTML statique
  • Comment assurer la pérennité du code présenté sur le moyen terme ?
  • Un processus éditorial trop chronophage pour les éditeur·rices bénévoles


Caption Évolutions envisageables

  • Affiner les règles éditoriales et imposer des normes de rédaction plus strictes.
  • Proposer des règles et des procédures sur la pratique de la programmation lettrée
  • Proposer des règles et des procédures sur l’utilisation des fonctionnalités d’un notebook.
  • Arrêter une structure unique (squelette modulable) pour tous les articles
  • Limiter le volume de code présenté. Pas une chaîne de traitement complète
  • Mieux automatiser le processus de relecture et d’édition. Assumer l’utilisation des forges logicielles
  • Basculer toute la gestion de la revue sur la forge logicielle (issues et issues Boards)
  • Faire un choix entre GitHub et GitLab (pas les deux)
  • Changer d’outil notebook pour les articles (Quarto), et ouvrir à d’autres langages ?
  • Pousser la production d’articles collectifs et interdisciplinaire
  • Conteneuriser automatiquement le code source des articles publiés pour assurer leur reproductibilité
  • Refonte du site web

Une revue modèle pour les aspects techniques : Computo (sfds)

Caption Conclusion


La revue Rzine est une de preuve de concept qui permet de :

  • Réfléchir à l’appropriation de la programmation lettrée et de l’outil notebook pour un article de méthode appliqué en programmation
  • Participer à la diffusion de cette pratique, au delà de l’espace de publication proposé par Rzine

Pour aller plus loin…

Groupe de travail sur les enjeux et problématiques du Notebook, pris comme un objet complexe au sein du cycle des données de la recherche.


➡️ Site Web et liste de diffusion du GT Notebook

Caption Merci MetSem



Contact

@rzine_shs

@rzine@fosstodon.org