Claude SIMON a écrit 546 commentaires

Et moi qui vient juste de me lancer dans l'implémentation du protocole WebSocket…

Zelbinium, la programmation ludique

Dans le premier lien, il est indiqué que, pour une personne physique, elle doit obligatoirement inscrire sur son site :
- Les nom et prénom ;
- l'adresse du domicile ;
- l'adresse de courrier électronique ;
- le numéro de téléphone.

Pourtant, l'article 6 auquel ce lien fait référence précise bien (III-2) :

Les personnes éditant à titre non professionnel un service de communication au public en ligne peuvent ne tenir à la disposition du public, pour préserver leur anonymat, que le nom, la dénomination ou la raison sociale et l'adresse du prestataire mentionné au 2 du I, sous réserve de lui avoir communiqué les éléments d'identification personnelle prévus au 1.

C'est quand même une omission de taille…

Zelbinium, la programmation ludique

…il y a Kargos.

Zelbinium, la programmation ludique

Mise à jour qui permet de formater les textes affichés avec print(…) et input(…) grâce aux fonctions suivantes.

set_property(name,value) applique la propriété CSS de nom name et de valeur valeur.

Exemple:

set_property("font-style": "italic")

set_properties(properties) applique les propriétés CSS stockées dans properties, qui est un dictionnaire dont les clefs sont les noms des propriétés, et les valeurs les valeurs de ces propriétés.

Exemple:

set_properties({
    "text-decoration-line": "line-through",
    "text-decoration-style": "wavy",
    "text-decoration-color": "red"
})

reset_properties() efface toutes les propriétés appliquées avec les fonctions ci-dessus.

Dans le dépôt GitHub, Basic.py est une exemple d'utilisation de print(…) et input(…), mais sans formatage CSS. WithCSS.py montre comment on applique des propriétés CSS et le résultat.

Suite à des certaines remarques, je précise que, contrairement aux autres programmes basés sur le toolkit Atlas, il n'est pas possible de lancer deux instances simultanées d'un même programme utilisant term2web. C'est volontaire, pour ne pas rendre la mise en œuvre de cette bibliothèque plus complexe. Elle est principalement destinée à être utilisée par des débutants, pour les familiariser avec l'environnement dans lequel évolue le genre d'exercice que l'on trouve à l'adresse https://q37.info/s/g9fvwzgp.

Zelbinium, la programmation ludique

En résume résumé, le musicien est privé de ses droits d'auteurs.

Zelbinium, la programmation ludique

Il y en a pas mal qui font du Scratch en classe de troisième, mais je ne sais pas si c'est généralisé…

Zelbinium, la programmation ludique

Il est possible de continuer à utiliser mercurial et de rester sous Bitbucket. Il existe en effet un plugin mercurial qui permet de répercuter de manière transparente les push/pull sur un dépôt mercurial vers un dépôt git.
Je l'utilise tous les jours, certes dans un seul sens (mercurial vers git), mais je n'ai jamais rencontré de problèmes…
Le plugin en question : https://hg-git.github.io/

Zelbinium, la programmation ludique

En fait, les chaînes de caractères qui transitent par ces fonctions sont uniquement récupérées de formulaires HTML et affichées dans des pages HTML, tous encodés en utf8 ; elles ne sont jamais lues à partir de la console, ou écrites dans la console. C'est peut-être pour cela que je n'ai jamais rencontré de problèmes…

Zelbinium, la programmation ludique

pourquoi passer de str/chr à bytes ? ça j'ai pas suivi…

Certaines fonctions qui prenaient un string en version 2 n'acceptent plus qu'un objet bytes en version 3, comme la méthode send de l'objet socket (v2, v3).

pourquoi ajouter decode("utf-8") alors qu'un use utf-8 suffirait en en-tête ? (bientôt obsolète j'espère)

"utf-8" est inutile, étant la valeur par défaut du paramètre correspondant, mais le decode() est nécessaire pour convertir l'objet bytes retourné par socket.recv(…) en string.

J'ai voulu essayer use …, mais je n'ai pas trouvé de documentation à ce sujet…

Zelbinium, la programmation ludique

Je viens d'essayer avec Python 2.7.15+ avec les caractères ⯈⯈⯈ éàôö…, et ça fonctionne sans problème…

Zelbinium, la programmation ludique

Bonne idée, mais c'est un peu trop petit…

Je tente avec du Markdown :

 def writeByte(socket, byte):
-       socket.send(chr(byte))
+       socket.send(bytes([byte]))

 def writeSize(socket, size):
-       result = chr(size & 0x7f)
+       result = bytes([size & 0x7f])
        size >>= 7

        while size != 0:
-               result = chr((size & 0x7f) | 0x80) + result
+               result = bytes([(size & 0x7f) | 0x80]) + result
                size >>= 7

        socket.send(result)

 def writeString(socket, string):
-       writeSize(socket, len(string))
-       socket.send(string)
+       bString = bytes(string, "utf-8")
+       writeSize(socket, len(bString))
+       socket.send(bString)

 def writeStringNUL(socket, string):
-       socket.send(string + "\0")
+       socket.send(bytes(string + "\0", "utf-8"))

 def getByte(socket):
        return ord(socket.recv(1))
@@ -65,6 +66,8 @@
        size = getSize(socket)

        if size:
-               return socket.recv(size)
+               return socket.recv(size).decode("utf-8")
        else:
                return ""

Zelbinium, la programmation ludique

[…] à part la différenciation str/bytes qui ajoute de la complexité apparente à Python3. Je dis bien apparente car elle force au final à raisonner de manière plus précise sur nos données […]

Il y a quelque temps, j'ai développé des fonctions pour faire transiter des chaînes de caractères via des sockets. Bien que je n'avais quasiment jamais fait de Python, j'ai trouvé la version pour Python 2 assez facile à écrire. Par contre, pour la version Python 3, ça a quand même été un petit peu plus compliqué.

Voilà les deux versions ; on ne sait jamais, ça servira peut-être à quelqu'un…

(Oui, je sais, je n'aurais pas du utiliser le camelCase, mais je débutais en Python, et n'avais pas connaissance des règles en la matière…)

La version pour Python 2 :

def writeByte(socket, byte):
    socket.send(chr(byte))

def writeSize(socket, size):
    result = chr(size & 0x7f)
    size >>= 7

    while size != 0:
        result = chr((size & 0x7f) | 0x80) + result
        size >>= 7

    socket.send(result)

def writeString(socket, string):
    writeSize(socket, len(string))
    socket.send(string)

def writeStringNUL(socket, string):
    socket.send(string + "\0")

def getByte(socket):
    return ord(socket.recv(1))

def getSize(socket):
    byte = getByte(socket)
    size = byte & 0x7f

    while byte & 0x80:
        byte = getByte(socket)
        size = (size << 7) + (byte & 0x7f)

    return size

def getString(socket):
    size = getSize(socket)

    if size:
        return socket.recv(size)
    else:
        return ""

et la version pour Python 3 :

def writeByte(socket, byte):
    socket.send(bytes([byte]))

def writeSize(socket, size):
    result = bytes([size & 0x7f])
    size >>= 7

    while size != 0:
        result = bytes([(size & 0x7f) | 0x80]) + result
        size >>= 7

    socket.send(result)

def writeString(socket, string):
    bString = bytes(string, "utf-8")
    writeSize(socket, len(bString))
    socket.send(bString)

def writeStringNUL(socket, string):
    socket.send(bytes(string + "\0", "utf-8"))

def getByte(socket):
    return ord(socket.recv(1))

def getSize(socket):
    byte = getByte(socket)
    size = byte & 0x7f

    while byte & 0x80:
        byte = getByte(socket)
        size = (size << 7) + (byte & 0x7f)

    return size

def getString(socket):
    size = getSize(socket)

    if size:
        return socket.recv(size).decode("utf-8")
    else:
        return ""

(Code source extrait respectivement de https://github.com/epeios-q37/atlas-python/blob/be77cf9d5c8921877fecc1ed1bfa3819fc7e7546/atlastk/XDHqDEMO2.py et https://github.com/epeios-q37/atlas-python/blob/be77cf9d5c8921877fecc1ed1bfa3819fc7e7546/atlastk/XDHqDEMO3.py.)

Zelbinium, la programmation ludique

… que Python est le langage retenu par l'Éducation nationale pour les cours de sciences numériques et technologie, cours qui est obligatoire pour tous les élèves des classes de seconde des lycées généraux et technologiques.

Zelbinium, la programmation ludique

Bonjour !

Alors, avant que je n'oublie, quelques liens qui donnent sur un 404 :

• dans le lien ci-dessus, section Librairies (qui, soit dit en passant, devrait être intitulée Bibliothèques), le lien sur entree ;
• dans le README.md du dépôt GiHub, les 4 derniers liens.

---

À mon tour, je me permets de présenter une approche différente, mais qui me semble complémentaire, à savoir une bibliothèque qui s'inspire de la tortue du Logo. Ça permet aux élèves d'écrire quelque-chose du genre :

tortoise.down()

for i in range(500):
    tortoise.setColorHSL(360 * i / 500, 100, 50)
    tortoise.forward(i/2.5)
    tortoise.left(91)

qui permet d'obtenir ça :

En combinaison avec l'outil présenté dans cette dépêche, on peut créer un exercice qui consiste à leur faire écrire, par exemple, quelque chose de ce genre :

baisse()

for y in range(0, 24):
    fixeCouleurTSL(T, 100, 50)
    T += 15
    for x in range(0, 12):
        avance(30)
        tourneDroite(30)
    tourneDroite(15)

J'en parle dans ce journal.

Zelbinium, la programmation ludique

Tu as dû mal lire la remarque de magnolia, ça n'est pas ce qu'il reprochait : il parlait bien du risque d'engager les profs dans cette voie.

De quoi parles-tu exactement ? Le commentaire auquel tu réponds est ma réponse à ta propre remarque …proposer ça comme outil à faire connaître à tous les lycéens…, pour signaler que ce n'est absolument pas le cas.

Et moi en plus en tant qu'apprenant, j'aime bien aller voir ce qu'il y a derrière. Ça sera problématique à ce moment-là également.

Et qu'est-ce qui serait moins problématique pour toi ? Un outil propriétaire développé par une multinationale qui en profiterait pour soutirer un maximum de données personnelles des élèves et des enseignants afin de les abreuver de publicités ?

Zelbinium, la programmation ludique

C'est tout le contraire. L'outil présenté dans cette dépêche est destiné à être utilisé par ceux qui élaborent les exercices, pas par les élèves auxquels sont destinés ces exercices.

Tout est fait pour rendre cet outil transparent pour les élèves. Dans le code que tape l'élève dans le cadre des exercices, à aucun moment il ne manipule l'API de la bibliothèque edutk, ni celle de la bibliothèque atlastk.

Zelbinium, la programmation ludique

Concernant l'idée d'une bibliothèque graphique :

Le post suggère de diriger les futurs profs de NSI/Python vers une bibliothèque maintenue par une personne qui n'est même pas installée par défaut sur les distributions Python classiques comme Anaconda. Cela me semble être une erreur grave. Je m'y connais plutôt en info (ce qui me permet d'être écouté oar les administrateurs du lycée) et c'est déjà compliqué pour demander aux administrateurs d'installer le moindre truc.

Les bibliothèques sont disponibles sur PyPi ; si Anaconda a un système équivalent de gestion de paquets, je veux bien créer ceux dédiés à ces bibliothèques, si cela peut en simplifier l'usage…

Ne parlons même pas de séparation entre le coeur du code et l'interface graphique d'un programme que ce genre d'enseignement va ignorer totalement.

Les manipulations concernant l'interface graphique étant réduites au minimum, seul celui qui élaborera les exercices sera amené à gérer la séparation interface/traitement…

Zelbinium, la programmation ludique

L'outil présenté fait une jolie présentation, pour certains élèves en collège/lycée ça peut être intéressant pour juste les intéresser à la chose (les élèves en prépa sont généralement un peu plus motivés et costauds que la moyenne). L'aspect accessible via Internet est un plus (quand c'est prêt c'est directement utilisable), et un moins (il faut quelqu'un qui sache le mettre en place et bénéficier d'un hébergement).

C'est pour que ce soit directement utilisable que je met à disposition un serveur gratuit et public, sachant que, comme on est sur du logiciel libre, on reste tout à fait libre (sans jeu de mot) de mettre en place son propre serveur…

Zelbinium, la programmation ludique

Pour ce qui est du post est des interfaces graphiques, je suis sceptique. Je suis prof dans une des meilleures prépa de France. Et je dois batailler en début d'année pour que les élèves comprennent qu'il y a une différence entre un print(a) et un return a. Écrire une interface graphique propre est un boulot de spécialiste et nécessite beaucoup de connaissances très spécifiques à la bibliothèque utilisée. Certes, c'est ici une bibliothèque très simple, qui permet de faire des input et des print plus jolis. Mais bon, je crois qu'il est plus important de savoir ce qu'est un tableau ou une table de hachage.

Et bien justement, le but de l'outil présenté ici est de pouvoir créer des exercices qui permettent aux élèves de profiter de tous les avantages d'une interface graphique, sans pour autant qu'ils aient à la manipuler directement, et ce afin qu'ils puissent se concentrer sur l'objet de l'exercice (tableau, table de hachage…).

Zelbinium, la programmation ludique

Excellente initiative !

Merci !

Je me permets une remarque superficielle sur la forme :
j'essaye personnellement de présenter de bonnes habitudes de rédaction de code python à mes élèves.
Par conséquent, je préférerais leur fournir des fonctions utilitaires dont les identifiants respectent les conventions de nommage en python et non en camelCase.

J'étais passé à coté de la PEP dédiée.

Ceci dit, pour autant que je sache, dans le cadre des cours de SNT/NSI, on ne cherche pas à initier les élèves à Python en particulier, mais à la programmation en général. Du coup, respecter les conventions de nommage Python n'est pas aussi important que ça, car si un élève décide, plus tard, d'utiliser un autre langage, il est probable qu'il aura affaire à d'autres conventions de nommage.

Maintenant, cet outil est totalement agnostique concernant les conventions de nommage ; on peut donc mettre en œuvre, dans les exercices, celle de son choix.

Je vais étudier de plus près ces outils que vous partagez généreusement.

N'hésitez pas à m'en faire part si vous rencontrez des problèmes, ou si vous avez des remarques/suggestions/questions…

Zelbinium, la programmation ludique

On peut aussi rester appuyé sur le bouton droit durant le déplacement, et le relâcher seulement une fois positionné. Ça économise un clic…

Zelbinium, la programmation ludique

Concrètement, comme je n'utilise pas la STL, je ne m'attarde pas sur les nouveautés qui s'y rapportent. Donc, concernant ces nouveautés, aussitôt lues, aussitôt oubliées.

Zelbinium, la programmation ludique

Des experts C++ qui se qualifie 4.5 / 5 en C++ et qui sont perdus dés avec 3 minutes quand tu leur parle de VTable.

Ça fait presque vingt ans que je programme quasi-exclusivement en C++, et ça ne me viendrait absolument pas à l'idée de me qualifier d'expert C++. D'une part, parce que je ne me considère pas comme tel, et, d'autre part, parce que je ne vois pas l'intérêt pour moi d'être un expert en C++, pour l'usage que j'en ai.

Le C++ est un outil que j'utilise de la manière qui me convient le mieux, qui n'est pas, j'en conviens, la plus répandue. Je me tiens au courant des fonctionnalités ajoutées au fur et à mesure des nouvelles versions et j'en adopte une de temps en temps (la dernière, ce sont les variadic templates, dont j'use et abuse), parce qu'elle me facilite mon travail de développeur. Ce qui fait que je dois n'en utiliser, au final, qu'une faible partie. Mais à quoi cela me servirait-il d'en connaître plus si je n'en ai pas l'usage ? À impressionner d'éventuels recruteurs ? Si mon compte Github ne leur suffit pas pour savoir si mes compétences en matière de programmation répondent ou non à leurs besoins, c'est leurs propres compétences qui laissent à désirer…

Pour reprendre une analogie fort populaire dans notre milieu : je possède ma voiture depuis plus de dix ans, et je bataille plusieurs minutes deux fois par an pour mettre mon auto-radio (intégré) à l'heure (c'était d'actualité il y a peu), alors que la procédure prend moins de 10 secondes si on la connaît. Du coup, malgré les dix ans et quelques que je l'ai en ma possession, difficile de me qualifier d'expert du modèle que je possède. Et ça ne me pose aucun problème, vu ce que je connais d'elle me suffit pour m'amener d'un point A à un point B dans des conditions que j'estime satisfaisantes.

Commentaire que j'ai écris il y quelques années sur comment ne pas être considéré comme un spécialiste C++ malgré une pratique quasi-quotidienne de plus de 12 ans : https://linuxfr.org/users/fredx/journaux/ce-qu-on-demande-a-un-developpeur-aujourd-hui#comment-1471811.

Zelbinium, la programmation ludique

Sous KDE, du moins avec Kubuntu, il y a Muon Package Manager. C'est assez proche de Synaptic, et je l'utilise systématiquement à la place de Discover. Le seul cas où j'utilise encore Discover, c'est pour les mises à jour, quand il s'ouvre lorsque l'on clique sur la notification.
Au début, je fermais la notification, et je faisais les mises à jour avec Muon. Mais Discover fait exactement les mêmes mises à jour, y compris les paquets qui n'apparaissent pas dans Discover et que j'ai donc installé via Muon, y compris également les paquets installés à partir d'un PPA, avec Muon.

Zelbinium, la programmation ludique

Petite erreur à la fin du premier paragraphe :

[…] et vous serez aider aidés.

Zelbinium, la programmation ludique