Discussion :

[XeGregory]

Je développe actuellement un projet qui me tient particulièrement à cœur : EduCode.

EduCode est un environnement pédagogique de programmation, pensé pour faciliter l’apprentissage de l’algorithmique et de la logique informatique, aussi bien pour les débutants que pour les enseignants et apprenants plus avancés.



L’objectif principal :
Rendre la programmation accessible, compréhensible et pédagogique, sans la complexité technique souvent décourageante des outils classiques.

Ce qui fait la spécificité d’EduCode :

• Langage 100 % en français, conçu pour comprendre la logique avant la syntaxe
• Exécution directement dans le navigateur, sans installation
• Un environnement pensé pour l’enseignement, les exercices et la progression pas à pas
• Un interpréteur pédagogique qui met l’accent sur la compréhension des étapes
• Une architecture sécurisée, légère et adaptée à un usage local ou éducatif

EduCode a été conçu dès le départ comme un outil d’aide à l’apprentissage, que ce soit en classe, en autonomie ou dans un cadre de formation.
Le projet est en cours de développement, et chaque évolution vise à améliorer la clarté, la simplicité et l’expérience utilisateur.

Apprendre à coder, c'est avant tout apprendre à penser.

Cette phrase résume toute la démarche d'EduCode. Quand on débute, les plus grandes difficultés ne sont pas de comprendre un algorithme — elles viennent des obstacles syntaxiques, des messages d'erreur cryptiques, des configurations à mettre en place. EduCode cherche à faire disparaître cette friction pour que l'apprenant puisse se concentrer sur l'essentiel : la logique.

https://educode-academie.fr/

[LittleWhite]

Bonjour,

Je voulais tester et je me suis retrouvé à télécharger un zip contenant un .exe. Vous parlez d'une exécution en ligne, du coup, c'est où que je peux tester en ligne ?
Dans la capture suivante : https://educode-academie.fr/assets/image/pasapas.png, je trouve le détail du déroulement du code un peu trop dense.
Sinon, avec quels technologies l'avez vous développé ? Comment analysez-vous votre langage ?

[XeGregory]

Bonjour LittleWhite,

Merci pour votre retour - je réponds point par point

1) « Exécution en ligne » : où tester ?
Quand je dit « en ligne », il s’agit de l’exécution dans le navigateur, mais via un serveur local lancé sur votre machine (pas un service hébergé “dans le cloud”). Le .exe que vous avez trouvé dans le .zip sert justement à démarrer ce serveur local (HTTP), puis vous utilisez l’éditeur depuis votre navigateur.

Guide de démarrage

Pourquoi un serveur local ?
J’aurais pu développer EduCode comme un logiciel 100% "desktop" sans serveur.
Le choix d’un serveur local (HTTP) apporte cependant un avantage majeur : la multi‑connexion.
Une seule instance d’EduCode peut être lancée sur un poste (ex. poste enseignant / poste serveur) et plusieurs utilisateurs peuvent y accéder depuis leurs navigateurs sur le même réseau local.

En résumé : le serveur local permet d’avoir une expérience "web" simple côté utilisateurs, tout en gardant le moteur d’exécution centralisé et contrôlé sur une seule instance, idéal pour un usage multi‑postes / multi‑élèves.

2) « Pas à pas » trop dense
Vous avez raison : le pas à pas affiche volontairement chaque instruction exécutée pour comprendre l’ordre réel d’exécution et l’évolution des variables, mais sur certains programmes ça peut devenir très chargé.

Amélioration déjà prévue côté v1.1 : au-delà de 1000 lignes, les logs sont ignorés, car au-delà ce n’est plus exploitable (lisibilité et performances).
Je vais continuer à l’alléger (idée : niveau de détail / filtrage "instructions clés", regroupement des boucles, etc...).

Avec des boucles, le pas à pas peut exploser en nombre de logs, ce qui complique fortement l’analyse.

Sokoban


Permutations des caractères d'un texte




Ce type de programme peut produire très rapidement un volume de logs considérable (1 000 0000 lignes et plus), rendant l’analyse peu lisible. Le mode pas à pas reste idéal pour de petits cas pédagogiques, mais sur des programmes à boucles, le suivi devient rapidement complexe.

Explication pas à pas

3) Analyse du langage
Côté “moteur”, EduCode s’appuie sur un mini-interpréteur pédagogique comprenant un lexer (analyse lexicale - tokenisation) et un interpréteur exécuteur.

[XeGregory]

Une nouvelle fonctionnalité de lecture et d’explication du code est actuellement en cours de développement.

Elle permettra de parcourir un programme ligne par ligne, d’en afficher la structure logique, et de fournir une lecture pédagogique et compréhensible des instructions, avec indentation automatique et explications en langage naturel.

Cette évolution vise à faciliter la compréhension du code, en particulier pour les débutants, et sera disponible dans une prochaine mise à jour d’EduCode.

[XeGregory]

Le problème des 8 reines. ♟️
Un problème posé en 1848 par un joueur d'échecs.
Toujours enseigné 175 ans plus tard dans les cours d'algorithmique.

La règle :
- Place 8 reines sur un échiquier.
- Aucune ne doit pouvoir en capturer une autre.

J'ai codé la solution en EduCode.
Et ce qui m'a le plus frappé :
Le programme ne «réfléchit» pas.
Il essaie. Il échoue. Il recule. Il réessaie.

C'est ça le backtracking :
- On place une reine ligne par ligne
- On vérifie : même colonne ? même diagonale ?
- Si invalide : on efface et on essaie la colonne suivante
- Si on est bloqué : on remonte d'une ligne et on change

Comme un labyrinthe.
On avance tant qu'on peut.
On revient sur ses pas dès qu'on est bloqué.

Résultat ?
92 solutions différentes. Toutes trouvées.
Parfois les meilleurs algorithmes ressemblent à de la persévérance organisée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
// ============================================
// LE PROBLEME DES 8 REINES - Backtracking
// Programme EduCode
// ============================================

// Un echiquier 8x8
// Placer 8 reines sans qu'aucune ne s'attaque
// Algorithme : backtracking (retour arriere)

// ============================================
// VARIABLES GLOBALES
// ============================================

taille est une constante vaut 8
// reines[i] = colonne de la reine sur la ligne i
reines est un tableau
i, nb_solutions est un nombre
pour i de 0 à taille - 1
  reines[i] vaut -1
fin pour

nb_solutions vaut 0
afficher_toutes est un booléen
afficher_toutes vaut faux

// ============================================
// FONCTIONS
// ============================================

// Verifie si on peut placer une reine ligne l, colonne c
fonction estValide(ligne, col)
  i est un nombre
  pour i de 0 à ligne - 1
    // Meme colonne
    si reines[i] = col alors
      retourne faux
    fin si
    // Diagonale gauche
    si reines[i] = col - (ligne - i) alors
      retourne faux
    fin si
    // Diagonale droite
    si reines[i] = col + (ligne - i) alors
      retourne faux
    fin si
  fin pour
  retourne vrai
fin fonction

// ============================================
// PROCEDURES
// ============================================

// Dessine l echiquier avec les reines placees
procédure dessinerEchiquier(num)
  affiche ''
  affiche '  Solution n ' + num
  affiche '  +---+---+---+---+---+---+---+---+'
  ligne, col est un nombre
  pour ligne de 0 à taille - 1
    lig, positions est un texte
    lig vaut '  |'
    pour col de 0 à taille - 1
      si reines[ligne] = col alors
        lig vaut lig + ' Q |'
      sinon si (ligne + col) % 2 = 0 alors
        lig vaut lig + '   |'
      sinon
        lig vaut lig + ' . |'
      fin si
    fin pour
    affiche lig
    affiche '  +---+---+---+---+---+---+---+---+'
  fin pour
  affiche '    a   b   c   d   e   f   g   h'
  affiche ''
  // Affiche les positions des reines
  positions vaut '  Positions : '
  pour ligne de 0 à taille - 1
    col est un nombre
    col vaut reines[ligne]
    lettre est un texte
    si col = 0 alors
      lettre vaut 'a'
    sinon si col = 1 alors
      lettre vaut 'b'
    sinon si col = 2 alors
      lettre vaut 'c'
    sinon si col = 3 alors
      lettre vaut 'd'
    sinon si col = 4 alors
      lettre vaut 'e'
    sinon si col = 5 alors
      lettre vaut 'f'
    sinon si col = 6 alors
      lettre vaut 'g'
    sinon
      lettre vaut 'h'
    fin si
    positions vaut positions + lettre + (ligne + 1) + ' '
  fin pour
  affiche positions
  affiche ''
fin procédure

// Algorithme de backtracking
procédure resoudre(ligne)
  si ligne = taille alors
    // Toutes les reines sont placees : solution trouvee !
    nb_solutions ajoute 1
    si nb_solutions <= 3 ou afficher_toutes alors
      appelle dessinerEchiquier(nb_solutions)
    sinon si nb_solutions = 4 alors
      affiche '  ... (autres solutions non affichees) ...'
      affiche ''
    fin si
  sinon
    col est un nombre
    pour col de 0 à taille - 1
      si estValide(ligne, col) alors
        reines[ligne] vaut col
        appelle resoudre(ligne + 1)
        reines[ligne] vaut -1
      fin si
    fin pour
  fin si
fin procédure

// Affiche l echiquier vide avec une tentative
procédure dessinerTentative(ligne, col, valide)
  affiche '  +---+---+---+---+---+---+---+---+'
  l, c est un nombre
  pour l de 0 à ligne
    lig est un texte
    lig vaut '  |'
    pour c de 0 à taille - 1
      si l < ligne et reines[l] = c alors
        lig vaut lig + ' Q |'
      sinon si l = ligne et c = col alors
        si valide alors
          lig vaut lig + ' Q |'
        sinon
          lig vaut lig + ' X |'
        fin si
      sinon si (l + c) % 2 = 0 alors
        lig vaut lig + '   |'
      sinon
        lig vaut lig + ' . |'
      fin si
    fin pour
    affiche lig
    affiche '  +---+---+---+---+---+---+---+---+'
  fin pour
  si valide alors
    affiche '  -> Position valide ! On continue...'
  sinon
    affiche '  -> Position invalide (attaque). On recule.'
  fin si
  affiche ''
fin procédure

// Demonstration pas a pas des premiers coups
procédure demonstrationPasAPas()
  affiche repeter_texte('=', 50)
  affiche '  DEMONSTRATION PAS A PAS - Ligne 1'
  affiche repeter_texte('=', 50)
  affiche ''
  affiche '  On essaie de placer la 1ere reine...'
  affiche ''

  // Essai ligne 0, col 0 : valide
  reines[0] vaut 0
  affiche '  Essai : ligne 1, colonne a'
  appelle dessinerTentative(0, 0, vrai)

  // Essai ligne 1, col 0 : invalide (meme colonne)
  affiche '  Essai : ligne 2, colonne a'
  appelle dessinerTentative(1, 0, faux)

  // Essai ligne 1, col 1 : invalide (diagonale)
  affiche '  Essai : ligne 2, colonne b'
  appelle dessinerTentative(1, 1, faux)

  // Essai ligne 1, col 2 : valide
  reines[1] vaut 2
  affiche '  Essai : ligne 2, colonne c -> OK !'
  appelle dessinerTentative(1, 2, vrai)

  // Reset
  reines[0] vaut -1
  reines[1] vaut -1
fin procédure

// ============================================
// PROGRAMME PRINCIPAL
// ============================================

affiche ''
affiche '  *** LE PROBLEME DES 8 REINES ***'
affiche ''
affiche '  Regles :'
affiche '  -> Placer 8 reines sur un echiquier 8x8'
affiche '  -> Aucune reine ne doit en attaquer une autre'
affiche '  -> Ni sur la meme ligne, colonne ou diagonale'
affiche ''
affiche '  Algorithme : BACKTRACKING (retour arriere)'
affiche '  On place, on teste, on recule si invalide.'
affiche ''

// Demonstration pas a pas
appelle demonstrationPasAPas()

// Resolution complete
affiche repeter_texte('=', 50)
affiche '  RESOLUTION COMPLETE'
affiche repeter_texte('=', 50)
affiche '  Recherche de toutes les solutions...'
affiche ''

appelle resoudre(0)

affiche repeter_texte('*', 50)
affiche '  BILAN FINAL'
affiche repeter_texte('*', 50)
affiche ''
affiche '  Nombre total de solutions : ' + nb_solutions
affiche ''
affiche '  Pour un echiquier NxN :'
affiche '  4x4 ->   2 solutions'
affiche '  5x5 ->  10 solutions'
affiche '  6x6 ->   4 solutions'
affiche '  7x7 ->  40 solutions'
affiche '  8x8 ->  92 solutions'
affiche '  9x9 -> 352 solutions'
affiche ''
affiche '  Le backtracking explore toutes les'
affiche '  possibilites en eliminant les branches'
affiche '  invalides le plus tot possible.'
affiche ''
affiche '  Fin du programme.'