Claude SIMON a écrit 576 commentaires

Comme mentionné dans le journal cité, est-ce vraiment pire que de programmer avec le clavier à membrane du Sinclair ZX81 ?

Et puis, ils pourront toujours utiliser les ordinateurs personnels qui sont mis à disposition dans les établissements scolaires, les médiathèques, les CSC... pour réaliser le gros du travail de programmation pour ensuite l'utiliser sur leur smartphone à l'aide de Replit et/ou Termux/iSH et/ou les forges logicielles.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

• Les jeunes qui veulent un jeux vidéo, c'est pour y jouer ;
• les jeunes qui veulent une BD, c'est pour la lire ;
• les jeunes qui veulent une voiture, c'est pour ce déplacer ;
• etc.

Les jeunes qui veulent un smartphone, c'est pour... en fait, c'est juste parce que presque tous leurs petits camarades en ont un.

Les jeunes, il utilisent leur smartphone pour aller sur les réseaux sociaux, regarder des vidéos, relever des défis complètement stupides voire carrément dangereux... simplement parce que c'est ce que la plupart des jeunes font avec leur smartphone, et que ce sont donc les choses à faire pour s'intégrer.

Pourquoi est-ce que la programmation ne ferait pas partie de ces choses que les jeunes font avec leur smartphone ? Peut-être pour quantité de raisons, mais si de telles raisons existent, j'espère que Zelbinium en a rendues quelques-unes caduques....

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Ça a fait l'objet d'une petite discussion ici-même : https://linuxfr.org/users/epeios/liens/ovh-rgpd-vos-backups-sont-perdus-il-faut-le-signaler-a-la-cnil

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Énoncé : Soit f:R→R telle que ∀x∈R:f(7x−3)=x+80. Calculer la dérivée de f.

Réponse avec GPT-3.5 :

Pour calculer la dérivée de la fonction f(x), nous allons utiliser la règle de la chaîne. La règle de la chaîne stipule que si nous avons une fonction composée, par exemple g(h(x)), alors la dérivée de cette fonction composée peut être calculée en multipliant la dérivée de g(h(x)) par la dérivée de h(x).

Dans notre cas, nous avons f(7x - 3) = x + 80. Nous pouvons considérer la fonction g(u) = u + 80 et la fonction h(x) = 7x - 3.

La dérivée de g(u) par rapport à u est simplement 1, car u + 80 est une fonction linéaire de coefficient 1 devant u.

Maintenant, nous devons calculer la dérivée de h(x). La dérivée de 7x - 3 par rapport à x est simplement 7, car la dérivée d'une fonction linéaire est égale au coefficient devant x.

En utilisant la règle de la chaîne, nous pouvons maintenant calculer la dérivée de f(x) comme suit :

f'(x) = g'(h(x)) * h'(x)

Dans notre cas, g'(u) = 1 et h'(x) = 7, donc :

f'(x) = 1 * 7 = 7

Ainsi, la dérivée de la fonction f(x) est égale à 7.

Je lui ai demandé de déterminer spécifiquement f(x), et après 4 réponses incorrectes :

Je m'excuse encore une fois pour les réponses incorrectes précédentes. Reprenons l'énoncé initial et essayons de déterminer correctement la fonction f(x) :

Soit f: R → R telle que ∀x ∈ R : f(7x - 3) = x + 80.

Pour trouver la fonction f(x), nous devons exprimer x en termes de 7x - 3. Nous avons :

7x - 3 = y

En isolant x, nous obtenons :

7x = y + 3

x = (y + 3)/7

Maintenant, nous pouvons exprimer f(x) en termes de y :

f(y) = (y + 3)/7 + 80

Donc, la fonction f(x) correspondante est f(x) = (x + 3)/7 + 80.

Encore une fois, je m'excuse pour les réponses incorrectes précédentes et j'espère que cette réponse correspond correctement à l'énoncé initial.

Ouf !

Il a l'air d'apprendre, car avec un nouveau chat :

Pour calculer la dérivée de la fonction f, nous devons utiliser la règle de la chaîne. Tout d'abord, nous exprimons la fonction f(7x - 3) en termes de x :

f(7x - 3) = x + 80

Maintenant, nous dérivons les deux côtés de cette équation par rapport à x. La dérivée de la fonction f(7x - 3) par rapport à x peut être calculée en utilisant la règle de la chaîne :

[f(7x - 3)]' = (x + 80)'

Maintenant, nous devons calculer les dérivées individuelles des deux côtés de l'équation. La dérivée de x par rapport à x est simplement 1, et la dérivée constante 80 par rapport à x est égale à 0. Pour la dérivée de f(7x - 3), nous utilisons la règle de la chaîne :

[f(7x - 3)]' = f'(7x - 3) * (7x - 3)'

La dérivée de (7x - 3) par rapport à x est simplement 7. En substituant toutes ces valeurs, nous avons :

f'(7x - 3) * 7 = 1

Maintenant, nous pouvons isoler f'(7x - 3) :

f'(7x - 3) = 1/7

Donc, la dérivée de la fonction f par rapport à x est f'(x) = 1/7.

Je me demande si la version 4 aurait tout de suite trouvé la bonne réponse...

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

...un peu de pub éhontée pour un projet open source, des fois que cela pourrait se révéler utile...

Pour ajouter un peu d'interactivité aux notebook Jupyter, il existe ipywidget qui permet d'obtenir ceci :

Pour ceux qui ont besoin de widgets plus évolués, ben il y a mon projet qui permet de mettre en œuvre n'importe quel composant HTML.

À titre d'exemple, voici l'équivalent du Hello world :

Le notebook correspondant est visible à l'adresse https://github.com/epeios-q37/atlas-python/blob/master/tutorials/Hello.ipynb.

Un exemple un peu plus sophistiqué, dont le notebook est visible à l'adresse https://github.com/epeios-q37/atlas-python/blob/master/tutorials/Contacts.ipynb :

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

L'application s'appuie, pour l'interface graphique, sur le toolkit Atlas dont le but, en gros, est de pouvoir profiter de certaines technos web (HTML/CSS) sans en subir les inconvénients (JavaScript, nécessité de disposer d'un serveur web).

L'ancêtre du toolkit Atlas s’appuyait sur Electron et, avant cela, sur XULRunner. C'est pour éviter cela que le toolkit s'appuie sur un serveur, avec lequel il communique à l'aide d'un protocole maison. L'URL affichée au démarrage de l'application lance une connexion à ce même serveur, mais en utilisant le protocole HTTP(S), donc avec un navigateur web comme client.

Voici le schéma correspondant :

On peut mettre en place son propre serveur en suivant la procédure à l'adresse https://q37.info/s/hxkfph74.

L'application fonctionne également en HTTP, mais j'ai remarqué que certains opérateurs téléphoniques bloquaient les WebSockets en HTTP, d'où l'utilisation de HTTPS par défaut.

Il y a déjà eu ici même quelques publications concernant cette architecture : https://linuxfr.org/tags/atlas_toolkit/public. Mais s'il y a des aspects à approfondir, je le ferais bien volontiers, éventuellement sous forme de journal...

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Sur le même sujet, en un peu plus détaillé... : https://maliki.com/strips/a-croisee-chemins/

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Comme montré dans la vidéo mentionnée dans mon précédent commentaire, Denemo offre la possibilité de saisir le rythme au clavier d'ordinateur, puis de saisir les notes au clavier MIDI. Ça peut être une solution, sauf que je ne vois pas trop comment récupérer de manière simple ce qui a été saisi pour l’intégrer à MuseScore.

Avec mon outil, c'est l'inverse : on saisit d'abord les notes, puis les durées correspondantes. Ceci dit, il serait relativement simple d'implémenter la saisie à la sauce Denemo. On récupère ensuite ce qui a été saisi au moyen d'un copier/coller de ce qui est généré par un appui sur le bouton .ly. C'est au format LilyPond, mais on peut générer n'importe quel format textuel avec le fichier XSL et le script adéquats, sur le modèle de ce qui est fait avec le format LilyPond. Mais, là encore, je ne vois pas trop quel format utiliser pour MuseScore et comment y intégrer les données.

Pour les silences, on saisit une note quelconque à la place du silence. Ensuite, quand on est dans la phase de saisie des durées, une fois le curseur positionné sur la note, on la marque comme un silence (touche 0), on revient sur la note (on peut utiliser la flèche gauche du clavier), puis on saisit la durée du silence. Ou inversement : on saisit la durée, on revient sur la note, puis on la marque comme silence. Ce n'est pas très optimisé ; peut-être que le mieux c'est que le fait de marquer une note comme silence ne fasse pas avancer le curseur...

Personnellement, je préfère travailler directement avec des fichiers texte, comme l'autorise LilyPond, plutôt qu'avec des applications WYSIWYG comme MuseScore ou Finale. On a beaucoup plus de liberté : on peut créer des petits utilitaires comme mon outil, ou des logiciels plus complets comme Frescobaldi, voire Denemo et ainsi créer son propre flux de travail. J'avais déjà eu la même démarche avec Markdown/Marp.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Puisque l'occasion m'en ai donné, un grand merci, qui englobe naturellement tout les autres contributeurs, pour ce fantastique logiciel. En tant que musicien, j'ai souvent affaire à des partitions vendues fort chers par des éditeurs ayant pignon sur rue, et souvent, quand je vois leur rendu, je me demande «Pourquoi diable n'utilisent-t-ils pas LilyPond ?».

Lilypond a déjà fait l'objet de plusieurs publications ici-même, mais c'est quand même un logiciel dont la plupart des personnes fréquentant ce site, comme dans le reste de la population, n'ont pas l'usage.

Concernant Frescobaldi, celui-ci ne gère que la saisie des notes, ce qui n'est qu'une des fonctionnalités de mon outil. Avec ce dernier, une fois les notes saisies, on se repositionne sur la première note, puis on saisit la durée de chaque note, à l'aide du clavier ou des boutons adéquats. Cette fonctionnalité n'est pas disponible avec Frescobaldi, comme semble le confirmer cette entrée GitHub non close.

Ceci dit, il y a une fonctionnalité qui s'en rapproche, avec Tools/Rythm/Apply rythm..., qui ouvre une boîte de dialogue dans laquelle on saisit les durées au format Lilypond, qui sont alors appliquées une à une aux notes sélectionnées. Mais c'est un peu moins pratique parce que, par exemple, une noire suivie d'une croche suivie d'une double-croche nécessitent de taper la séquence de touches 4[espace]8[espace]16, alors qu'avec mon outil il suffit de la séquence 345 (ou de cliquer sur les boutons correspondants).

Je viens de trouver une vidéo qui montre comment fonctionne Denemo. Si j'avais vu cette vidéo plus tôt, peut-être que je n'aurais pas crée mon outil. Ce qui m'avait échappé avec Denemo, c'est qu'il faut d'abord saisir le rythme, puis les notes, alors que j'étais parti sur principe de d'abord saisir les notes, puis le rythme, principe appliqué dans mon outil.

Cependant, Denemo est conçu pour prendre en charge l'intégralité de l'écriture d'une partition, dans l'idée, je pense, de se positionner comme alternative à Finale. Il a son propre format de fichier, et LilyPond ne lui sert que de moteur de rendu. Or, je préfère travailler directement sur des fichiers LilyPond, ce qui est facilité avec Frescobadi, et mon outil, comme le suggère le titre du journal, est conçu dans l'idée être utilisé en complément.

Et encore merci pour ce logiciel :-) !

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Certes, mais depuis : https://linuxfr.org/users/epeios/journaux/enfin-un-successeur-a-freecode-ex-freshmeat (notez le score exemplaire !).

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Quelque soit la cause de la baisse de niveau concernant l'utilisation de l'informatique, c'est peut-être également à l'origine du même phénomène qui touche les aspirants développeurs. Et ça ne date pas d'aujourd'hui, puisque c'est pour tenter de contrer cette tendance que le Raspberry Pi a été conçu.

Le Raspberry Pi connaît un succès phénoménal, pas en tant qu'outil éducatif, mais en tant que plateforme d’expérimentation plébiscitée, grâce à son faible coût, par des personnes qui sont généralement déjà à l'aise avec l'informatique (je plaide coupable).

On pourrait se dire que ce n'est pas grave que le Raspberry Pi soit passé à coté de son objectif premier : à quoi bon un Raspberry Pi pour découvrir l'informatique, alors que le taux d'équipement en smartphone atteint un niveau stratosphérique ? Sauf que cette omniprésence des smartphones n'a pas vraiment amélioré la situation. Á qui la faute ?

Beaucoup reçoivent leur premier smartphone alors qu'ils sont au collège. Dans mon cas, les smartphones n'existant pas encore à l'époque, ce fût un ordinateur. Les fonctions trigonométriques étant étudiées au collège, l'un de mes premiers programmes avait pour finalité de dessiner un bête cercle à l'aide des fonctions sinus et cosinus vues en cours. Essayez d'écrire un tel programme avec et pour un smartphone...

Mais ce qui a été tenté au niveau matériel avec le Raspberry Pi, il y a peut-être moyen de le réaliser au niveau logiciel, comme je l'ai évoqué dans ce journal, et développé là...

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

C'est surtout que c'est ch...ant de freiner en changeant en même temps de vitesse à chaque feu rouge pour pouvoir redémarrer dans de bonnes conditions au vert.

En voiture, tu anticipes mal, ben tu débrayes et tu freines à la pédale. Puis tu mets tranquillement la première au vert.

En vélo, tu te loupes, bonjour le redémarrage, à moins de changer de vitesse en soulevant la roue arrière par la selle, ce qui n'est pas une manœuvre très agréable à réaliser.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Sinon j'ai remarqué que certains rasoirs ne fonctionnent pas lorsqu'ils sont en charge (le chargeur branché) - probablement pour éviter de le faire tomber à l'eau lorsqu'on l'utilise en le chargeant.

J'ai rencontré les deux. Le modèle qui ne fonctionnait pas en charge était un modèle qui pouvait s'utiliser sous la douche, contrairement à l'autre. Du coup, je pense que c'est pour éviter son utilisation en charge sous la douche...

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Mais les procédures pour changer de nom de famille sont très longues et difficiles en France...

Ça dépend.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

ingénieuse peut prêter à confusion :

Cette ingénieuse propriétaire...

Une ingénieure qui est également propriétaire, ou une propriétaire qui a est pleine de ressources, d’esprit... ?

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

• Une facture d'accès à Internet et de téléphone fixe, parce que l'opérateur est OVH et que la guichetière n'en a jamais entendu parler ?

C'était avant ou après l'incendie ? (-> [])

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Le BASIC du ZX81 avait aussi GOSUB et GOTO. Heureusement, parce qu'il avait IF ... THEN ... mais pas ELSE.

Ce qui est amusant avec le GOTO, c'est qu'on peut lui passer une expression qui retournait un nombre. Ainsi, le programme :

10LETA=2
20GOTOA*100
100PRINT"A"
110STOP
200PRINT"B"
210STOP
300PRINT"C"
310STOP

affichait B.

Ça permettait de simuler le ON ... GOTO ... d'autres BASIC, voire une forme de switch.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

En capillotractant un peu : « Paul ne sait pas s'il ne va pas ne pas continuer à ne pas chômer ».

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Pour ceux qui y ont eu droit en avant-première, la réponse c'est 4b pour l'instant, mais c'est facilement contournable : https://www.numerama.com/tech/1267426-premier-test-de-bing-chatgpt-je-me-suis-dispute-avec-une-ia.html

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Ça bouge pas mal en ce qui concerne le son.

Dans le cadre du développement d'une application destinée à faciliter l'écriture de partitions musicales, j'ai découvert une API qui prend en charge le vénérable protocole MIDI.
Je ne l'ai finalement pas utilisée, parce qu'elle n'est pas encore disponible dans tous les navigateurs majeurs, notamment ceux de l'écosystème Apple, mais ce n'est probablement que partie remise...

L'API en question : https://developer.mozilla.org/en-US/docs/Web/API/Web_MIDI_API

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Pas vraiment un raccourci, mais on peut utiliser la touche de tabulation pour aller jusqu'au bouton d'envoi et l'actionner avec la touche entrée. Du coup, pas besoin d'utiliser la souris.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Je crois que c'est peine perdue. C'est comme l'utilisation de librairie (qui est un faux-ami pour le coup) pour désigner une bibliothèque logicielle. C'est rentré dans le mœurs, notamment chez les professionnels, et comme l'usage fait la langue...

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Pour accéder à une variable d'une fonction parente dans une sous-fonction, tu n'as rien à faire. C'est disponible de base en Python, l'ensemble des variables de la fonction parente sont accessibles directement.

Oui et non.

Oui si c'est pour lire la variable, non si c'est pour la modifier.

def f_parent():
 msg = 'hello'
 def f_sous_fonction():
 msg += ' world'
 print(msg)
 return f_sous_fonction
fsf = f_parent()
fsf()

UnboundLocalError: local variable 'msg' referenced before assignment

def f_parent():
 msg = 'hello'
 def f_sous_fonction():
 nonlocal msg # <- ajout
 msg += ' world'
 print(msg)
 return f_sous_fonction
fsf = f_parent()
fsf()

hello world

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

Il ne devait pas y en avoir tant que ça, n'empêche que Firefox Reality, le navigateur de Mozilla dédié à la réalité virtuelle, a été abandonné en 2022 et retiré des magasins d'applications.
Je n'ai pas réussi à mettre la main sur Wolvic (sic), son successeur basé sur son code source, pour voir son user-agent.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...

• https://grisebouille.net/amour-numerique/
• https://grisebouille.net/amour-numerique-bis/
• https://grisebouille.net/lhdg04-numerique-vs-digital/

Ce sont les deux premiers qui sont cités par le dernier.

Zelbinium: pour la génération qui crée, pas celle qui scrolle...