mzf a écrit 151 commentaires

Pour éviter l'écueil du manque d'adoption de la plateforme, pensez-vous proposer une compatibilité avec les géants existants (youtube, dailymotion, vimeo)?

On pourrait imaginer soit pouvoir importer facilement des vidéos venant de ces autres plateformes, soit carrément les regarder directement sur peertube en bénéficiant du partage via webtorrent ?

Car j'ai peur que sans cette compatibilité il n'y aura que peu de migrations volontaires et le projet restera cantonné à des applications de niches.

Cela me semble logique que la documentation ait le même numéro de version que le code, et on peut (doit ?) rajouter un numéro supplémentaire pour la révision de la documentation en elle-même.

C’est ce qui est utilisé pour gérer les paquets deb :
1.2.3-4 avec 1.2.3 la version du logiciel et 4 la révision de la documentation.

Merci pour cette formation rapide :-)

Et il cherche un sponsor !

https://lists.debian.org/debian-mentors/2018/03/msg00241.html

:-)

Une nouvelle version de TapTempo, super !

Que représente le working-storage section avec sa syntaxe étonnante `01 ws-tap-moy-s pic 9(9)v9(9).̀  ?
Est-ce la déclaration des variables du programme ?

Il fait peut être référence à la levée de fond :

GitLab a réalisé une levée de fonds de vingt millions de dollars, notamment auprès de GV (Google Ventures)

La plupart des portages reprennent les chaînes de caractères à l'identique. Est-ce que ça les rend produits dérivés, et donc GPL-v3 comme l'original ?

Demande faite: https://github.com/Taptempo-Federation/Taptempo-Federation/issues/28

Bravo pour cette nouvelle version, surtout pour les tests unitaires !

J'ai regardé les fichiers du dossier test, et j'ai du mal à comprendre ce qui est fait. Par exemple :

(deftest calc-tempo-test
  (testing "calc-tempo from 0"
    (is (= (calc-tempo [1]) [nil 1]))
    (is (= (calc-tempo [60000 0]) [1N 2]))
    (is (= (calc-tempo [120000 60000 0]) [1N 3]))
    (is (= (calc-tempo [180000 120000 60000 0]) [1N 4]))
    (is (= (calc-tempo [240000 180000 120000 60000 0]) [1N 5]))
    (is (= (calc-tempo [300000 240000 180000 120000 60000 0]) [1N 6]))
    (is (= (calc-tempo [360000 300000 240000 180000 120000 60000 0]) [1N 7])))
  (testing "calc-tempo from 0 quicker"
    (is (= (calc-tempo [36000 30000 24000 18000 12000 6000 0]) [10N 7])))
  (testing "calcl-tempo from 1000"
    (is (= (calc-tempo [361000 301000 241000 181000 121000 61000 1000]) [1N 7])))
  (testing "calc-tempo from 1000 quiker"
    (is (= (calc-tempo [37000 31000 25000 19000 13000 7000 1000]) [10N 7])))
  (testing "calc-tempo for some validated entries"
    (is (= (calc-tempo [1521057817004]) [nil 1]))
    (is (= (calc-tempo [1521057820183 1521057817004]) [60000/3179 2]))
    (is (= (calc-tempo [1521057820602 1521057820183 1521057817004]) [60000/1799 3]))
    (is (= (calc-tempo [1521057821046 1521057820602 1521057820183 1521057817004]) [90000/2021 4]))
    (is (= (calc-tempo [1521057821469 1521057821046 1521057820602 1521057820183 1521057817004]) [48000/893 5]))
    (is (= (calc-tempo [1521057821914 1521057821469 1521057821046 1521057820602 1521057820183 1521057817004]) [30000/491 6]))
    (is (= (calc-tempo [1521057822350 1521057821914 1521057821469 1521057821046 1521057820602 1521057820183]) [300000/2167 6]))
    (is (= (calc-tempo [1521057822807 1521057822350 1521057821914 1521057821469 1521057821046 1521057820602]) [20000/147 6]))
    (is (= (calc-tempo [1521057823243 1521057822807 1521057822350 1521057821914 1521057821469 1521057821046]) [300000/2197 6]))
    (is (= (calc-tempo [1521057823700 1521057823243 1521057822807 1521057822350 1521057821914 1521057821469]) [300000/2231 6]))
    (is (= (calc-tempo [1521057824167 1521057823700 1521057823243 1521057822807 1521057822350 1521057821914]) [100000/751 6]))
    (is (= (calc-tempo [1521057824633 1521057824167 1521057823700 1521057823243 1521057822807 1521057822350]) [100000/761 6]))))

Tu passes les timestamps en entrée du programme ?

Super, merci beaucoup pour ces explications. Ça donne envie de faire du vrai fonctionnel :)

Concernant la récursivité en OCaml, y a-t-il une limitation du nombre d'appel récursif comme dans la plupart des langages impératifs ?

c'est le source le plus court du taptempo.

Vu qu'il n'y a pas de paramètres d'entrées ni de régionalisation, je crois que le code golf en JavaScript est plus court :
https://linuxfr.org/users/wawet76/journaux/portage-de-taptempo-en-javascript#comment-1730795

Tant mieux si l'auteur n'était pas au courant de l'autre version comme ça c'est une deuxième approche avec le même langage, ça reste intéressant à lire !

D'ailleurs la première version avait des soucis avec l'entrée standard, est-ce que l'utilisation de $char = \stream_get_contents(STDIN, 1); permet d'éviter les mêmes écueils ?

Merci pour cette version très didactique. J'ai testé avec GNU APL et ça a l'air de bien fonctionner !

Avec tous ces caractères Unicode j'ai l'impression de jouer à Dwarf Fortress ;-)

[Au passage, il y a quelques phrases marrantes sur la page Wikipédia à la rubrique Quelques_opinions.]

Merci pour les explications :-)

Wahoo, encore plus compacte !
Pour moi c'est quasiment aussi cryptique que du BrainFuck quand je lis ce genre de ligne :

: calc-tempo steps 60 1000 1000 * * * s>f drop now swap - s>f f/ ;

Après test, le tempo n'est affiché que toutes les 6 frappes, c'est voulu ?

Marrant cette version :-)
Je ne connais pas le protocole telnet, mais est-ce qu'on pourrait imaginer passer des arguments à la connexion pour régler le nombre d'échantillons ou la précision ?

Sympa cette version !
Je ne vois pas où se situe la boucle qui permet d'afficher les tempi successifs comme dans l'original. Est-elle cachée dans les appels récursifs ou il n'y a qu'un seul tempo qui est calculé lorsqu'on entre la lettre “q” ?

Mis à part la parenthésite aigüe héritée de Lisp, cette version est vraiment compacte ! Merci :-)

Merci pour ces éclaircissements !

ça a l'air super ce langage, mais est-on obligé d'utiliser flash ?

Sous Debian buster, j'ai essayé d'ouvrir l'archive avec scratch 1.4 mais ça n'a pas l'air retro-compatible :(

Bonjour, j'ai du mal à comprendre le benchmark effectué. Pouvez-vous m'éclairer ?

j'ai essayé de comparer nos bons vieux Winterfell avec un serveur 16vCPU/64GB de chez Digital Ocean sur une compilation de linuxboot.

En quoi le système de boot influe sur le temps de compilation qui je suppose se déroule dans le "vrai" système d'exploitation ?

Bravo pour ce portage qui me rend curieux de tester l'iso-fonctionnalité avec l'original.
Peux-tu m'expliquer comment le compiler et l'exécuter ?
Je vois que le fichier jbuild décrit les dépendances; sont-elles automatiquement téléchargées lors de la construction ?

Bravo pour la créativité :-)

J'ai cherché à comprendre comment tu détectes les "claps".

function detectClap(data){
      var t = (new Date()).getTime();
      if(t - lastClap < 200) return false; // TWEAK HERE
      var zeroCrossings = 0, highAmp = 0;
      for(var i = 1; i < data.length; i++){
        if(Math.abs(data[i]) > 0.25) highAmp++; // TWEAK HERE
        if(data[i] > 0 && data[i-1] < 0 || data[i] < 0 && data[i-1] > 0) zeroCrossings++;
      }
      if(highAmp > 20 && zeroCrossings > 30){ // TWEAK HERE
        //console.log(highAmp+' / '+zeroCrossings);
        lastClap = t;
        return true;
      }
      return false;
    }

Donc il faut que le signal sonore passe 20 fois au dessus de 0.25 en valeur absolue et 30 fois croiser l'origine ?
Est-ce que cette métrique est issue de tests en conditions réelles ? ;-)

J'ai du mal à comprendre la relation du Kotlin avec le Java. Le langage est interprété par une JVM ? et on peut utiliser directement d'autres modules java ?
Si oui, quel est son intérêt ? moins verbeux ?

(et merci pour cette version !)

Merci pour cette découverte, un langage en français plus sérieux que le GOTO++ ;-)