Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Une scientifique propose un nouveau langage de programmation pour enseigner aux enfants le codage informatique
Au travers d'une approche graduelle implémentée en Python sur 13 paliers

Le , par Patrick Ruiz

44PARTAGES

8  0 
L’une des barrières les plus importantes à l’accès à la filière de la programmation informatique pour les débutants est la syntaxe des langages dont on fait usage. La nécessité de sa prise en compte met très vite le novice face à des problèmes de pure implémentation. C’est pour contourner cette difficulté que le Conseil supérieur des programmes de France a proposé Python comme langage officiel de l’enseignement de la programmation. Motif : le langage est simple d’usage et concis. Hedy, un nouveau langage de programmation, fait encore plus simple pour faciliter l’apprentissage du codage informatique aux enfants : il propose d'apprendre la programmation en parcourant 13 paliers d'un langage très proche de Python.

Le langage de programmation proposé par la scientifique Felienne Hermans est implémenté en Python. L’auteur s’appuie sur un outil d’analyse syntaxique dénommé Lark. Le code Hedy (c’est le nom du langage) est analysé par ce dernier et transpilé dans le langage de la création de Guido Van Rossum. De façon ramassée, faire référence à Hedy c’est toucher à Python, la précision étant que le premier propose plusieurs niveaux de difficultés du deuxième aux apprenants.

« Hedy est un langage de programmation graduel destiné à l'enseignement de la programmation et à l'apprentissage de Python. Il enseigne en utilisant différents niveaux. Le premier propose simplement d'imprimer du texte et de demander des entrées. Ce niveau est destiné à introduire les apprenants à l'idée d'un langage de programmation ainsi qu'à l'environnement. À partir de là, Hedy se développe pour inclure une syntaxe plus complexe et des concepts supplémentaires », commentaire l’auteur. Illustration avec le contenu grammatical mis à la disposition des apprenants au premier niveau de l’apprentissage :



Grosso modo, le langage Hedy vient renforcer l’idée selon laquelle la programmation informatique ferait plus appel à des qualités linguistiques qu’aux compétences en mathématiques. Une autre étude parue plus tôt dans l’année est à nouveau venue le mettre en avant.

« C'est parce que l’écriture du code informatique implique également l'apprentissage d'une seconde langue, la capacité d'apprendre le vocabulaire et la grammaire de cette langue et la façon dont ils travaillent ensemble pour communiquer des idées et des intentions. La recherche décrite ici est motivée par un changement de paradigme conceptuel, à savoir que l'apprentissage des langages de programmation modernes ressemble à l'apprentissage d'une langue naturelle, comme le français ou le chinois, à l'âge adulte. De façon plus précise, nous soutenons que la recherche sur les bases neurocognitives de l'aptitude à la programmation a largement omis le fait que les langages de programmation informatique sont conçus pour ressembler à la structure de communication du programmeur (les langages humains) », expliquaient les chercheurs.

La série de conclusions de cette étude résultait d’une batterie de tests centrés autour du langage Python. Les chercheurs y avaient soumis une trentaine d’adultes n’ayant jamais appris à coder, ce, pour évaluer leurs compétences cognitives sur divers axes (compétences mathématiques, linguistiques, attention, résolution de problèmes, mémoire...). Il en était ressorti que ceux qui ont appris Python le plus rapidement et avec une grande précision sont ceux qui possèdent un mélange de fortes capacités de résolution de problèmes et d’apprentissage de langues étrangères. Felienne Hermans s’étend en explications sur ce lien entre apprentissage des langues et apprentissage de la programmation informatique dans le cadre d’une présentation lors de l’édition 2020 de la conférence internationale de recherche sur l’enseignement de l’informatique. Les contenus proposés suggèrent que l’on gagnerait à mettre sur pied des moyens d’apprentissage comme Hedy pour amener plus d’enfants à choisir la filière programmation informatique plus tard.


Hedy est téléchargeable avec en sus la possibilité de l’associer à un environnement de développement intégré. L’on a également la possibilité de programmer en Hedy via une interface dans le navigateur

Code Python : Sélectionner tout
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
from lark import Lark
from lark.exceptions import VisitError, LarkError
from lark import Tree, Transformer, Visitor
from lark.indenter import Indenter
 
reserved_words = ['and','except','lambda','with','as','finally','nonlocal','while','assert','false','None','yield','break','for','not','class','from','or','continue','global','pass','def','if','raise','del','import','return','elif','in','True','else','is','try']
 
def closest_command(command, commands):
    #simple string distance, could be more sophisticated MACHINE LEARNING!
    min = 1000
    min_command = ''
    for c in commands:
        min_c = minimum_distance(c, command)
        if min_c < min:
            min = min_c
            min_command = c
    return min_command
 
def minimum_distance(s1, s2):
    if len(s1) > len(s2):
        s1, s2 = s2, s1
    distances = range(len(s1) + 1)
    for index2, char2 in enumerate(s2):
        new_distances = [index2 + 1]
        for index1, char1 in enumerate(s1):
            if char1 == char2:
                new_distances.append(distances[index1])
            else:
                new_distances.append(1 + min((distances[index1], distances[index1 + 1], new_distances[-1])))
        distances = new_distances
    return distances[-1]
 
class HedyException(Exception):
    def __init__(self, message, **arguments):
        self.error_code = message
        self.arguments = arguments
 
class ExtractAST(Transformer):
    # simplyfies the tree: f.e. flattens arguments of text, var and punctuation for further processing
    def text(self, args):
        return Tree('text', [''.join([str(c) for c in args])])
 
    #level 2
    def var(self, args):
        return Tree('var', [''.join([str(c) for c in args])])
    def punctuation(self, args):
        return Tree('punctuation', [''.join([str(c) for c in args])])
    def index(self, args):
        return ''.join([str(c) for c in args])
    def list_access(self, args):
        if type(args[1]) == Tree:
            return Tree('list_access', [args[0], 'random'])
        else:
            return Tree('list_access', [args[0], args[1]])
 
    #level 5
    def number(self, args):
        return Tree('number', ''.join([str(c) for c in args]))
    #level 6 (and up)
    def indent(self, args):
        return ''
    def dedent(self, args):
        return ''
 
def flatten(args):
    flattened_args = []
    if isinstance(args, str):
        return args
    elif isinstance(args, Tree):
        return args
    else:
        for a in args:
            if type(a) is list:
                for x in a:
                    flattened_args.append(flatten(x))
            else:
                flattened_args.append(a)
        return flattened_args
 
class AllAssignmentCommands(Transformer):
    # returns only variable assignments AND places where variables are accessed
    # so these can be excluded when printing
 
    def program(self, args):
        return flatten(args)
 
    def repeat(self, args):
        commands = args[1:]
        return flatten(commands)
 
    def command(self, args):
        return flatten(args)
 
    def ask(self, args):
        #todo: this also uses this arg for level 1, where it should not be used
        #(since then it has no var as 1st argument)
        #we should actually loop the level in here to distinguish on
        return args[0].children
    def assign(self, args):
        return args[0].children
    def assign_list(self, args):
        return args[0].children
    def list_access_var(self, args):
        return args[0].children
    def var_access(self,args):
        return args[0].children
 
    #list access is accessing a variable, so must be escaped
    def list_access(self, args):
        listname = args[0].children[0]
        if args[1] == 'random':
            return 'random.choice(' + listname + ')'
        else:
            return listname + '[' + args[1] + ']'
    def print(self, args):
        return args
 
 
def create_parser(level):
    with open(f"grammars/level{str(level)}.txt", "r") as file:
        grammar = file.read()
    return Lark(grammar)
 
def all_arguments_true(args):
    bool_arguments = [x[0] for x in args]
    arguments_of_false_nodes = [x[1] for x in args if not x[0]]
    return all(bool_arguments), arguments_of_false_nodes
 
# this class contains code shared between IsValid and IsComplete, which are quite similar
# because both filter out some types of 'wrong' nodes
class Filter(Transformer):
    def program(self, args):
        bool_arguments = [x[0] for x in args]
        if all(bool_arguments):
            return [True] #all complete
        else:
            command_num = 1
            for a in args:
                if not a[0]:
                    return False, a[1], command_num
                command_num += 1
 
    def command(self, args):
        return all_arguments_true(args)
 
    def assign(self, args):
        return all_arguments_true(args)
    def assign_list(self, args):
        return all_arguments_true(args)
    def assign_sum(self, args):
        return all_arguments_true(args)
    def list_access(self, args):
        return all_arguments_true(args)
 
    # level 4 commands
    def list_access_var(self, args):
        return all_arguments_true(args)
    def ifs(self, args):
        return all_arguments_true(args)
    def ifelse(self, args):
        return all_arguments_true(args)
    def condition(self, args):
        return all_arguments_true(args)
    def equality_check(self, args):
        return all_arguments_true(args)
    def in_list_check(self, args):
        return all_arguments_true(args)
 
    # level 5 command
    def repeat(self, args):
        return all_arguments_true(args)
 
    # level 6
    def addition(self, args):
        return all_arguments_true(args)
    def substraction(self, args):
        return all_arguments_true(args)
    def multiplication(self, args):
        return all_arguments_true(args)
    def division(self, args):
        return all_arguments_true(args)
 
    #leafs are treated differently, they are True + their arguments flattened
    def random(self, args):
        return True, 'random'
    def index(self, args):
        return True, ''.join([str(c) for c in args])
    def punctuation(self, args):
        return True, ''.join([c for c in args])
    def number(self, args):
        return True, ''.join([c for c in args])
    def invalid(self, args):
        # return the first argument to place in the error message
        # TODO: this will not work for misspelling 'at', needs to be improved!
        return False, args[0][1]
 
class IsValid(Filter):
    # all rules are valid except for the invalid production rule
    # this function is used to generate more informative error messages
    # tree is transformed to a node of [Bool, args, linenumber]
 
    #would be lovely if there was some sort of default rule! Not sure Lark supports that
 
    def ask(self, args):
        return all_arguments_true(args)
    def print(self, args):
        return all_arguments_true(args)
    def echo(self, args):
        return all_arguments_true(args)
 
 
    #leafs with tokens need to be all true
    def var(self, args):
        return all(args), ''.join([c for c in args])
    def text(self, args):
        return all(args), ''.join([c for c in args])
    def addition(self, args):
        return all(args), ''.join([c for c in args])
 
    def invalid_space(self, args):
        # return space to indicate that line start in a space
        return False, " "
 
 
class IsComplete(Filter):
    # print, ask an echo can miss arguments and then are not complete
    # used to generate more informative error messages
    # tree is transformed to a node of [True] or [False, args, line_number]
 
    #would be lovely if there was some sort of default rule! Not sure Lark supports that
 
    def ask(self, args):
        return args != [], 'ask'
    def print(self, args):
        return args != [], 'print'
    def echo(self, args):
        #echo may miss an argument
        return True, 'echo'
 
    #leafs with tokens need to be all true
    def var(self, args):
        return all(args), ''.join([c for c in args])
    def text(self, args):
        return all(args), ''.join([c for c in args])
    def addition(self, args):
        return all(args), ''.join([c for c in args])
 
 
class ConvertToPython_1(Transformer):
    def __init__(self, punctuation_symbols, lookup):
        self.punctuation_symbols = punctuation_symbols
        self.lookup = lookup
 
    def program(self, args):
        return '\n'.join([str(c) for c in args])
    def command(self, args):
        return args
    def text(self, args):
        return ''.join([str(c) for c in args])
    def print(self, args):
        return "print('" + args[0] + "')"
    def echo(self, args):
        all_parameters = ["'" + a + "'+" for a in args]
        return "print(" + ''.join(all_parameters) + "answer)"
    def ask(self, args):
        all_parameters = ["'" + a + "'" for a in args]
        return 'answer = input(' + '+'.join(all_parameters) + ")"
 
def wrap_non_var_in_quotes(argument, lookup):
    if argument in lookup:
        return argument
    else:
        return "'" + argument + "'"
 
class ConvertToPython_2(ConvertToPython_1):
    def punctuation(self, args):
        return ''.join([str(c) for c in args])
    def var(self, args):
        name = ''.join(args)
        return "_" + name if name in reserved_words else name
    def print(self, args):
        all_arguments_converted = []
        i = 0
        for argument in args:
            if i == len(args)-1 or args[i+1] in self.punctuation_symbols:
                space = ''
            else:
                space = "+' '"
            all_arguments_converted.append(wrap_non_var_in_quotes(argument, self.lookup) + space)
            i = i + 1
        return 'print(' + '+'.join(all_arguments_converted) + ')'
    def ask(self, args):
        var = args[0]
        all_parameters = ["'" + a + "'" for a in args[1:]]
        return f'{var} = input(' + '+'.join(all_parameters) + ")"
    def assign(self, args):
        parameter = args[0]
        value = args[1]
        return parameter + " = '" + value + "'"
    def assign_list(self, args):
        parameter = args[0]
        values = ["'" + a + "'" for a in args[1:]]
        return parameter + " = [" + ", ".join(values) + "]"
 
    def list_access(self, args):
        if args[1] == 'random':
            return 'random.choice(' + args[0] + ')'
        else:
            return args[0] + '[' + args[1] + ']'
 
 
 
#TODO: lookuptable and punctuation chars not be needed for level2 and up anymore, could be removed
class ConvertToPython_3(ConvertToPython_2):
    def text(self, args):
        return ''.join([str(c) for c in args])
    def print(self, args):
        #opzoeken is nu niet meer nodig
        return "print(" + '+'.join(args) + ')'
 
def indent(s):
    lines = s.split('\n')
    return '\n'.join(['  ' + l for l in lines])
 
class ConvertToPython_4(ConvertToPython_3):
    def list_access_var(self, args):
        var = args[0]
        if args[2].data == 'random':
            return var + '=random.choice(' + args[1] + ')'
        else:
            return var + '=' + args[1] + '[' + args[2].children[0] + ']'
    def ifs(self, args):
        return f"""if {args[0]}:
{indent(args[1])}"""
    def ifelse(self, args):
        return f"""if {args[0]}:
{indent(args[1])}
else:
{indent(args[2])}"""
    def condition(self, args):
        return ' and '.join(args)
    def equality_check(self, args):
        arg0 = wrap_non_var_in_quotes(args[0], self.lookup)
        arg1 = wrap_non_var_in_quotes(args[1], self.lookup)
        return f"{arg0} == {arg1}" #no and statements
    def in_list_check(self, args):
        arg0 = wrap_non_var_in_quotes(args[0], self.lookup)
        arg1 = wrap_non_var_in_quotes(args[1], self.lookup)
        return f"{arg0} in {arg1}"
 
class ConvertToPython_5(ConvertToPython_4):
    def number(self, args):
        return ''.join(args)
 
    def repeat(self, args):
        times = wrap_non_var_in_quotes(args[0], self.lookup)
        command = args[1]
        return f"""for i in range(int({str(times)})):
{indent(command)}"""
 
class ConvertToPython_6(ConvertToPython_5):
 
    def print(self, args):
        #force all to be printed as strings (since there can not be int arguments)
        args_new = []
        for a in args:
            if type(a) is Tree:
                args_new.append(f'str({a.children})')
            elif "'" not in a:
                args_new.append(f'str({a})')
            else:
                args_new.append(a)
 
        return "print(" + '+'.join(args_new) + ')'
 
    #we can now have ints as types so chck must force str
    def equality_check(self, args):
        arg0 = wrap_non_var_in_quotes(args[0], self.lookup)
        arg1 = wrap_non_var_in_quotes(args[1], self.lookup)
        if len(args) == 2:
            return f"str({arg0}) == str({arg1})" #no and statements
        else:
            return f"str({arg0}) == str({arg1}) and {args[2]}"
 
    def assign(self, args):
        if len(args) == 2:
            parameter = args[0]
            value = args[1]
            if type(value) is Tree:
                return parameter + " = " + value.children
            else:
                return parameter + " = '" + value + "'"
        else:
            parameter = args[0]
            values = args[1:]
            return parameter + " = [" + ", ".join(values) + "]"
 
 
    def addition(self, args):
        return Tree('sum', f'int({str(args[0])}) + int({str(args[1])})')
 
    def substraction(self, args):
        return Tree('sum', f'int({str(args[0])}) - int({str(args[1])})')
 
    def multiplication(self, args):
        return Tree('sum', f'int({str(args[0])}) * int({str(args[1])})')
 
    def division(self, args):
        return Tree('sum', f'int({str(args[0])}) // int({str(args[1])})')
 
class ConvertToPython_7(ConvertToPython_6):
    def __init__(self, punctuation_symbols, lookup, indent_level):
        self.punctuation_symbols = punctuation_symbols
        self.lookup = lookup
        self.indent_level = indent_level
 
    def indent(self, args):
        self.indent_level += 1
        return ""
 
    def dedent(self, args):
        self.indent_level -= 1
        return ""
 
    def command(self, args):
        return "".join([self.indent_level * "    " + x for x in args if x != ""])
 
    def repeat(self, args):
        args = [a for a in args if a != ""]  # filter out in|dedent tokens
        return "for i in range(int(" + str(args[0]) + ")):\n" + "\n".join(args[1:])
 
    def ifs(self, args):
        args = [a for a in args if a != ""] # filter out in|dedent tokens
        return "if " + args[0] + ":\n" + "\n".join(args[1:])
 
    def elses(self, args):
        args = [a for a in args if a != ""]  # filter out in|dedent tokens
        return "\nelse:\n" + "\n".join(args)
 
    def assign(self, args): #TODO: needs to be merged with 6, when 6 is improved to with printing exprestions directly
        if len(args) == 2:
            parameter = args[0]
            value = args[1]
            if type(value) is Tree:
                return parameter + " = " + value.children
            else:
                if "'" in value or 'random.choice' in value: #TODO: should be a call to wrap nonvarargument is quotes!
                    return parameter + " = " + value
                else:
                    return parameter + " = '" + value + "'"
        else:
            parameter = args[0]
            values = args[1:]
            return parameter + " = [" + ", ".join(values) + "]"
 
    def var_access(self, args):
        if len(args) == 1: #accessing a var
            return wrap_non_var_in_quotes(args[0], self.lookup)
            # this was used to produce better error messages, but needs more work
            # (because plain text strings are now also var_access and not textwithoutspaces
            # since we no longer have priority rules
            # if args[0] in self.lookup:
            #     return args[0]
            # else:
            #     raise HedyException('VarUndefined', level=7, name=args[0])
        else:
        # dit was list_access
            return args[0] + "[" + str(args[1]) + "]" if type(args[1]) is not Tree else "random.choice(" + str(args[0]) + ")"
 
class ConvertToPython(Transformer):
 
    def start(self, args):
        return "".join(args)
 
    def statement(self, args):
        return "".join([self.indent_level * "\t" + x + ("\n" if x[-1] != '\n' else "") for x in args if x != ""])
 
    def if_statement(self, args):
        return "if " + args[0] + ":\n" + "".join(args[1:])
 
    def elif_statement(self, args):
        return "elif " + args[0] + ":\n" + "".join(args[1:])
 
    def else_statement(self, args):
        return "else:\n" + "".join(args)
 
    def repeat(self, args):
        return "for i in range(" +args[0] + "):\n" + "".join(args[1:])
 
    def ranged_loop(self, args):
        return "for " + args[0] + " in range(" + args[1] + "," + args[2] +  "):\n" + "".join(args[3:])
 
    def assignment(self, args):
        return args[0] + "=" + str(args[1])
 
    # for now. expressions to Bool are not implemented (not sure we'd need them until 13)
    # def eq(self, args):
    #     return str(args[0]) + "==" + str(args[1])
    #
    # def ne(self, args):
    #     return str(args[0]) + "!=" + str(args[1])
    #
    # def le(self, args):
    #     return str(args[0]) + "<=" + str(args[1])
    #
    # def ge(self, args):
    #     return str(args[0]) + ">=" + str(args[1])
    #
    # def lt(self, args):
    #     return str(args[0]) + "<" + str(args[1])
    #
    # def gt(self, args):
    #     return str(args[0]) + ">" + str(args[1])
 
    # migrated to level 6
    # def addition(self, args):
    #     return str(args[0]) + "+" + str(args[1])
    #
    # def substraction(self, args):
    #     return str(args[0]) + "-" + str(args[1])
    #
    # def multiplication(self, args):
    #     return str(args[0]) + "*" + str(args[1])
    #
    # def division(self, args):
    #     return str(args[0]) + "/" + str(args[1])
 
    def list(self, args):
        return str(args)
 
    def list_access(self, args):
        return  args[0] + "[" + str(args[1]) + "]" if args[1] != "random" else "random.choice(" + str(args[0]) + ")"
 
    def function_call(self, args):
        return args[0] + "(" + ", ".join(args[1:]) + ")"
 
    def INTEGER(self, args):
        return int(args.value)
 
    def FLOAT(self, args):
        return float(args.value)
 
    def NAME(self, args):
        return str(args.value)
 
    def STRING(self, args):
        return args.value
 
    def INDENT(self, args):
        self.indent_level += 1
        return ""
 
    def DEDENT(self, args):
        self.indent_level -= 1
        return ""
 
class BasicIndenter(Indenter):
    NL_type = "_EOL"
    OPEN_PAREN_types = []
    CLOSE_PAREN_types = []
    INDENT_type = "INDENT"
    DEDENT_type = "DEDENT"
    tab_len = 4
 
def create_grammar(level):
    with open("grammars/level" + str(level) + ".txt", "r") as file:
        return file.read()
 
def transpile(input_string, level):
    try:
        return transpile_inner(input_string, level)
    except Exception as E:
        #we retry HedyExceptions of the type Parse (and Lark Errors) but we raise Invalids
        if E.args[0] == 'Parse':
            #try 1 level lower
            if level > 1:
                try:
                    new_level = level-1
                    result = transpile_inner(input_string, level-1)
                    raise HedyException('Wrong Level', correct_code = result, original_level=level, working_level=new_level)
                except LarkError as e:
                    raise HedyException('Parse', level=level, parse_error=e.args[0])
            else:
                raise E
        else:
            raise E
 
def repair(input_string):
    #the only repair we can do now is remove leading spaces, more can be added!
    return '\n'.join([x.lstrip() for x in input_string.split('\n')])
 
 
 
def transpile_inner(input_string, level):
    if level <= 6:
        punctuation_symbols = ['!', '?', '.']
        level = int(level)
        parser = Lark(create_grammar(level))
 
        try:
            program_root = parser.parse(input_string+ '\n').children[0]  # getting rid of the root could also be done in the transformer would be nicer
            abstract_syntaxtree = ExtractAST().transform(program_root)
            lookup_table = AllAssignmentCommands().transform(abstract_syntaxtree)
 
        except Exception as e:
            # TODO: if all else fails, here we could translate Lark error messages into more sensible texts!
            raise HedyException('Parse', level=level, parse_error=e.args[0])
 
        is_valid = IsValid().transform(program_root)
        if not is_valid[0]:
            if is_valid[1] == ' ':
                line = is_valid[2]
                #the error here is a space at the beginning of a line, we can fix that!
 
                fixed_code = repair(input_string)
                if fixed_code != input_string: #only if we have made a successful fix
                    result = transpile_inner(fixed_code, level)
                raise HedyException('Invalid Space', level=level, line_number=line, fixed_code = result)
            else:
                invalid_command = is_valid[1]
                closest = closest_command(invalid_command, ['print', 'ask', 'echo'])
                raise HedyException('Invalid', invalid_command=invalid_command, level=level, guessed_command=closest)
 
        is_complete = IsComplete().transform(program_root)
        if not is_complete[0]:
            incomplete_command = is_complete[1]
            line = is_complete[2]
            raise HedyException('Incomplete', incomplete_command=incomplete_command, level=level, line_number=line)
 
 
 
        if level == 1:
            python = ConvertToPython_1(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
        elif level == 2:
            python = 'import random\n'
            python += ConvertToPython_2(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
        elif level == 3:
            python = 'import random\n'
            python += ConvertToPython_3(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
        elif level == 4:
            python = 'import random\n'
            python += ConvertToPython_4(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
        elif level == 5:
            python = 'import random\n'
            python += ConvertToPython_5(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
        elif level == 6:
            python = 'import random\n'
            python += ConvertToPython_6(punctuation_symbols, lookup_table).transform(abstract_syntaxtree)
            return python
 
    #todo: we need to be able to 'valid check' levels 6 and 8+ also, skipping for now (requires changes to grammar)
    elif level >= 7:
        parser = Lark(create_grammar(level), parser='lalr', postlex=BasicIndenter(), debug=True)
        punctuation_symbols = ['!', '?', '.']
        program_root = parser.parse(input_string + '\n').children[0]  # TODO: temporary fix, statements have to end with _EOL
        abstract_syntaxtree = ExtractAST().transform(program_root)
        lookup_table = AllAssignmentCommands().transform(abstract_syntaxtree)
        if level == 7:
            try:
                python = 'import random\n'
                result = ConvertToPython_7(punctuation_symbols, lookup_table, 0).transform(program_root)
                return python + result
            except VisitError as E:
                raise E.orig_exc
    else:
        raise Exception('Levels over 7 are not implemented yet')
 
 
def execute(input_string):
    python = transpile(input_string)
    exec(python)
 
 
# f = open('output.py', 'w+')
# f.write(python)
# f.close()

Hedy vient allonger une liste de langages de programmation pour enfants dans laquelle on retrouve Scratch, MiniJava ou encore LOGO. D’avis d’observateurs, Hedy n’apporte rien de plus que des langages comme Python sur l’axe auquel le langage prétend apporter des réponses. Pascal aurait été conçu pour des besoins similaires, à savoir l’enseignement de la programmation informatique. C’est le choix des décideurs de l’écarter des programmes de formation qui serait le plus à questionner.

Sources : publication, GitHub

Et vous ?

Doué en apprentissage de langues donc doué en programmation informatique : qu’en pensez-vous ?
Quelles sont les aptitudes en langues qui vous ont été les plus utiles en tant qu’acteur de la filière programmation informatique ?
Que pensez-vous des initiatives comme Hedy ? Partagez-vous aussi l'avis que c'est le type d'initiative qu'il faut à la filière programmation informatique pour s'assurer d'avoir des travailleurs de qualité ?

Voir aussi :

Les professeurs des classes prépas alertent sur le faible niveau en sciences du bac S, une menace pour l'enseignement supérieur en informatique ?
Réforme du lycée : les maths ne sont-elles utiles que dans les domaines scientifiques et informatiques pour être reléguées au rang de spécialité ?
Que faire pour minimiser l'impact des interruptions sur l'activité de développement de logiciels ? Appliquer les méthodes Agile ?
Y a-t-il une corrélation entre diplôme et succès en tant que développeur de logiciels ? Un acteur de la sphère donne son avis
Pourquoi réécrire un projet en partant de zéro ? Parce que l'ancien code est un fatras ou qu'il est plus facile d'écrire que de lire un code ?
Que pensez-vous des formations intensives en programmation ? Sont-elles plus efficaces que les formations classiques en informatique ?

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Math71
Membre régulier https://www.developpez.com
Le 18/08/2020 à 14:24
Citation Envoyé par Patrick Ruiz Voir le message
Doué en apprentissage de langues donc doué en programmation informatique : qu’en pensez-vous ?
Dans mes études, j'ai toujours été le meilleur en développement, mais l'un des plus mauvais en langue (et mauvais dans le sens très mauvais, que ce soit au BAC ou en étude supérieur, je n'ai jamais eu la moyenne en anglais). Donc soit j'ai loupé quelques chose avec les cours d'anglais soit l'étude ne veux rien dire du tout...

Citation Envoyé par Patrick Ruiz Voir le message
Quelles sont les aptitudes en langues qui vous ont été les plus utiles en tant qu’acteur de la filière programmation informatique ?
Aucune....
Je me sert juste des mes maigres connaissances d'anglais pour lire les docs...

Citation Envoyé par Patrick Ruiz Voir le message
Que pensez-vous des initiatives comme Hedy ? Partagez-vous aussi l'avis que c'est le type d'initiative qu'il faut à la filière programmation informatique pour s'assurer d'avoir des travailleurs de qualité ?
Trop complexe pour des enfants en bas age, très simple pour comprendre la véritable programmation...
J'ai commencé par apprendre le C puis le C++ (qui ne sont pas forcément les meilleurs) qui m'ont permis de comprendre comment un programme fonctionnait, la gestion de la mémoire, les piles, ...
Et surtout avec la complexité de ces langages par rapport a ceux de maintenant, on devait réfléchir a faire un algorithme avant de se lancer directement dans le code, contrairement à maintenant, ou la plupart des méthodes existent déjà.

En conclusion :
Un langage de programmation est une langue avec son orthographe et sa grammaire (mais pas dans le sens d'une langue parlé), mais c'est la logique qui fait qu'on soit bon ou mauvais développeur. C'est pour ça que je les petits jeux de logique sont beaucoup plus intéressant pour promouvoir la programmation informatique.
2  0 
Avatar de Pyramidev
Expert confirmé https://www.developpez.com
Le 18/08/2020 à 16:27
Citation Envoyé par Sodium Voir le message
Réaction de la France face à n'importe quel problème : On va sortir notre propre truc à nous !
Felienne Hermans travaille à l'université de Leiden, aux Pays-Bas.
https://www.felienne.com/bio-and-pic
2  0 
Avatar de Pyramidev
Expert confirmé https://www.developpez.com
Le 18/08/2020 à 20:26
Je viens de regarder la vidéo Youtube (13m16) et la publication (12 pages) cités par l'article présent de Developpez.com, puis j'ai testé la version française du tutoriel de Hedy en ligne : https://hedy-beta.herokuapp.com/hedy?lang=fr

Dans la vidéo Youtube, l'idée générale avancée par Felienne Hermans est que, quand elle avait essayé d'enseigner la programmation à de jeunes enfants de 11 ans, au début, ces enfants galéraient car, même dans un code simple, il y avait trop de nouveautés syntaxiques d'un coup. Ils n'apprenaient pas à programmer aussi facilement qu'elle quand elle avait 10 ans.

Alors, elle a mis en place un nouveau langage, Hedy, en plusieurs niveaux. Le niveau 1 a une syntaxe très basique, mais ne permet pas de faire grand chose. Ensuite, au fur et à mesure que l'on introduit des concepts (variables, conditions, répétitions...), on complique la syntaxe en passant à des niveaux supérieurs du langage. Le langage ressemble alors de plus en plus au Python. Ensuite, les enfants peuvent passer au Python.

Dans la publication, elle indique que l'un des intérêts d'avoir une syntaxe simple est que cela permet de faire des messages d'erreur plus facile à comprendre :
For example this Hedy code: prnt Hello World generates the error message: prnt is not a Hedy level 1 command, did you mean print? which is arguably more helpful than NameError: name ‘prnt’ is not defined which Python would produce.
Pour ma part, je salue l'initiative.

La version française du tutoriel a été ajoutée le 20 mai 2020 par un Canadien : https://github.com/Felienne/hedy/com...4c561b07fd2dcd

D'ailleurs, dans cette traduction, il y a des problèmes de syntaxe à corriger : il faut ajouter une espace avant "!", "?" et ":".

Au final, Hedy me semble pertinent pour les jeunes enfants. Pour des adolescents, par contre, je pense qu'il n'y a pas besoin d'un langage aussi progressif est qu'ils peuvent s'attaquer directement à Python.
2  0 
Avatar de abriotde
Membre expérimenté https://www.developpez.com
Le 18/08/2020 à 14:43
Doué en apprentissage de langues donc doué en programmation informatique : qu’en pensez-vous ?
Non bien sûr néanmoins "doué en mathématiques donc doué en informatique" n'est pas plus vrai.
Ce qui est vrai c'est que passer d'un langage informatique à un autre c'est un peu comme passer d'une langue à une autre. Mais c'est surtout vrai à l'écris et surtout pour eux ayant déjà une bonne maîtrise de plusieurs langages. Parce que l'informatique ajoute des besoin de compétences qui ne sont pas dans les langues et vice versa.
De même pour les mathématiques.
En informatique on a un besoin d'expression empreinté aux langages, un besoin de logique empreinté aux mathématiques, mais aussi un besoin algorithmique qui lui est propre (Si en langues ou en mathématique on retrouve des process ils n'ont rien a voir car une fois intégrés on en oublie la mécanique). L’algorithme, c'est comme la lecture/écriture, c'est un processus pas très difficile a comprendre mais difficile a intégré qui demande une compétence spécifique. C'est comme comparer apprendre à conduire une voiture/camion ou apprendre à faire du vélo.
1  0 
Avatar de Nebulix
Membre expérimenté https://www.developpez.com
Le 21/08/2020 à 10:58
Pascal aurait été conçu pour des besoins similaires, à savoir l’enseignement de la programmation informatique. C’est le choix des décideurs de l’écarter des programmes de formation qui serait le plus à questionner.
Nostalgique de Pascal ? (moi aussi)
1  0 
Avatar de jackk
Membre averti https://www.developpez.com
Le 18/08/2020 à 21:00
Réaction de la France face à n'importe quel problème : On va sortir notre propre truc à nous !
Ah! Python est franco français?
1  1 
Avatar de fatbob
Membre confirmé https://www.developpez.com
Le 04/09/2020 à 14:53
Il faudrait surtout que les instits et les profs soient formés en informatiques...
Quand mon fiston était en term, les connaissances de son prof avaient l'air tout juste suffisantes pour faire des hello world pas trop complexes
0  0 
Avatar de Glutinus
Expert éminent sénior https://www.developpez.com
Le 08/09/2020 à 16:34
Le "codage informatique", est-ce que c'est ce qui provoque des trucs informatiques genre des "bugs informatiques" dans des "applications informatiques" sauf s'il y a du "recettage informatique" ?
0  0 
Avatar de wakiza11
Nouveau membre du Club https://www.developpez.com
Le 08/09/2020 à 16:38
On a perdus le langage LOGO ?
0  0 
Avatar de eric44000
Membre à l'essai https://www.developpez.com
Le 18/08/2020 à 17:52
Rien de mieux pour le novice (enfant ou adulte en reconversion) qu'un langage visuel sous forme d'organigramme pour l'initiation algorithmique. LARP (Logiciel d'Algorithmes et de Résolution de Problèmes) permet de réaliser un simple "Hello world" et de le traduire en pseudo-code (qui est moins évident en première approche).
Cet environnement de développement (http://larp.marcolavoie.ca/fr/) permet de créer des structures conditionnelles et répétitives, instructions, entrées/sorties, modules... Bref, il y a de quoi de faire.
Mais pour aller plus loin, une méthode rigoureuse de résolution de problème algorithmique est nécessaire pour résoudre des algorithmes complexes (que peu d'informaticiens sont capables).
Enfin, passer de LARP à Python demande un niveau très basique (premier trimestre de 6ème) dans la langue de Shakespeare.
0  1