barmic 🦦 a écrit 5783 commentaires

En faite ça dépend beaucoup de comment tu vis les appels téléphoniques. Moi je déteste ça, même si c'est un ami, j'ai un soupir avant de décrocher. Alors non ça n'est pas une raison pour insulter mais ça ne me met pas dans un état permettant d'être cordial avec eux.

Globalement je ne répond pas en principe sauf quand j'attends un appel et c'est extrêmement frustrant de recevoir un appel d'une escroquerie quand tu attends un appel qui est important pour toi.

Mes parents se font emmerder comme ça sur téléphone fixe. Ils entendent l'appel faut arrêter ce qu'ils font aller prendre le combiné, décrocher vite car ils craignent de mettre trop de temps, prendre une litanie d'un gars qui récite son discours vite qu'ils ne comprennent pas, donc prendre le temps pour comprendre que ce n'est pas un résultat d'analyse, la mairie, mais bien une société qui pensent que le temps des gens ne comptent pas plus que leur profit, arrêter l'appel et revenir sur ce que tu étais.

Pour ce qui est de la personne au bout du fil. Elle ne fait probablement pas ce métier par choix ou par passion et elle doit subir des conditions de travail désastreuses. Ça ne change pas le fait que son travail c'est d'importuner les gens. Et si tartampion de la société dtc ne t'appelle qu'une seule fois leur nombre apparenterait la pratique à du harcèlement.

On parle de manœuvre qui sont tellement devenues légions que tous les français connaissent le problème, qu'on a dû légiférer plusieurs fois dessus, qu'il existe des centaines d'applications pour tenter de palier au problème, que les fabricants de téléphones eux-mêmes tentent de proposer des solutions,…

C'est très bien si certains restent calme devant eux, mais faut comprendre qu'aussi humains soit-ils ils ont ajouté leur contribution à l'agression de quelqu'un et s'apprêtent à recommencer dans la foulée et en auront fait quelques dizaines dans la journée.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

barmic< parlait du noyau Linux dans la phrase que j’ai citée, je répondais donc sur le cas Linux, pas sur LibreOffice.

Effectivement pour Linux le peu de remou qu'à donné le choix de Linus montre surtout qu'il n'y avait pas beaucoup de valeur dans l'utilisation de semver.

Personnellement je trouve que c'est un point important de calver de se démarquer de semver. Le nombre de logiciels et de bibliothèques que les utilisateurs croient à tort qu'ils sont en semver est important à mon avis et donner une fausse information me paraît d'autant plus regrettable.

Merci pour l’exemple. Ceci dit c’est quoi l’utilité par rapport à l’utilisation d’un bête entier (ie: sans le préfixe "0.") ? Se garder une possibilité de passer à une 1.X dans le futur pour une raison encore inconnue ?

Chaque projet sa raison. Je présume que c'est une absence de décision. Personne dans le projet ne pousse pour passer à une version 1 (ce qui demande de mettre un coup de tampon pour ne pas toucher à la compatibilité) et ça n'avance pas. Si les utilisateurs eux-mêmes s'en foutent comme c'est de plus en plus le cas ben ça reste en l'état et ça ne gêne qu'une minorité et les amoureux de semver.

Il semble qu’il y a une subtilité supplémentaire dans le cas de gettext, […]

Il y a une subtilité supplémentaire dans tous les projets quelque soit leur schéma de versionnement. Ceux qui qui utilisent calver, mais font des versions correctives à la semver (comme va le faire LibO), ceux qui au contraire ne font qu'avancer,… Dans semver ceux qui utilisent les mineurs pair pour les versions stables et impair pour les versions de développement, ceux qui utilisent le mineur 99 pour la version de développement,…

Chaque projet a sa petite excentricité.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Considérant ces deux points (aucun lien avec des sorties à date fixe et perte d’informations importante sur la maturité du logiciel et la nature des changements), est-ce que quelqu’un⋅e peut me dire pourquoi tous les projets s’y mettent les uns après les autres ?

Ce n'est pas que tous les logiciels s'y mettent, mais que c'est un versionement où ça se voit que ça n'est pas semver et comme pleins de gens croient que semver est l'alpha et l'oméga du versionement. Parmi les logiciels qui ne suivent pas semver il y a ceux qui passent à calvers et systématiquement ça crée un débat (alors que la sortie de la version 3 de linux n'avait pas tant fait parler) et passer de 0 à plusieurs logiciels qui l'utilise ça donne une impression de beaucoup.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Je pense plutôt qu’il l’a fait, au début… puis fini par arrêter, de manière progressive. Progressive mais assez rapide je pense, une fois qu’on a cédé on en a vite plus rien à foutre ! ^{^}

Ça m'exaspère de voir quelqu'un non chalamant préférer envisager de la paresse chez autrui sans faire le petit effort de vérifier.

La première version majeure de LibO est la 4.0 sortie il y a 10 ans. La raison qu'on pourrait se dire c'est une incompatibilité pour certaines extensions… Qu'ils ont recassé en version 4.0.1 puis 4.0.2.

OOo 3 avait un changement de licence, mais c'est difficile de vérifier s'ils respectaient véritablement semver.

Alors est-ce qu’avec CalVer on utilise 1970, ou 1970.1.1, pour cette étape embryonnaire du bousin ?

Je n'ai jamais vu de logiciels ou bibliothèques utiliser calvers en early.

je vois des collègue envisager sérieusement d’utiliser des versions 0.X de logiciel, à chaque fois je fais aucun commentaire mais quand j’entends trois ou quatre mois plus tard que le logiciel en question est maintenant « obsolète » mes sentiments sont partagés. o

Il ne faut pas confondre semver et 0ver. Par exemple gettext ça fait 37 ans qu'ils sont sur la 0.x.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Parce que soit tu numérotes bêtement par YYYY.MM selon la date à laquelle tu sors la version, sans autre considération, et je suis d’accord que ce n’est absolument pas arbitraire dans ce cas mais tu perds alors toute indication de maturité/compatibilité du logiciel. Soit tu acceptes de sortir une version 2015.XX en 2016 ou en 2017, parce qu’il n’y a pas de changement majeur, comme un des exemples du lien que tu donnes (Teradata), mais c’est alors l’indication de chronologie qui perd toute véracité.

Un paquet de logiciels ne peuvent pas utiliser semver. Ça n'a aucun sens pour eux. Et pour te sortir une autorité que peu se permettront de remettre en cause ici, c'est le cas de linux. Linux n'utilise pas semver. Il est impossible de serialiser toutes les API du noyau en un seul numéro de version. Donc ben ils ont arrêté d'essayé. Au final ils ont un truc arbitraire. La branche 6 comme toutes celles depuis la branche 2.6 se font à la subjectivité de Linus qui ne dis qu'une seule chose de concret : la branche 6 ne change pas de la branche 5.

Mais prenons quelque chose qui est plus proche de LibO comme LibO lui-même par exemple. Qu'est-ce qui a motivé le passage à une version 7 ? L'ajout de fonctionctionnalités qui leur paraissaient importantes (c'est ce que dis le blog de la document fundation). Ce n'est pas du semver, je ne sais pas si ça l'a était un jour, mais ça fait quelques années que ça n'est pas le cas.

Les gens s’interrogent parce qu'ils découvrent que ça n'est pas du semver, mais n'ont jamais rencontrés de problème jusque là.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Tu t'es pris la tête je trouve pour la comparaison en binaire.

J'ai fais un xor et j'ai vérifié s'il donnait une puissance de 2

let c = a_data ^ b_data;
return (c & (c - 1)) == 0;

Il y a 2 subtilités :

• le test répond oui pour 0
• on accepte qu'une seule différence sur la map

Du coup j'ai une condition

if c == 0 {
    return 0;
} else if (c & (c - 1)) == 0 {
    return 1;
} else {
    return 2;
}

La spécifictité de ce code fais que ma partie 1 et ma partie 2 sont assez distinct, mais je suis à ~500µs.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Ah oui c'est un cache des branches de l'arbre.

J'aimerais bien tout de même aller plus loin dans l'approche constructiviste. Voir jusqu'où ça peut mener. Il y a un paquet de possibilité d'optimisations, mais ça augmente la complexité algorithmique de l'implémentation.

Je vais par contre mettre ça de côté, vu le retard que j'ai et mon manque de temps…

Merci beaucoup je vais prendre le temps de lire vos échanges.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

J'ai mal calculé la complexité du premier, mais je pense que mon calcul de validation partielle pourrait être plus agressif (pour le moment il s'arrête au premier ?, alors qu'il pourrait regarder le reste. Je vois au moins 1 raccourcis : considérer tous les ? comme des . et voir si c'est valide (au quel cas on s'arrête immédiatement) ou partiellement valide (et là on continue).

En l'écrivant je me dis que la validation partielle pourrait indiquer jusqu'où est-ce que la validation est exact et que ça permettrait de faire des sauts dans l'arbre.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Moi je fais ça depuis que j'ai activé l'option d'être par défaut en navigation privée.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Je met mon message en réponse à vous 2 au cas où vous auriez un peu de temps. Je bute sur la partie 2 et je voudrais pas lire une solution directement donc j'ai essayé de ne lire que le minimum de vos échanges pour savoir si vous aviez une solution vraiment plus efficace que la mienne et c'est le cas.

Pour la partie 1 j'ai fais du bête de chez bête j'itère de 0 à 2 puissance le nombre de ? et je place de # là où j'ai des 1 et des . là où j'ai des 0 dans le nombre courant.

Évidement O(2ⁿ⁾ ça marche pas pour la partie 2. J'ai repris la question autrement et je conçois les solutions possibles comme un arbre binaire je fais un parcours en largeur de l'arbre pour pouvoir couper les branches dès que je vois qu'elles ne marchent pas.

Si je montre ça en pseudo code python ça donne :

paths=['???.###????.###????.###????.###????.###']

result=0
while len(paths) > 0:
    current_path=pop(paths)
    switch one_step(current_path, [1,1,3,1,1,3,1,1,3,1,1,3,1,1,3]:
        case Success:
            result += 1
        case Fail:
            pass
        case Path(p1, p2):
            paths.append(p1)
            paths.append(p2)

avec one_step() qui vérifie s'il y a encore des ? si ce n'est pas le cas il vérifie si c'est bon ou non et renvoie Success/Fail

s'il reste des ? il vérifie si c'est partiellement valide (il ne vérifie pas que tous les blocs sont présents) si ça ne l'est pas Fail si oui il renvoie la chaine qu'il a en argument 2 fois : une en ayant remplacé le prochain ? par un # et une ou c'est par un .

Pour moi je suis en O(log2(N)) et ça marche bien sur l'exemple mais pas du tout sur le puzzle.

Je suis complètement à côté de la plaque ? (là ça tourne depuis 23 minutes… :( )

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

% less --version
less 590 (GNU regular expressions)
Copyright (C) 1984-2021  Mark Nudelman

qui dit "mieux" ?

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

les médias ne sont pas en cause

Je suis tellement pas d'accord avec ça et toute la rhétorique du "ce n'est qu'un outil" marche moyennement. Si tu me vois me balader avec une AK47, est-ce que tu te dira que ce n'est qu'un outil et que j'ai peut être trouvé une façon de hacker l'objet pour en faire quelque chose de positif et sans danger ?

Ils ne sont pas l'alpha et l'omega du problème, mais ils en font parti.

Pour rester sur l'outil, je comprends qu'un couteau n'est pas forcément une arme, mais si tu prend un karambit tu va avoir du mal à couper ton saucisson avec.

Il y a beaucoup de choses qui ne sont pas neutres dans les média (au sens large j'inclus les réseaux sociaux) et l'impossibilité (voir l'inutilité) d'être neutre ne doit pas être une façon d'accepter n'importe quoi.

l'instruction et la diffusion d'informations vérifiées (et encore ou est la vérité ?)

Pareil je n'y crois à aucun moment. L'information n'est pas une binarité de vrai ou faux. Il y a des niveaux de confiance. Je peux prendre un appareil photo du turfu qui va signer les photos avec un GPG de l'espace, le choix du cadrage, l'angle que j'aurais pris pourra être un mensonge. On peut te présenter une manifestation comme vide ou pleine de monde facilement.

C'est un leurre d'espérer pouvoir créer une bulle de vérité, il faut au contraire accepter l'incertitude parce que sinon on fini moins armé pour lutter contre les angle-morts ou de nouvelles formes de mensonges.

De plus il faut voir que des discours contradictoires peuvent être vrais tous les 2 en même temps. C'est le cas en politique. Quand tu as 2 personnalités politiques qui expriment des avis potentiellement différents sur un sujet. Ils peuvent parfaitement avoir tous les 2 raisons, on est dans le champs de l'avis, de la vision du monde différentes ce n'est pas une question de vérité. Et ça me pose un vrai souci de voir placer ce genre de discours sur le même plan que des vérités factuelles et disqualifier n'importe qui en faisant croire que ce n'est pas une question de politique. On dit souvent qu'on dépolitise le débat. On tente de présenter la politique existante non pas comme une politique (qui peut légitimement changer dans une démocratie), mais comme une mécanique.

Bref tout ça non pas pour dire que tout devrait être sur un pied d'égalité ce qui laisse la place aux idées les plus folles. Par exemple ce n'est pas parce qu'on ne sait pas comment une construction a était faite qu'une hypothèse extraterrestre vaut aussi bien que les différentes théories de scientifiques.

Par contre ça place le complotisme non pas comme une sphère distincte de ce que serait les gens de savoir, mais comme un gradient dans le quel on est tous et où nous avons tous fais nos choix de manière plus ou moins éclairée, mais systématiquement avec ce que l'on a pu.

Et donc quoi faire ? S'armer contre les techniques pour tenter de détecter quand des méthodes de manipulation sont utilisée par exemple. horizon-gull est utile à mon avis.

Désolé j'ai fais un pavé…

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Relis la suite de commentaires ;)

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Pour qui conque s’intéresse pas particulièrement à LibO, j'ai aucune idée de quelle est la dernière version. À part en allant chercher je ne saurais dire si la version X que mon père utilise est vielle ou non.

En soit pour un logiciel comme LibO le semver n'a pas de sens. Il a pleins d'API et chacun suit son cycle de vie (les extensions, les thèmes, peut être une API pour le piloter, etc). Devoir pour un développeur d'extension changer son range de compatibilité pour un truc qui ne te concerne aucunement perd tout l’intérêt de semver.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

C'est pour ça que je pose la question. On a tendance à comprendre les phrases qui se suivent comme une continuation logique et dans le commentaire du dessus, je le comprends au premier abord comme :

1. hypothèse
2. explication de l'hypothèse
3. exemple de l'hypothèse

J'ai du mal à voir ce qu'apporte les exemples dans ton commentaire s'ils ont pour effet d'appuyer l'hypothèse que tu tente de nuancer dans ta première phrase.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Tu prends des développeurs du noyau linux et des efl comme arguments d'autorité représentant des personnes qui ne sont pas friands de technologie ?

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

En même temps, existe t-il de bons dérivés de debian avec Kde?

Puis pourquoi Kde? Pour moi c'est le pire bureau qui soit… Je comprends rien à ce journal. Tu prends n'importe quelle bureau autre, Debian est nickel.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Ça se voit particulièrement bien quand tu l'implémente en récursif, même si tu n'a pas l'optimisation puisque tu va implémenter une méthode qui prend une liste d'entier et qui en retourne 1 ou 2.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Et enfin, voilà le code de la méthode Hand.score, là où on se rend compte que tous les magiciens ont leur « trucs ». Je ne sais pas si j'aurais pu faire plus « intelligent », mais c'est assez clair je pense.

Personnellement je l'ai pris en compte pendant de calcul du jocker :

fn hand_type_jocker(hand: &String) -> u8 {
    let mut counters = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    for c in hand.chars().into_iter() {
        let i = CARDS_JOCKER.find(c).unwrap();
        counters[i] += 1;
    }
    let mut values = (0, 0);
    for i in 1..counters.len() {
        if counters[i] > values.0 {
            values = (counters[i], values.0);
        } else if counters[i] > values.1 {
            values = (values.0, counters[i]);
        }
    }
    let jocker = counters[0];
    values = (values.0 + jocker, values.1);
    match values {
        (5, _) => 6,
        (4, _) => 5,
        (3, 2) => 4,
        (3, _) => 3,
        (2, 2) => 2,
        (2, _) => 1,
        _ => 0,
    }
}

J'augmente la plus grand nombre de carte identique par le nombre de jocker.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

J'ai enfin le temps d'avancer. Comme toi j'ai même hésité à coder. Pour la diversité je poste ma réponse rust

use regex::Regex;
use std::env;
use std::io::{self, BufRead};

fn course(time: u64, distance: u64) -> u64 {
    let delta = (time * time) - (4 * distance);
    if delta <= 0 {
        return 0;
    } else {
        let sqrt = (delta as f64).sqrt();
        let t = time as f64;
        let x1 = (-t + sqrt) / -2f64;
        let x2 = (-t - sqrt) / -2f64;

        let mut min = x1.abs().ceil() as u64;
        let mut max = x2.abs().floor() as u64;
        if (time - min) * min == distance {
            min += 1;
        }
        if (time - max) * max == distance {
            max -= 1;
        }
        return max - min + 1;
    }
}

fn part1() -> u64 {
    let token_pattern = Regex::new(r"(\d+)").unwrap();
    let mut times: Vec<u64> = Vec::new();
    let mut distances: Vec<u64> = Vec::new();
    for line in io::stdin().lock().lines() {
        let l = line.unwrap();
        if l.starts_with("Time:") {
            for (_, [seed]) in token_pattern.captures_iter(&l).map(|c| c.extract()) {
                times.push(seed.parse::<u64>().unwrap());
            }
        } else if l.starts_with("Distance:") {
            for (_, [seed]) in token_pattern.captures_iter(&l).map(|c| c.extract()) {
                distances.push(seed.parse::<u64>().unwrap());
            }
        }
    }
    let mut result: u64 = 1;

    for (time, distance) in times.iter().zip(distances.iter()) {
        let ways = course(*time, *distance);
        result *= ways;
    }
    return result;
}

fn part2() -> u64 {
    let token_pattern = Regex::new(r"(\d+)").unwrap();
    let mut times = "".to_owned();
    let mut distances = "".to_owned();
    for line in io::stdin().lock().lines() {
        let l = line.unwrap();
        if l.starts_with("Time:") {
            for (_, [seed]) in token_pattern.captures_iter(&l).map(|c| c.extract()) {
                times.push_str(seed);
            }
        } else if l.starts_with("Distance:") {
            for (_, [seed]) in token_pattern.captures_iter(&l).map(|c| c.extract()) {
                distances.push_str(seed);
            }
        }
    }

    let time = times.parse::<u64>().unwrap();
    let distance = distances.parse::<u64>().unwrap();

    return course(time, distance);
}

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() > 1 && args[1] == "part2" {
        println!("Part 2: {}", part2());
    } else {
        println!("Part 1: {}", part1());
    }
}

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Là il ne s'agit pas d'une information au public, mais d'une bribe d'un problème bien plus large. Je ne me sens pas particulièrement informé par ce message. Il y a trop de sous texte, une part d'ego, un unique son de cloche,… Sorti de tout contexte ça ne permet pas au corps électoral d'être informé.

L'information de l'électeur pour un parti dont il ne sait même pas qu'il existe ne me paraît pas être si important. Ce genre de problèmes dans les partis très idéalistes. Il y en a toujours eu. Ils faisaient moins d'1% avant ils feront pas mieux après publicité ou pas.

Et c'est surtout donné sans contexte. Florie Marie est en désaccord idéologique avec le parti pirate. L'aspect anarchique et la volonté d'horizontalité est en contradiction avec son fonctionnement où son engagement la met sur le devant de la scène. Elle a choisi d'aller vers quelque chose qui ira plus dans cette direction. Quand on lit ces 2 derniers postes en comparaison de ce qu'elle décrivait dans l'émission backseat où je l'avais découvert il y a quelques années on voit un écart très important.

Ça ne veut pas dire qu'il n'y a pas de connards dans le PP, mais ça donne une autre lumière à ses "vous ne me méritez pas".

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

C'est le genre de communication qui n'a d'intérêt que pour les membres du parti. C'est impossible à lire sans connaître le pacif qu'il y a entre ces gens.

Elle n'est pas bien à ce poste, elle ne se sent pas respecté. Elle s'en va c'est très bien.

Je trouve que faire la publicité de ce message par contre n'est que de nature à envenimer leur situation.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Outre le fait que ce soit un concours basé sur un logiciel propriétaire

C'est malheureusement la norme dans l'e-sport.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Perso j'ai commencé à abandonné ssh. Je ne fais plus de manipulation direct sur la machine (ou alors en physique). Je publie la mise à jour d'un playbook qui est régulièrement récupéré par la machine qui vérifie la signature avant de le jouer et m'envoie un mail s'il y a eu un problème.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll

Pour vérifier ça, il faudrait voir si on a une baisse significative au moment où ça a était déployé.

https://linuxfr.org/users/barmic/journaux/y-en-a-marre-de-ce-gros-troll