Delete ls-output.txt

decoupe-mots.txt

@@ -0,0 +1,19 @@
+
+
+# Litteraux
+## chaine de charactère
+## booléen
+## numérique
+?
+
+# Choisi par la personne qui a écrit le code
+## variables
+## classe
+## module
+## fonction
+## méthode
+
+# Mots réservés
+## opérateur
+## mots clefs
+## variable, class, module, fonction, methode provenant de la core lib ou std lib

episode-001/boutdecode.lua

@@ -0,0 +1,49 @@
+
+-- En provenance de https://github.com/bluebird75/luaunit/blob/4d1db2a3ab84acb56ac37ea3357913882e15019a/luaunit.lua#L220
+-- luaunit
+
+local function strsplit(delimiter, text)
+-- Split text into a list consisting of the strings in text, separated
+-- by strings matching delimiter (which may _NOT_ be a pattern).
+-- Example: strsplit(", ", "Anna, Bob, Charlie, Dolores")
+    if delimiter == "" then -- this would result in endless loops
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+
+
+-- Version sans les commentaires
+
+
+local function strsplit(delimiter, text)
+    if delimiter == "" then
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+

episode-001/boutdecode.txt

@@ -0,0 +1,20 @@
+
+local function strsplit(delimiter, text)
+    if delimiter == "" then
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+

episode-001/mail-phase-1.txt

@@ -0,0 +1,25 @@
+Bonjour à vous.
+
+Nous voici arrivé à notre premier essai d'exercice de lecture de code à distance.
+
+Je m'attends à ce que chacune et chacun d'entre vous prenne le temps qui lui ait nécessaire. Ne vous mettez pas la pression.
+
+J'envisage pour le moment de faire par petite étape, pour me donner le temps de voir comment je souhaite organiser le suivi de vos retour.
+
+C'est une grande première pour moi aussi vous l'aurez compris; aussi, j'espère que vous m'aiderez en me faisant par de vos retour.
+
+
+
+Pour notre premier épisode, je vous propose le boutdecode.txt en pièce jointe.
+
+Ce que je vous demanderais, c'est de
+- ranger par groupe cohérent chacun des mots/signe de ce bout de code.
+- donner un nom à ces groupes. Ce n'est pas très grave si c'est pas LE nom, ce qui m'intéresse, c'est le nom que VOUS lui donné
+- expliquer pourquoi ce nom et le regroupement (en quelques mots)
+
+
+Envoyez moi vos retour sour la forme qui vous arrange (c'est aussi une part de mon expérimentation, et je vous rappel que vous êtes mes cobayes :-D)
+
+Merci encore à vous, et à bientôt.
+
+

episode-001/mail-phase-2.txt

@@ -0,0 +1,20 @@
+Bonjour à vous,
+
+et bravo ! vous avez répondu à la première phase de l'épisode 001.
+
+Je vous propose d'explorer maintenant le même bout de code (que je vous remet en pièce jointe au cas où), mais cette fois, j'aimerais que vous fassions un découpage vertical, par bloc de code.
+
+J'aimerais que pour chaque ligne vous:
+- identifiez (elle représente quelle type d'instruction)
+- notiez le bloc parent auquelle elle appartient (si elle en a un).
+
+On m'a suggéré de vous proposer un joker, une aide, à la demande. Si vous avez envie, n'hésitez pas
+
+Et n'oubliez pas, dans vos retour j'aimerais :
+- avoir votre résultat de l'exercice
+- avoir votre sentiment par rapport à l'exercice
+- savoir si vous avez appris quelque chose en le faisant.
+
+A bientôt,
+-- Yannick.
+

episode-001/reponse-decoupage-bloc/reponse-alexandra-msg.txt

@@ -0,0 +1,2 @@
+C'est encore un exercice intéressant car il m'oblige à lire du code. Ensuite, de revenir sur un code que j'ai déjà analysé permet d'approfondir et de découvrir des aspects que je n'avais pas vu auparavant. Tout en gardant à l'esprit que je ne connais pas du tout le langage. C'est d'ailleurs, ce point qui peut aussi être frustrant, car il m'est arrivé de vouloir comprendre ce que cela faisait tout en doutant sur ce que j'avais réellement compris et en me retenant de rechercher quel langage c'était.
+

episode-001/reponse-decoupage-bloc/reponse-estelle.rtf

@@ -0,0 +1,107 @@
+{\rtf1\ansi\deff3\adeflang1025
+{\fonttbl{\f0\froman\fprq2\fcharset0 Times New Roman;}{\f1\froman\fprq2\fcharset2 Symbol;}{\f2\fswiss\fprq2\fcharset0 Arial;}{\f3\froman\fprq2\fcharset0 Liberation Serif{\*\falt Times New Roman};}{\f4\fswiss\fprq2\fcharset0 Liberation Sans{\*\falt Arial};}{\f5\froman\fprq2\fcharset0 Courier{\*\falt Courier New};}{\f6\fnil\fprq2\fcharset0 Noto Sans CJK SC Regular;}{\f7\fnil\fprq2\fcharset0 Lohit Devanagari;}{\f8\fnil\fprq0\fcharset128 Lohit Devanagari;}}
+{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;\red251\green2\blue255;\red253\green128\blue8;\red33\green255\blue6;\red33\green255\blue255;}
+{\stylesheet{\s0\snext0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033 Normal;}
+{\s15\sbasedon0\snext16\sb240\sa120\keepn\dbch\af6\dbch\af7\afs28\loch\f4\fs28 Heading;}
+{\s16\sbasedon0\snext16\sl288\slmult1\sb0\sa140 Text Body;}
+{\s17\sbasedon16\snext17\sl288\slmult1\sb0\sa140\dbch\af8 List;}
+{\s18\sbasedon0\snext18\sb120\sa120\noline\i\dbch\af8\afs24\ai\fs24 Caption;}
+{\s19\sbasedon0\snext19\noline\dbch\af8 Index;}
+}{\*\generator LibreOffice/5.4.2.2$Linux_X86_64 LibreOffice_project/40m0$Build-2}{\info{\creatim\yr0\mo0\dy0\hr0\min0}{\revtim\yr2018\mo2\dy14\hr17\min42}{\printim\yr0\mo0\dy0\hr0\min0}}{\*\userprops}\deftab720
+
+{\*\pgdsctbl
+{\pgdsc0\pgdscuse451\pgwsxn11906\pghsxn16838\marglsxn1440\margrsxn1440\margtsxn1440\margbsxn1440\pgdscnxt0 Default Style;}}
+\formshade{\*\pgdscno0}\paperh16838\paperw11906\margl1440\margr1440\margt1440\margb1440\sectd\sbknone\sectunlocked1\pgndec\pgwsxn11906\pghsxn16838\marglsxn1440\margrsxn1440\margtsxn1440\margbsxn1440\ftnbj\ftnstart1\ftnrstcont\ftnnar\aenddoc\aftnrstcont\aftnstart1\aftnnrlc
+{\*\ftnsep\chftnsep}\pgndec\pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf17\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+local function strsplit(delimiter, text)  }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Description}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+if delimiter == "" then               }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// If Condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+        }{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+error("delimiter matches empty string!") }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+//}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+end}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                                }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Fin de la condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+local list, pos, first, last = \{\}, 1   }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+//}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+while true do}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                      }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// While Condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+        }{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+first, last = text:find(delimiter, pos, true) }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+//Instruction hi\u233\'e9rarchis\u233\'e9e}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+        }{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+if first then -- found? }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// If Condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+            }{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+table.insert(list, text:sub(pos, first - 1))}{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Execution}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+            }{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+pos = last + 1\tab \tab }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Execution        \tab }
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+\tab    }{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+else}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                   }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Instruction hi\u233\'e9rarchis\u233\'e9e}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+            }{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+table.insert(list, text:sub(pos))\tab }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Execution }
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+            }{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+break}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                                }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Execution}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+        }{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+end}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                         }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Fin de la condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+end}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                           }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Fin de la condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\fs24\loch\f5\hich\af5
+    }{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+return list}{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+                    }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// }
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+end                            }{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+// Fin de la condition}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+M.private.strsplit = strsplit}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf20\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+Bleu}{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+ se r\u233\'e9f\u232\'e8re \u224\'e0 }{\cf12\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+violet}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+qui se r\u233\'e9f\u232\'e8re \u224\'e0 }{\cf19\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+vert}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+qui se r\u233\'e9f\u232\'e8re \u224\'e0 }{\cf18\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+orange}
+\par \pard\plain \s0\nowidctlpar\hyphpar0\cf0\kerning1\dbch\af6\langfe2052\dbch\af7\afs24\alang1081\loch\f3\hich\af3\fs24\lang1033\sl280\slmult0{\cf1\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+qui se r\u233\'e9f\u232\'e8re \u224\'e0 }{\cf17\outl0\expnd0\expndtw0\kerning0\rtlch \ltrch\loch\fs24\loch\f5\hich\af5
+rose}
+\par }

episode-001/reponse-decoupage-bloc/reponse-estelle.txt

@@ -0,0 +1,15 @@
+
+J'ai mis des commentaires en bout de chaque ligne, mais je sais que ce n'est pas très "respectueux" du code !
+
+J'ai essayé de comprendre certains mécanismes dans le code, des fois je m'aide de recherches sur Internet pour voir s'il y a des infos, mais ça m'embrouille aussi un peu.
+
+J'essaye de ne pas passer des heures sur l'exercice, même si je veux le faire sérieusement, je sais que je n'ai pas toutes les données donc je me force un peu à conclure en fin de cession.
+
+Je suis contente de prendre le temps de me pencher sur le sujet comme à chaque fois, mais c'est un peu frustrant de ne pas savoir si l'on progresse et de ne pas apprendre de nouveaux éléments par la correction de l'exercice précédent.
+
+Mais j'attends la suite avec impatience,
+
+Bonne journée,
+
+Estelle
+

episode-001/reponse-decoupage-mot/reponse-alexandra.txt

@@ -0,0 +1,9 @@
+
+J'ai adoré cet exercice pour le chemin que cela m'a fait parcourir: Réfléchir
+sur les différentes catégories qui, du coups, a induit une lecture x 20 au
+microscope.  Je reste persuadée que tout le parcours accompli n'aurait pas été
+aussi satisfaisant si tu m'avais défini les groupes dès le départ.
+
+Suggestion: En rapport avec ton objectif final (site), il serait intéressant de
+choisir le niveau de complexité en cochant si ou non on veut un indice.
+

episode-001/reponse-decoupage-mot/reponse-anna-livia-ALG - boutdecode.txt

@@ -0,0 +1,77 @@
+
+local function strsplit(delimiter, text)
+    if delimiter == "" then
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+
+
+
+# Groupes
+
+
+
+## Fonctions et Variables - représentations de données présentes à l'interieur du bout de code
+
+### Fonctions et variables assignée dans ce bout de code - Dont la fonction peut être connue en lisant ce bout de code
+strsplit
+delimiter
+text
+list
+pos
+first
+last
+found
+
+### Fonctions et variables définies autre part - dont la fonction ne peut pas être connue (mais potentiellement inférée) en lisant ce bout de code
+error()
+text:find()
+text:sub()
+table.insert()
+M
+
+
+## Grammaire du langage - Element permettant les opérations basiques d'un langage de programmation
+
+### Constantes - données présentes à l'interieur du bout de code
+
+"" (string)
+"delimiter matches empty string!" (String)
+1 (Int)
+true (Boolean)
+
+### Opérateurs - permet de modifier/comparer la donnée
+==
+-
++
+
+### Elements permettant de gérer l'assignation et le scopting des variables
+local
+function()
+private
+return
+=
+--
+
+### Elements permettant la procéduralité
+if/then/else/end
+While/do/end
+?
+
+
+
+
+

episode-001/reponse-decoupage-mot/reponse-anna-livia.txt

@@ -0,0 +1,19 @@
+Hello Yannick,
+
+Merci pour ce premier exercice, je suis super contente d'être le cobaye de cette expérience !
+
+Tu trouveras en PJ ma réponse à l'exercice.
+
+Ce que j'ai pensé de l'exercice :
+- je ne connais pas les mots de l'informatique :)
+- je n'aime pas ne pas aller chercher la réponse sur internet (j'aurais pu le faire, mais je me dis que ce n'était pas l'esprit de l'exercice)
+- j'ai changé plusieurs fois l'organisation des groupes de mots, mais rarement ce qu'il y avait à l'intérieur des groupes.
+- j'ai trouvé interessant de choisir un prisme de classement
+
+Ce que j'ai  appris durant l'exercice.
+- que "-- found?" est mon némésis, je veux bien une réponse sur ce que c'est parce que je ne sais même pas comment demander aux internets.
+- j'ai du mal à comprendre où  je dois mettre mon attention pendant l'exercice, pour avancer sur le chemin de la lecture de code.
+- Que j'aurais pu classer de plein de manières différentes.
+
+Voilou, merci encore, et j'ai hate de recevoir l'épisode 2
+

episode-001/reponse-decoupage-mot/reponse-elodie.txt

@@ -0,0 +1,64 @@
+
+local function strsplit(delimiter, text)
+    if delimiter == "" then
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+
+
+
+Elements syntaxique du langage :
+- local function,
+- local,
+- if,
+- then,
+- end,
+- while,
+- do,
+- else,
+- break,
+- private
+
+Nom de variable :
+- delimiter,
+- text,
+- list,
+- pos,
+- first,
+- last,
+- table,
+
+Nom de fonction :
+- strsplit
+- error
+- find
+- found?
+- insert
+- sub
+- M
+
+Diver :
+
+- == : représente une égalité
+- "" : represente une chaine de caractère vide.
+- "delimiter matches empty string!" : represente une string
+- last = {} : represente un object
+- 1 : represente un entier
+- true : represente vrais dans une comparaison par exemple
+- text: je ne sais pas.
+- last = text:find(delimiter, pos, true) : represent une affectation de variable (le resultat de cette fonction va dans la varaible last.)
+- table.insert(list, text:sub(pos)) : represente une varable table a qui on lui applique la fonction insert avec ses paramêtres.
+- + 1 / - 1 : represente un + 1 sur la variable first (qui doit contenir un integer.)

episode-001/reponse-decoupage-mot/reponse-eric-lecture_code_E1_resultat_ELT.txt

@@ -0,0 +1,49 @@
+# Groupes
+
+# Ce premier groupe de mots détermine la structure et la circulation
+# -termes conditionnels :  while, if, then, else
+# -termes d'action : do, return, break, end
+# -terme d'avertissement : error
+
+# Ce deuxième groupe range les signes par catégorie selon leur rôle 
+# -signes de ponctuation : ( ) " , { } : .
+# -signe d'affectation : =
+# -signes d'arithmétique : + - ==
+
+# J'ai regroupé ces trois ensembles par analogie avec la syntaxe humaine (sujet, verbe, complément)
+# -variables : delimiter, text, strsplit, pos, first, last
+# -fonctions : strsplit, find, insert, sub, found?
+# -adjectifs : local, private
+
+# Ce groupe contient différents types de variables
+# -chaînes de caractères : "delimiter matches empty string!" 
+# -booléens : true
+# -nombres : 1
+# -tableaux : table, list
+
+# En dernier, un peu à part
+# -classe : M
+
+#  J'ai l'impression que cet exercice m'a fait réfléchir sur le sens des termes en m'amenant à mobiliser des notions que je connaissais déjà, en me forçant à m'interroger sur des petits bouts de code les uns après les autres. Au début, j'ai essayé de faire des recherches sur Internet pour m'aider mais ça n'a pas été fructueux donc j'ai laissé tomber. Je crois que c'est du R. Je comprends vaguement le code dans l'ensemble mais pas dans le détail. J'ai un peu le sentiment d'être passé à côté de l'exercice et que j'apprendrai surtout en lisant la correction. 
+
+
+
+local function strsplit(delimiter, text)
+    if delimiter == "" then
+        error("delimiter matches empty string!")
+    end
+    local list, pos, first, last = {}, 1
+    while true do
+        first, last = text:find(delimiter, pos, true)
+        if first then -- found?
+            table.insert(list, text:sub(pos, first - 1))
+            pos = last + 1
+        else
+            table.insert(list, text:sub(pos))
+            break
+        end
+    end
+    return list
+end
+M.private.strsplit = strsplit
+

episode-001/reponse-decoupage-mot/reponse-eric.txt

@@ -0,0 +1,7 @@
+Hello Yannick,
+
+Ça y est, j'ai fait le premier exercice de lecture de code. Il est en pièce jointe.
+Bonne semaine à toi, et à vendredi !
+
+Eric
+

episode-001/reponse-decoupage-mot/reponse-estelle.txt

@@ -0,0 +1,18 @@
+
+_email du 6 janvier 2018_
+
+Alors je me suis penchée sur le code. Je pars un peu de zéro, la soirée code du mois d'octobre est un peu loin dans mes souvenirs donc je tâtonne.
+
+Première remarque pour une débutante comme moi, je pense qu'il serait bien de proposer un exercice intermédiaire, soit proposer des noms de groupe à identifier dans le code ou identifier des groupes et tenter de les nommer.
+
+Bon j'ai fait un premier jet, ce n'est pas toujours cohérent enfin tu verras s'il y a quelque chose à sauver.
+
+je peux continuer l'exercice si tu as des corrections ou des lignes directrices à me donner.
+
+
+
+_email du 9 janvier_
+
+Alors faire cet exercice m'a permis de prendre un peu de temps à regarder du code toute seule sans aide.
+Je me dis que ce n'est pas complétement de l'Hébreu pour moi, j'ai l'impression de distinguer quelques informations dans la structuration du code et ça me donne donc envie d'avoir quelques clés pour aller plus loin.
+

episode-001/reponse-decoupage-mot/reponse-etienne.txt

@@ -0,0 +1,46 @@
+chalut,
+
+j'ai fait mes devoirs !
+
+- ranger par groupe cohérent chacun des mots/signe de ce bout de code.
+done
+
+- donner un nom à ces groupes. Ce n'est pas très grave si c'est pas LE nom, ce qui m'intéresse, c'est le nom que VOUS lui donné
+done
+
+- expliquer pourquoi ce nom et le regroupement (en quelques mots)
+je te propose deux versions, qui témoignent de la progression de ma réflexion.
+
+dans la v1
+j'ai commencé par identifier les mots-clés, car ça me semblait être le plus simple. ce sont tous les mots qui te sont imposés par le langage. mots-clés parce que ces mots sont généralement courts et ont un sens déterminé.
+puis j'ai identifié les variables, dans lesquelles on stocke des valeurs. les variables sont les mots à gauche du signe égal ou sont passées en argument de fonctions. les valeurs sont toujours à droite du signe égal. j'ai utilisé les mots qu'on emploie généralement pour ce genre de choses. ça commençait à devenir bien coloré.
+j'ai cherché des catégories pour les mots restants, j'ai vu insert, j'ai compris que j'avais oublié les fonctions. donc j'ai rajouté les fonctions, avec un doute sur find et sub, car ils ne sont pas appelés avec . mais avec : bizarrement. mais j'ai tout de même décidé que c'étaient des fonctions.
+ensuite sont venus tous les symboles, que j'ai appelés ponctuation, car ça permet de structurer, découper, regrouper le code. j'ai hésité sur les symboles + - =. je pensais les identifier comme ponctuation au début, puis je me suis dit que a + b c'était comme a.add(b) donc + est devenu une fonction. pareil pour a = 3 qui peut se lire a.assign(3).
+là il restait encore les mots table et text. je ne les voyais pas comme des variables car on ne les a jamais déclarés et ils ne varient pas à mon sens. donc mots-clés.
+il restait aussi -- found? dont je n'ai pas compris le sens. j’ai donc supposé que c’était un commentaire
+
+mais je n'étais pas vraiment satisfait à cause de certains cas comme strsplit à la dernière ligne, car strsplit changeait de catégorie par rapport à la première ligne ; à cause de first - 1 qui mélangeait variable et valeur ; à cause du mélange de couleurs dans les paramètres de la fonction find.
+
+dans la v2
+donc j'ai eu envie de changer de concept et de remplacer variable et valeur par left-value et right-value. c'est Laurent qui m'en a parlé pour la première fois, j'avais pas très bien compris à l'époque, mais là, bizarrement, ça me semblait plus adapté.
+donc lvalues ou left-values pour les mots généralement placés à gauche du signe = et vice versa. mais généralement n'est pas une règle.
+la règle que je me suis donnée pour distinguer ces deux catégories est la suivante : les lvalues sont modifiées lorsqu'elles apparaissent, les rvalues ne sont pas modifiées. il me semble que le découpage est plus logique maintenant.
+
+- votre réponse à l'exercice
+done
+
+- ce que vous avez pensez de l'exercice
+moins facile que prévu
+super utile pour mettre ses connaissances à l'épreuve
+j'aimerais avoir une analyse de ma réponse par un expert, ou un découpage cohérent, car je sais que le mien manque de logique et j'ai toujours des doutes en écrivant ce point meta
+
+- ce que vous avez appris durant l'exercice.
+j'ai pensé pendant l'exercice au terme littéral que Laurent emploie souvent et que je n'ai jamais compris. peut-être que l'une de mes deux versions à quelque chose à voir avec ce concept. peut-être pas.
+peut-être qu'il n'y a pas qu'un seul découpage correct
+tout ce que je sais, c'est que je ne sais rien
+
+et voilà :) très bonne soirée Yannick
+
+Etienne Puydebois
+
+

episode-001/reponse-decoupage-mot/reponse-souley-Lecture de code.rtf

@@ -0,0 +1,379 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1561\cocoasubrtf200
+{\fonttbl\f0\fnil\fcharset0 HelveticaNeue-Bold;\f1\fnil\fcharset0 HelveticaNeue-Italic;\f2\fnil\fcharset0 HelveticaNeue;
+\f3\fmodern\fcharset0 CourierNewPS-BoldMT;\f4\fnil\fcharset0 HelveticaNeue-BoldItalic;\f5\fmodern\fcharset0 Courier-Bold;
+\f6\fmodern\fcharset0 Courier-BoldOblique;\f7\fmodern\fcharset0 Courier-Oblique;\f8\fmodern\fcharset0 Courier;
+\f9\fmodern\fcharset0 CourierNewPSMT;\f10\fmodern\fcharset0 CourierNewPS-ItalicMT;}
+{\colortbl;\red255\green255\blue255;\red255\green255\blue255;\red230\green0\blue14;\red0\green0\blue0;
+\red253\green129\blue123;\red32\green166\blue3;\red76\green76\blue76;\red13\green96\blue2;\red245\green174\blue9;
+\red12\green97\blue171;\red189\green13\blue104;\red253\green128\blue8;}
+{\*\expandedcolortbl;;\cssrgb\c100000\c100000\c100000;\cssrgb\c93213\c13483\c4656;\cssrgb\c0\c0\c0;
+\cssrgb\c100000\c58874\c55293;\cssrgb\c11306\c69375\c172;\cssrgb\c37036\c37036\c37036;\cssrgb\c507\c44277\c174;\cssrgb\c97413\c73060\c0;
+\cssrgb\c0\c46246\c72914;\cssrgb\c79662\c16222\c48278;\cssrgb\c100000\c57771\c0;}
+{\*\listtable{\list\listtemplateid1\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{disc\}}{\leveltext\leveltemplateid1\'01\uc0\u8226 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid1}
+{\list\listtemplateid2\listhybrid{\listlevel\levelnfc23\levelnfcn23\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace360\levelindent0{\*\levelmarker \{disc\}}{\leveltext\leveltemplateid101\'01\uc0\u8226 ;}{\levelnumbers;}\fi-360\li720\lin720 }{\listname ;}\listid2}}
+{\*\listoverridetable{\listoverride\listid1\listoverridecount0\ls1}{\listoverride\listid2\listoverridecount0\ls2}}
+\paperw11905\paperh16837\margl1133\margr1133\margb1133\margt1133
+\deftab720
+\pard\pardeftab720\partightenfactor0
+
+\f0\b\fs22 \cf2 \cb3 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec2 local function strsplit(delimiter, text)    \
+\pard\pardeftab720\partightenfactor0
+
+\f1\i\b0\fs18 \cf4 \cb5 \strokec4 if delimiter == "" then                                      \
+        error("delimiter matches empty string!")\
+    end                                                                \
+\pard\pardeftab720\partightenfactor0
+
+\f2\i0\fs22 \cf4 \cb1 \strokec4 local list, pos, first, last = \{\}, 1\
+\pard\pardeftab720\partightenfactor0
+
+\f1\i\fs18 \cf4 \cb5 \strokec4 while true do                                                    \
+        first, last = text:find(delimiter, pos, true)   \
+        if first then -- found?                                \
+            table.insert(list, text:sub(pos, first - 1))\
+            pos = last + 1                                        \
+        else                                                           \
+            table.insert(list, text:sub(pos))              \
+            break                                                    \
+        end                                                           \
+    end                 
+\f2\i0\fs22 \cf4 \cb5 \strokec4                                       \
+\pard\pardeftab720\partightenfactor0
+\cf4 \cb1 \strokec4     return list\
+\pard\pardeftab720\partightenfactor0
+
+\f0\b \cf2 \cb3 \strokec2 end\
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0 \cf4 \cb1 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f0\b \cf2 \cb6 \strokec2 M.private.strsplit = strsplit\
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0 \cf4 \cb1 \strokec4 \
+\
+\
+\pard\pardeftab720\qc\partightenfactor0
+
+\f0\b\fs28 \cf3 \strokec3 A-    \cf4 \ul \ulc4 \strokec4 ANALYSE DU CODE\
+\pard\pardeftab720\partightenfactor0
+
+\fs22 \cf4 \ulc4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0 \cf4 \ulnone \strokec4 \'c0 premi\'e8re vue, on remarque que notre bout de code est constitu\'e9 de deux partie s\'e9par\'e9es.\
+\
+\pard\pardeftab720\qc\partightenfactor0
+
+\f0\b\fs28 \cf3 \strokec3 1- 
+\fs20 \cf3 \strokec3  
+\f2\b0\fs26 \cf4 \ul \ulc4 \strokec4 Un bloc d\'e9limit\'e9 par:
+\fs20 \cf4 \ulnone \strokec4  
+\f3\b \cf7 \strokec7 local function strsplit(delimiter, text) \'85\'85\'85 end
+\f2\b0 \cf4 \strokec4  (en rouge)\
+\pard\pardeftab720\partightenfactor0
+
+\fs22 \cf4 \ul \ulc4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+\cf4 \ulnone \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f0\b\fs26 \cf3 \cb5 \strokec3 local function\cf4 \cb5 \strokec4  \cf8 \cb5 \strokec8 strsplit\cf9 \cb5 \strokec9 (delimiter, text)  \cf4 \cb5 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0\fs22 \cf4 \cb1 \strokec4   
+\f0\b \cf3 \strokec3   
+\f4\i \cf3 \strokec3 if \cf10 \strokec10 delimiter
+\f1\b0 \cf4 \strokec4  
+\f4\b \cf3 \strokec3 ==
+\f1\b0 \cf4 \strokec4  
+\fs26 \cf11 \strokec11 ""
+\fs22 \cf4 \strokec4  
+\f4\b \cf3 \strokec3 then\
+\pard\pardeftab720\partightenfactor0
+
+\f1\b0 \cf4 \strokec4         
+\f4\b \cf6 \strokec6 error
+\fs32 \cf12 \strokec12 (
+\f1\b0\fs22 \cf11 \strokec11 "delimiter matches empty string!"
+\f4\b\fs32 \cf12 \strokec12 )
+\f1\b0\fs22 \cf4 \strokec4 \
+    
+\f4\b \cf3 \strokec3 end
+\f1\b0 \cf4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f2\i0 \cf4 \strokec4    
+\f0\b \cf3 \strokec3  \
+\pard\pardeftab720\partightenfactor0
+
+\fs28 \cf3 \strokec3 local
+\f2\b0 \cf4 \strokec4  
+\f0\b \cf10 \strokec10 list, pos, first, last
+\f2\b0 \cf4 \strokec4  \cf3 \strokec3 =\cf4 \strokec4  
+\f0\b \cf3 \strokec3 \{\}
+\f2\b0 \cf4 \strokec4 , 1\
+\pard\pardeftab720\partightenfactor0
+
+\fs22 \cf4 \strokec4  
+\f0\b \cf4 \strokec4   \
+\pard\pardeftab720\partightenfactor0
+
+\f5\fs24 \cf3 \strokec3   
+\f6\i \cf3 \strokec3 while
+\f7\b0 \cf3 \strokec3  true do\cf4 \strokec4 \
+        
+\f6\b \cf10 \strokec10 first, last
+\f7\b0 \cf4 \strokec4  = 
+\f6\b \cf4 \strokec4 text:\cf6 \strokec6 find\cf12 \strokec12 (delimiter, pos
+\f7\b0 \cf12 \strokec12 , 
+\f6\b \cf12 \strokec12 true)
+\f7\b0 \cf12 \strokec12 \
+\pard\pardeftab720\partightenfactor0
+\cf4 \strokec4        
+\f6\b \cf3 \strokec3  if
+\f7\b0 \cf4 \strokec4  \cf3 \strokec3 first then\cf4 \strokec4  -- 
+\f6\b \cf3 \strokec3 found?\
+
+\f7\b0 \cf4 \strokec4             
+\f6\b \cf4 \strokec4 table\cf3 \strokec3 .\cf6 \strokec6 insert
+\f7\b0 \cf4 \strokec4 (
+\f6\b \cf10 \strokec10 list
+\f7\b0 \cf4 \strokec4 , 
+\f6\b \cf4 \strokec4 text:\cf6 \strokec6 sub\cf12 \strokec12 (pos, first - 1))
+\f7\b0 \cf4 \strokec4 \
+            
+\f6\b \cf10 \strokec10 pos \cf3 \strokec3 =\cf10 \strokec10  last
+\f7\b0 \cf4 \strokec4  + 1\
+       
+\f6\b \cf3 \strokec3  else\
+
+\f7\b0 \cf4 \strokec4             
+\f6\b \cf4 \strokec4 table\cf3 \strokec3 .\cf6 \strokec6 insert\cf12 \strokec12 (
+\f7\b0 \cf12 \strokec12 list, 
+\f6\b \cf12 \strokec12 text:\cf6 \strokec6 sub
+\f7\b0 \cf12 \strokec12 (pos)
+\f6\b \cf12 \strokec12 )
+\f7\b0 \cf12 \strokec12 \
+\cf4 \strokec4            
+\f6\b \cf3 \strokec3  break
+\f7\b0 \cf4 \strokec4 \
+       
+\f6\b \cf3 \strokec3  end
+\f7\b0 \cf4 \strokec4 \
+    
+\f6\b \cf3 \strokec3 end\
+\pard\pardeftab720\partightenfactor0
+
+\f8\i0\b0 \cf4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f2\fs22 \cf4 \strokec4     
+\f0\b \cf3 \strokec3 return
+\f2\b0 \cf4 \strokec4  
+\f0\b \cf10 \strokec10 list\
+\pard\pardeftab720\partightenfactor0
+
+\fs26 \cf3 \cb5 \strokec3 end \
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0\fs22 \cf4 \cb1 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f0\b\fs24 \cf4 \strokec4 \
+\
+\
+\
+\
+Dans cette 1\'e8re partie on a:\
+\pard\pardeftab720\partightenfactor0
+
+\f2\b0\fs22 \cf4 \ul \ulc4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb3 \ulnone \strokec2 EN ROUGE:\cf4 \cb1 \strokec4  Les mots cl\'e9 du langage 
+\f1\i\fs16 \cf4 \strokec4 (je pense au C++)
+\f2\i0\fs22 \cf4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb12 \strokec2 EN ORANGE et 
+\f0\b\fs32 \cf2 \cb12 \strokec2 ( )
+\f2\b0\fs22 \cf2 \cb12 \strokec2 :\cf4 \cb12 \strokec4   \cf4 \cb1 \strokec4 Les param\'e8tres de la fonction 
+\f0\b \cf4 \strokec4 strsplit()
+\f2\b0 \cf4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb10 \strokec2 EN BLEU:    \cf4 \cb10 \strokec4  les variables\
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb6 \strokec2 EN VERT:      \cf4 \cb6 \strokec4 Les noms de fonction\
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb3 \strokec2 EN NOIR:    \cf4 \cb1 \strokec4    Non identifier \
+\pard\pardeftab720\partightenfactor0
+\cf2 \cb11 \strokec2 EN VIOLET: \cf2 \cb1 \strokec2  \cf4 \strokec4   Chaine de caract\'e8res\
+\
+\
+\pard\pardeftab720\partightenfactor0
+
+\f0\b\fs28 \cf3 \strokec3 1- 
+\fs22 \cf3 \strokec3  
+\f2\b0\fs26 \cf4 \ul \ulc4 \strokec4 Un second bloc en dehors de la fonction representer par une seule instruction:   
+\f8\fs28 \cf7 \ulnone \strokec7 M.private.strsplit = strsplit 
+\fs24 \cf4 \strokec4 (en vert)\
+\pard\pardeftab720\qc\partightenfactor0
+
+\f5\b \cf4 \ul \ulc4 \strokec4 \
+\pard\pardeftab720\qc\partightenfactor0
+
+\f0\fs28 \cf3 \ulnone \strokec3 B- \cf4 \ul \ulc4 \strokec4 INTERPRETATION ET COMPR\'c9HENSION DU CODE\
+\
+\pard\pardeftab720\partightenfactor0
+
+\fs24 \cf4 \ulnone \strokec4 //
+\f2\b0 \cf3 \strokec3     
+\f3\b \cf3 \strokec3 local function strsplit(delimiter, text) \'85\'85\'85 end
+\f0 \cf3 \strokec3 \
+\pard\pardeftab720\partightenfactor0
+
+\f8\b0 \cf4 \strokec4 En g\'e9n\'e9ral nous avons une fonction appel\'e9e \cf7 \strokec7 strsplit() \cf4 \strokec4 qui prend en param\'e8tre un caract\'e8re de s\'e9paration appel\'e9 (\cf7 \strokec7 delimiter\cf4 \strokec4 ) et le texte (\cf7 \strokec7 text\cf4 \strokec4 ) \'e0 d\'e9couper en caract\'e8re comme l\'92indique le nom de la fonction (
+\fs28 \cf7 \strokec7 strsplit
+\fs24 \cf4 \strokec4 )\
+\pard\pardeftab720\partightenfactor0
+
+\f2\fs22 \cf4 \strokec4 \
+\
+\pard\pardeftab720\partightenfactor0
+
+\f0\b\fs26 \cf4 \strokec4 //\
+\pard\pardeftab720\partightenfactor0
+
+\f8\b0\fs22 \cf4 \strokec4    \cf3 \strokec3 if \cf10 \strokec10 delimiter\cf4 \strokec4  \cf3 \strokec3 ==\cf4 \strokec4  
+\fs26 \cf11 \strokec11 ""
+\fs22 \cf4 \strokec4  \cf3 \strokec3 then\
+\pard\pardeftab720\partightenfactor0
+\cf4 \strokec4         \cf6 \strokec6 error
+\fs32 \cf12 \strokec12 (
+\fs22 \cf11 \strokec11 "delimiter matches empty string!"
+\fs32 \cf12 \strokec12 )
+\fs22 \cf4 \strokec4 \
+    \cf3 \strokec3 end\
+\cf4 \strokec4 \
+Dans cette partie, on a un premier bloc 
+\f5\b \cf3 \strokec3 if \'85\'85
+\f8\b0 \cf4 \strokec4  
+\f5\b \cf3 \strokec3 end 
+\f8\b0 \cf4 \strokec4 qui compare la variable 
+\f5\b \cf10 \strokec10 delimiter
+\f8\b0 \cf4 \strokec4  \'e0 un caract\'e8re vide 
+\f5\b\fs26 \cf11 \strokec11 ""
+\f8\b0\fs22 \cf4 \strokec4  et renvoie un message d\'92erreur si l\'92instruction: 
+\f5\b \cf10 \strokec10 delimiter
+\f8\b0 \cf4 \strokec4  
+\f5\b \cf3 \strokec3 ==
+\f8\b0 \cf4 \strokec4  
+\fs26 \cf11 \strokec11 "" \cf4 \strokec4 renvoie \cf3 \strokec3 true\
+\
+\
+\pard\pardeftab720\partightenfactor0
+
+\f5\b\fs22 \cf4 \strokec4 //\
+\pard\pardeftab720\partightenfactor0
+
+\f3\fs28 \cf3 \strokec3 local
+\f9\b0 \cf4 \strokec4  \cf10 \strokec10 list, pos, first, last\cf4 \strokec4  \cf3 \strokec3 =\cf4 \strokec4  \cf3 \strokec3 \{\}\cf4 \strokec4 , 1  
+\f2\fs20 \cf4 \strokec4 =>  Affectation multiple\
+\pard\pardeftab720\partightenfactor0
+
+\f8\fs22 \cf4 \strokec4 ici 4 variables 
+\f5\b \cf10 \strokec10 list, pos, first, last
+\f8\b0 \cf4 \strokec4  sont initialis\'e9e o\'f9 \
+\pard\pardeftab720\partightenfactor0
+
+\f9\fs28 \cf10 \strokec10 list = \cf3 \strokec3 \{\} 
+\f2\fs20 \cf4 \strokec4 =>  hash vide
+\f9\fs28 \cf3 \strokec3 \
+\cf10 \strokec10 pos = \cf3 \strokec3 1\
+\cf10 \strokec10 first = \cf3 \strokec3 nil\
+\cf10 \strokec10 last = \cf3 \strokec3 nil
+\f10\i \cf4 \ul \ulc4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f5\i0\b\fs22 \cf4 \ulnone \strokec4 //\
+\pard\pardeftab720\partightenfactor0
+
+\f8\b0\fs24 \cf3 \strokec3 while true do\cf4 \strokec4 \
+        \cf10 \strokec10 first, last\cf4 \strokec4  = text:\cf6 \strokec6 find\cf12 \strokec12 (delimiter, pos, true)\
+\pard\pardeftab720\partightenfactor0
+\cf4 \strokec4        \cf3 \strokec3  if\cf4 \strokec4  
+\f5\b \cf10 \strokec10 first
+\f8\b0 \cf3 \strokec3  then\cf4 \strokec4  -- \cf3 \strokec3 found?\
+\cf4 \strokec4             table\cf3 \strokec3 .\cf6 \strokec6 insert\cf4 \strokec4 (\cf10 \strokec10 list\cf4 \strokec4 , \cf4 \strokec4 text:\cf6 \strokec6 sub\cf12 \strokec12 (pos, first - 1))\cf4 \strokec4 \
+            \cf10 \strokec10 pos \cf3 \strokec3 =\cf10 \strokec10  last\cf4 \strokec4  + 1\
+       \cf3 \strokec3  else\
+\cf4 \strokec4             table\cf3 \strokec3 .\cf6 \strokec6 insert\cf12 \strokec12 (list, text:\cf6 \strokec6 sub\cf12 \strokec12 (pos))\
+\cf4 \strokec4            \cf3 \strokec3  break\cf4 \strokec4 \
+       \cf3 \strokec3  end\cf4 \strokec4 \
+    \cf3 \strokec3 end\
+\pard\pardeftab720\partightenfactor0
+
+\fs22 \cf4 \strokec4 ici on a un bloc (
+\f5\b \cf3 \strokec3 if \'85\'85
+\f8\b0 \cf4 \strokec4  
+\f5\b \cf3 \strokec3 end
+\f8\b0 \cf4 \strokec4 ) imbriqu\'e9 dans un bloc (
+\f5\b \cf3 \strokec3 while \'85\'85
+\f8\b0 \cf4 \strokec4  
+\f5\b \cf3 \strokec3 end
+\f8\b0 \cf4 \strokec4 ) qui est toujours \'e0 \cf3 \strokec3 true,\cf4 \strokec4  synonyme de boucle infini.\
+Le but de la boucle ici c\'92est de:\
+\pard\tx20\tx260\pardeftab720\li240\fi-240\partightenfactor0
+\ls1\ilvl0
+\fs24\fsmilli12000 \cf4 \kerning1\expnd0\expndtw0 \up0 \nosupersub \ulnone \outl0\strokewidth0 {\listtext	-	}
+\fs20 \cf4 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec4 D\'92abord ex\'e9cuter l\'92instruction: \cf10 \strokec10 first, last\cf4 \strokec4  = text:\cf6 \strokec6 find\cf12 \strokec12 (delimiter, pos, true) \cf4 \strokec4 qui recherche s\'92il existe un delimiter fourni en param\'e8tre en position 1, \'e0 la fonction 
+\f3\b\fs24 \cf4 \strokec4 strsplit
+\f8\b0\fs20 \cf4 \strokec4  et l\'92affecte aux variables \cf10 \strokec10 first.\
+\ls1\ilvl0
+\fs24\fsmilli12000 \cf4 \kerning1\expnd0\expndtw0 \up0 \nosupersub \ulnone \outl0\strokewidth0 {\listtext	-	}
+\fs20 \cf4 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec4 S\'92il trouve un delimiter, il rentre dans le 
+\f5\b \cf3 \strokec3 if
+\f8\b0 \cf4 \strokec4  et ex\'e9cute ceci:\cf10 \strokec10  \cf4 \strokec4     
+\f5\b\fs22 \cf4 \strokec4 table\cf3 \strokec3 .\cf6 \strokec6 insert\cf4 \strokec4 (\cf10 \strokec10 list\cf4 \strokec4 , \cf4 \strokec4 text:\cf6 \strokec6 sub\cf12 \strokec12 (pos, first - 1))\cf4 \strokec4 \
+\pard\pardeftab720\partightenfactor0
+
+\f8\b0\fs24 \cf4 \strokec4             \cf10 \strokec10 pos \cf3 \strokec3 =\cf10 \strokec10  last\cf4 \strokec4  + 1,\
+\pard\pardeftab720\partightenfactor0
+
+\fs20 \cf4 \strokec4 increment la variable 
+\f5\b\fs24 \cf10 \strokec10 pos
+\f8\b0\fs20 \cf4 \strokec4  de 1 pour d\'e9placer la position du 
+\f5\b \cf10 \strokec10 delimiter
+\f8\b0 \cf4 \strokec4  dans le texte, ajoute le mot trouv\'e9 \'e0 la collection 
+\f5\b\fs22 \cf10 \strokec10 list
+\f8\b0\fs20 \cf4 \strokec4   puis rentre dans une nouvelle it\'e9ration du
+\f5\b \cf3 \strokec3  while 
+\f8\b0 \cf4 \strokec4 et
+\f5\b \cf3 \strokec3  
+\f8\b0 \cf4 \strokec4 ainsi de suite.\cf10 \strokec10 \
+\pard\tx20\tx260\pardeftab720\li240\fi-240\partightenfactor0
+\ls2\ilvl0
+\fs24\fsmilli12000 \cf4 \kerning1\expnd0\expndtw0 \up0 \nosupersub \ulnone \outl0\strokewidth0 {\listtext	-	}
+\fs20 \cf4 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec4 sinon (
+\f5\b \cf3 \strokec3 else
+\f8\b0 \cf4 \strokec4 ), il ex\'e9cute:\cf10 \strokec10  \cf4 \strokec4 table\cf3 \strokec3 .\cf6 \strokec6 insert\cf12 \strokec12 (list, text:\cf6 \strokec6 sub\cf12 \strokec12 (pos))\
+\ls2\ilvl0
+\fs24\fsmilli12000 \cf4 \kerning1\expnd0\expndtw0 \up0 \nosupersub \ulnone \outl0\strokewidth0 {\listtext	-	}
+\fs20 \cf4 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec4 Et arr\'eate l\'92ex\'e9cution de la boucle 
+\f5\b \cf3 \strokec3 while
+\f8\b0 \cf4 \strokec4  avec\cf12 \strokec12  \cf3 \strokec3 break\
+\ls2\ilvl0
+\fs24\fsmilli12000 \cf4 \kerning1\expnd0\expndtw0 \up0 \nosupersub \ulnone \outl0\strokewidth0 {\listtext	-	}
+\fs20 \cf4 \expnd0\expndtw0\kerning0
+\up0 \nosupersub \ulnone \outl0\strokewidth0 \strokec4 et retourne la variable 
+\f5\b \cf10 \strokec10 list 
+\f8\b0 \cf4 \strokec4 avec toute la collection de mots trouv\'e9s:\cf3 \strokec3  \cf4 \strokec4  
+\f5\b \cf3 \strokec3 return
+\f8\b0 \cf4 \strokec4  
+\f5\b \cf10 \strokec10 list\
+}

episode-001/reponse-decoupage-mot/response-thomas-boutdecode.md

@@ -0,0 +1,87 @@
+```
+local function strsplit(delimiter, text)
+	if delimiter == "" then
+		error("delimiter matches empty string!")
+	end
+	local list, pos, first, last = {}, 1
+	while true do
+		first, last = text:find(delimiter, pos, true)
+		if first then -- found?
+			table.insert(list, text:sub(pos, first - 1))
+			pos = last + 1
+		else
+			table.insert(list, text:sub(pos))
+			break
+		end
+	end
+	return list
+end
+M.private.strsplit = strsplit
+```
+
+## statements
+### keyword:
+`local` `function` `if...then..[else]...end` `while...do...end` `return` `break` `private`
+
+### operators/symbols:
+`==` `.` `=` `,` `.` `:` `+` `-` `()` `--`
+
+Éléments syntaxiques du langage qui permettent d'effectuer une action détérminé par
+l'interpréteur ou le compilateur, selon qu'il s'agisse d'un langage scripté ou compilé.
+Il peut s'agir d'un nom ou d'un symbole que l'on applique à 0 ou plusieurs opérandes.
+
+Ces opérandes peuvent être des valeurs, des variables ou des expressions composées).
+
+J'ai regroupé les opérateurs et les keywords dans la même catégorie car leur utilisation
+et syntaxes sont similaires quand bien même, leurs usages peuvent varier grandement et ne
+pas servir, du tout, le même but.
+
+Exemple de ce que j'entend par là : un `+` permet de réduire deux operandes à un seul en
+appliquant une addition tandis qu'un `if` permet, en fonction d'un opérande booléen de
+décider d'éxecuter un set d'opérandes plutôt qu'un autre.
+
+Peut-être pouvons-nous parler de compound statement pour les (`if`/`while`)... ? ;D
+
+#### Exemple `+`:
+```
+operand operator operand
+
+3 + 2
+```
+
+
+#### Exemple `while...do...end`:
+```
+operator operatand operator
+  operand
+  ...
+  operand
+operator
+
+while operand_1 do
+  operand_2
+  ...
+  operand_n
+end
+```
+
+
+## functions/callable expressions/routines/methods:
+`strsplit` `error` `find` `insert` `sub`
+
+Ces expressions agissent comme un opérateur mais à leur différence, ils ne sont pas
+définies dans la grammaire du langages et ne sont donc pas des mots réservés.
+
+
+## constants/values:
+`true` `""` `"delimiter matches empty string!"` `{}` `1`
+
+Ces noms, au moment de l'éxécution du programme, représentent un état de la mémoire
+invariable. Seules les opérations de lectures sont autorisés.
+
+
+## variables:
+`delimiter` `text` `list` `pos` `first` `last` `table` `M`
+
+Ces noms représentent aussi un état variable de la mémoire. Les actions d'écritures sont
+autorisés autant que les actions de lectures.

episode-001/reponse-decoupage-mot/response-thomas.txt

@@ -0,0 +1,24 @@
+Concernant mes retours, je dirai que j'ai trouvé l'exercice difficile au début, car il m'a manqué un peu de contexte. Du coup, j'ai eu l'impression de devoir faire des choix sur la manière dont j'allais conduire l'exercice avant de pouvoir le commencer. Peut-être est-ce volontaire ?
+
+Mes deux remarques sont d'ailleurs liées à ça.
+
+En tout cas, cela m'a énormément plu de participer à cet exercice et j'attends la suite avec impatience.
+
+Première remarque : j'ai eu du mal à comprendre l'objectif de l'exercice.
+J'aurai bien aimé savoir ce que cet exercice permet d'évaluer chez moi : la compréhension, les connaissances, ou autre(s)... ?
+S'agit-il, plutôt, de récolter des informations pour l'auteur de l'exercice et non pour ses participants, comme une sorte de sondage ou d'expérience ?
+Je rajouterai aussi : que feras-tu des réponses ? Aurons-nous un retour ? ...
+
+Deuxième remarque : doit-on analyser les éléments syntaxique d'un langage de programmation ou spécifiquement de celui du langage utilisé dans le boutdecode ?
+En gros, je me suis demandé si je devais me mettre dans le contexte du langage utilisé et de son paradigme ou si je pouvais y aller plus librement et réfléchir aussi par rapport à des langages dont la grammaire est moins "conventionnelle". Exemple, s'agissait-il d'éléments syntaxique ou de macros ? Et comme je ne connais pas le langage utilisé (existe-t'il ?), j'ai un peu mixé selon mes "goûts" sans forcément attendre de viser juste...
+
+
+Aussi, en me mettant dans la peau de qqn qui part de zéro, je me suis demandé si l'exercice me demandait de :
+  - faire des recherches sur les éléments syntaxique d'un langage de programation au sens large
+  - faire des recherches sur les éléments syntaxique du langage de programmation utilisé dans le boutdecode.txt (à identifier d'abord)
+  - ne pas faire de recherche et répondre à l'instinct (aussi difficile que cela puisse paraître).
+
+Concernant le format, rien à redire, les mails sont au top ! Et si jamais tu souhaites automatiser le tout, je me dis qu'un repo git avec une branche par personne peut être une bonne solution. Il faudrait faire une toute petite doc (3 lignes) pour expliquer comment clone/checkout une branche spécifiquement. Les épisodes seraient alors des dossiers.
+Nous n'aurions qu'à clone notre branche et avec un accès en lecture sur les autres branches nous pourrions voir ce que font les autres (s'ils le permettent).
+
+Voilà, voilà, j'ai fait le tour :)

suivi.md

@@ -0,0 +1,35 @@
+
+Episode 1:
+
+En attente de réponse:
+- Sakada
+- Carole Gombauld
+- Christophe
+- Sarah
+
+Envoyé et répondu:
+- Estelle
+- Alexandra
+- Souley
+- Anna-Livia
+- Étienne puydebois
+- Eric
+- Elodie
+- Thomas
+
+
+Episode 1 phase 2:
+
+A envoyer:
+- Thomas
+- Anna-Livia
+- Étienne puydebois
+- Eric
+- Elodie
+
+En attente de réponse:
+- Souley
+
+Envoyé et répondu:
+- Estelle
+- Alexandra