wilk a écrit 1168 commentaires

C'est vraiment paradoxal pour un programme qui est censé jouer par observation des parties déjà jouées de sortir des coups imprévisibles…
Ce soir on pourra revoir la partie commenté par Motoki sur kgs, à 20h30
Attention il faut java, hier je me suis fais avoir j'avais pas prévu le 1/4 d'heure pour installer java, rajouter une barrette mémoire, modifier /etc/java-7-openjdk/sound.properties pour avoir le son…

Y a plus qu'à essayer soit-même !
https://www.tensorflow.org/

J'ai regardé la partie commenté par Motoki hier soir (on peut le revoir sur KGS), ça n'est pas ce que j'ai retenu. Des coups surprenants mais pas agressifs pour autant. Après à ce niveau c'est difficile de faire la différence, je serai curieux de savoir s'il est possible d'analyser les logs d'AlphaGo pour voir s'il s'est "senti" en difficulté ou pas et si ça l'aurait obligé à être agressif ou s'il s'est senti en avance et que ses coups consolidaient sans qu'on ne s'en rende compte. Est-ce que le robot a cette notion ?
Motoki a montré quelques coups considérés comme surprenants en début de partie qui se sont avérés solides en fin de partie.

Mais bon, tu as raison dans le sens où ça ne semble pas être une partie juste sans erreur comme ça peut être le cas aux échecs.

Et même solution : les microservices :-)

Tu as raison il faut préciser le contexte sinon on ne sait pas de quoi on parle.
Mon créneau c'est beaucoup de petites et moyennes (1 à 15K lignes de code très concis) applications web très spécifiques, dont certaines vont durer très longtemps et évoluer dans des sens non définis au départ et que je gère quasiment seul. Genre des gestion de chantiers qui commencent gérées au siege, puis par des agences, puis par des chefs d'équipe sur leur smartphone etc… Après ça sera une gestion de résidents d'une maison de retraite qui pointent leur repas, leur ménage etc. Ou bien un site de vente de livres, où les éditeurs se regroupent puis se séparent puis se regroupent à nouveau, un jeu en ligne, un service de calcul d'itinéraire… Je suis également admin sys de tout ça, cad quelque dizaines d'apps en cours. Et c'est chouette de rentabiliser sa passion :-)

Donc mon casse tête c'est de pouvoir réutiliser le maximum de composants pour ne pas réinventer et réapprendre la roue. A court terme un bon framework c'est royal pour moi, j'essaye souvent.
Mais sachant que les composants et frameworks vont avoir une durée de vie plus courte que certaines applis et qu'ils seront utilisés dans des contextes parfois très différents, il faut impérativement que j'évite les effets de bords, dans l'instant et sur la durée, qu'en faisant évoluer un composant ça n'impacte pas les autres mais qu'une ancienne appli puisse quand même en bénéficier facilement un jour.

Si j'avais utilisé des gros frameworks, j'aurai du en utiliser plusieurs en même temps dont certains qui n'existeraient plus. Imagine si j'avais à maintenir des applis Zope et Django en même temps avec une demande d'évolution vers les websockets ou une contrainte de perf…
En revanche, avec un micro framework comme Pyramid je trouve un outil qui me permet de remplacer progressivement des composants de mon framework perso sans avoir à changer une ligne de code de mon appli. Donc j'achète, au pire je revend plus tard, le coût de la manoeuvre reste faible. Je prend Pyramid comme exemple car la doc explique de manière très détaillée cette philosophie, qui plus est par un ancien de Zope qui connaît bien le domaine, ça vaut le coup d'être lu même si on ne l'utilise pas.

Je faisais l'analogie avec la philosophie Go dans le sens où les auteurs ont décidés d'accepter une fonctionnalité du langage que s'ils étaient tous d'accord. J'applique la même règle avec mes composants perso, pour en faire une lib que je vais partager il faut que toutes mes applis soient d'accord, même la plus ancienne. En attendant : "une petite copie vaut mieux qu'une grosse dépendance" (Rob Pike).

C'est sûrement pas universel mais c'est assez marrant de partager certains points de vue entre Google et un indep ! J'ai vraiment été surpris. De la même manière quand je me suis aperçu que je pouvais utiliser Python pour le boulot, un langage qui semblait fait pour les enfants !

Je ne dis pas que je n'utilise pas d'orm, je dis juste que si je veux changer d'orm je ne veux pas avoir à changer de template pour autant.

Je ne cherche pas à être hors de toute dépendance, mes projets dépendent souvent de postgresql et reportlab par exemple mais aucun d'eux ne m'oblige à utiliser un orm quelconque ou à mettre mes fichiers de conf à tel endroit par exemple.
On n'utilise pas les mêmes frameworks du coup j'ai l'impression que ça commence à devenir difficile de savoir de quoi on parle…

J'ai des applis qui durent depuis plus de dix ans donc ça m'arrive assez souvent de changer un composant principal. Je préfère changer composant par composant que tout d'un coup. Si je dois démarrer une nouvelle app avec un autre moteur de template, je n'ai pas envie d'avoir à réaprendre un nouveau méga-framework et changer d'orm pour autant.
Mais bon, je ne cherche pas à convaincre, c'est juste mon expérience après avoir étudié et essayé les deux.

C'est bien pour ça que j'insiste sur un des avantages des micros frameworks qui est de pouvoir être changés facilement au cas où ça tournerait mal (ou que l'app évolue dans un sens différent), ce qui est loin d'être évident avec un plus gros et qui entraîne d'énormes problèmes pour faire évoluer le framework lui-même. Alors oui, le gros framework ne casse pas la compatibilité, mais pour cause, il n'évolue plus et au bout d'un moment on change tout, le langage avec l'eau du bain !

On retrouve cette philosophie en Go, de ne pas s'encombrer de ce qui pourrait devenir un boulet par la suite.

Utiliser un langage en cours de mise au point est au contraire tellement plein d'enseignements ! Même si on doit en utiliser un autre pour l'alimentaire il y a toujours moyen de progresser et d'améliorer sa pratique dans son langage actuel.

Je remercie donc particulièrement les auteurs de journaux ou dépêches qui partagent leurs découvertes et nous permettre d'en débattre.

edit: sur les frameworks que tu m'indiques, à vu de nez ça ne me déplaît pas, ça n'est pas ce que je critique, au contraire.

Personne n'a prétendu que les frameworks étaient nuls. Au contraire, ce sont souvent des monuments d'ingénierie. Mais ça ne signifie pas pour autant qu'ils soient adaptées à tous les cas de figure, surtout sur le long terme.

On n'utilise sûrement pas le même java. Celui que j'utilisais était en version 1.x, j'adhérai d'autant plus au framework que c'était le mien !
Ce que je veux dire par là c'est qu'un framework, même si on le connaît très bien, comporte trop d'effets de bords et de couches à maintenir pour évoluer sans peine sur des projets divers et variés.
Donc par la suite, en python, j'ai préféré opter pour un framework minimaliste (perso car à l'époque ça n'existait pas) et travailler sur la composition.
Par exemple je peux utiliser le même framework pour faire du "traversal" http://docs.pylonsproject.org/projects/pyramid/en/latest/narr/traversal.html
Mais il est difficile de savoir si on parle de la même chose en terme de framework… Autrement dit, je préfère la méthode "Unix" où chaque chose fait une seule chose mais bien et communique avec les autres.

Je suis également surpris par le ton que tu emplois contrairement à tes habitudes…
Chicha a juste dit qu'il en avait raz le bol lui-même pour ses propres besoins persos ! je ne vois pas où il y a une généralité là dedans ? Mais pas de quoi en faire un fromage, ça reste marrant à lire.

Par rapport à ton affirmation que beaucoup de gens disent du mal des frameworks parce qu'ils ne les maîtrisent pas, et bien là encore je constate exactement l'inverse, ce que j'ai écris sur les gros frameworks je ne l'applique pas uniquement aux frameworks que je ne connais pas bien mais également aux miens ! Quand j'utilisais Java, fier de la philosophie du langage qui incitait à faire les choses bien comme il faut je me suis écris à l'époque quelques bon gros framework qui me permettait d'aller hyper vite sur certains projets. En revanche comme je l'expliquait, sur le long terme j'ai du tout réécrire pour faire évoluer les applications dans des sens trop différents les unes des autres, ça m'a servi de leçon !

Ne m'incendie pas, c'est pas une généralité c'est mon expérience perso (petits projets qui évoluent sur du long terme) ;-)

Tout dépend de ce qu'on appelle un framework ?
Je constate plutôt l'inverse de ce que tu décrits, un gros framework (genre RoR ou Django) rend de plus en plus difficile toute évolution car il y a trop d'effet de bords et de surcouches à maintenir. En revanche un framework minimaliste comme Pyramid permet de faire évoluer un code dans n'importe quelle direction beaucoup plus facilement et surtout sans avoir à tout réécrire. Combien de projets on voit partis de RoR ou Django être réécrits entièrement car arrivés à une impasse ? On accuse bien trop souvent le langage alors que le problème vient du framework à mon avis.

Un critère que je trouve pertinent est de pouvoir conserver un même code d'un framework à l'autre. C'est ce que j'ai pu faire sur des applis qui datent de plus de dix ans et que je fais évoluer au fil de l'eau justement par ce que je n'ai jamais utilisé de gros framework. C'est aussi ce qui me permet de réécrire une partie en Go sans avoir à toucher à l'architecture ni à abandonner et réécrire ce qui peut très bien rester en Python.

J'aime bien Go pour ce même aspect minimaliste qu'on retrouvait au début en Python et qui a hélas été un peu perdu. Cet aspect me semble justement primordial pour la maintenance sur le long terme.

C'est marrant j'ai aussi fait un jeu de scrabble pour ma mômant ! http://seps.flibuste.net
Un jour j'ai eu un mail de Hasbro, je leur ai demandé sur quelle loi française ils s'appuyaient et depuis pas de réponse… J'attends qu'ils me fassent un effet Streisand avec mes mamies !!!

Sans ambiguïté dans le sens ou Go est le seul nom officiel du langage.

On trouve des tout petits scripts (moins de 200 lignes) qui montrent à quel point ça peut être simple et facile à intégrer :
https://github.com/diafygi/acme-tiny/

Je pense au Go par exemple, les interfaces, l'inférence de type, la compilation quasi instantanée…

Super ta présentation aux BlendWebMix, tu fais bien ressortir le côté simple et ludique de Go.

Je vais aller voir ton framework, si tu pouvais en faire un journal ou une dépêche pour nous expliquer comment il fonctionne, pourquoi tu en a créé un nouveau etc ce serait génial.

On trouve aussi l'inverse où on triche avec un langage à typage statique… Y a pas de miracle ! C'est pour ça que je trouve intéressant ce consensus où on essaye maintenant d'apporter plus de souplesse dans les langages statiques et plus de "sécurité" dans les langages dynamiques.

L'approche événementielle est complètement différente… Question de goût ou de besoin ?
Ce qui est marrant c'est qu'on reste en famille, Robert Griesemer a travaillé sur V8 (et java hotspot) avant de participer à la conception Go.
J'ai la chance de pouvoir choisir un langage parce qu'il me plait plus que par besoin donc je ne pourrai pas t'aider.

Merci du merci, quand on a le nez dans une dépêche c'est difficile de se rendre compte de ce que ça va donner.
Je ne pense pas non plus que ce soit une révolution, c'est juste une réponse bien pratique à des problèmes actuels, sans justement se casser la tête à tout réinventer.

Pour rester dans le sujet et répondre à ta question, une conf intéressante sur le dev de http://ngrok.com
à la fin il explique pourquoi Go et comment il a essayé de ne pas se perdre dans les dédales de l'orchestration.

https://www.twilio.com/blog/2016/02/how-alan-shreve-built-ngrok-with-go.html

24:50 exercice :

• Ecrire une application web (même petite)
• Temps réel avec websocket
• Rapide 1K+ req/s
• Monte à 10K connections simultanée
• Exploite tous les coeurs de la machine
• Déploiement d'un binaire sans dépendance sur différents plateformes

Le tout en une journée ;-)

Bon, maintenant que j'ai réussi il ne me reste plus qu'à trouver les clients pour faire les requêtes. La il donne une réponse aussi : vendez ce qui se vend déjà, vous êtes au moins sur que c'est vendable ! Mince c'est toujours pas la révolution non plus…

Ca montre le problème qu'il y a à utiliser les deux systèmes. Ca n'est pas tant qu'il y en ait un mieux que l'autre mais on essaye de retrouver des équivalences de commandes là où il y a une différence de conception…
J'utilise hg incoming pour le côté centralisé, pour voir si mon collègue à fait quelque chose ou pas. Si j'ai besoin de savoir exactement ce qu'il a fait je fais hg incoming -patch, ça me permet de voir exactement ce qu'il a fait, visuellement, sans rien récupérer. Je m'en sert également pour voir si mes librairies (en subrepos) sont à jour ou pas.
Inversement j'utilise push pour mettre à jour des applis en ligne. Avec outgo je peux savoir où j'en suis.

Depuis que j'utilise un algo en tête maison plus de soucis. C'est à dire un petit algo perso qui transforme le nom du service en un mot de passe, par exemple la première lettre + 1, la deuxième + 2, le nombre de lettre x l'année de naissance de ma fille etc…
Pour les cas un peu particulier où ça ne marche pas directement (pas assez de lettre ou autre) je l'écris sur un fichier qui lui n'a aucun besoin d'être crypté.
Pour les mots de passes ou codes que je ne peux pas modifier moi-même, je les écris avec une erreur. Par exemple si c'est un numéro j'inverse systématiquement le premier et le dernier caractère ou je lui ajoute mon année de naissance etc… Donc là aussi ça permet de l'écrire n'importe où.
N'importe où c'est généralement un fichier qui n'a l'air de rien genre test.py dans un répertoire build par ex.