SpaceFox a écrit 1730 commentaires

Les vrais chiffres, c'est plutôt 33 % de rendement pour une centrale nucléaire actuelle, 36 % pour un EPR (s'il fonctionne un jour) et 40 % pour une centrale thermique à flamme.

Les chiffres des moteurs sont plus compliqués à trouver, mais apparemment c'est de l'ordre de 30 % pour un moteur essence, et 45 % pour un bon gros moteur diesel.

Note aussi que ton moteur électrique n'est pas forcément alimenté avec de l'électricité d'origine thermique à flamme. Ça peut être aussi du solaire, de l'éolien, de l'hydraulique…

La connaissance libre : https://zestedesavoir.com

Tous les moteurs électriques n'utilisent pas d'aimants. Typiquement, les moteurs asynchrones qui équipent les voitures 100 % électriques n'en utilisent pas.

La connaissance libre : https://zestedesavoir.com

le pourcentage très élevé de contenus sous licences CC-BY-SA sur le site (98%)

Je suis à peu près persuadé que c'est une conséquence du manque de choix et non une volonté de prendre cette licence en particulier – la preuve, j'ai mis longtemps à voir que par défaut mes journaux étaient publiés avec cette licence. L'expérience de Zeste de Savoir, c'est que beaucoup de gens laissent le choix par défaut, quel qu'il soit.

Cela dit, c'est toi le chef, tu fais bien ce que tu veux, et j'avoue avoir la flemme d'apprendre Ruby juste pour développer ça :)

La connaissance libre : https://zestedesavoir.com

Je te rassure, les développeurs Ubuntu ont eu la même réaction que toi, et aucune mise à jour ne se fait à l'arrêt tant que tu n'as pas coché la case qui le demande.

La connaissance libre : https://zestedesavoir.com

Oui, enfin ça ne fonctionne pas à l'infini. Windows se permet parfois d'ignorer superbement ce réglage, c'est du vécu.

La connaissance libre : https://zestedesavoir.com

Je confirme, j'ai suffisamment utilisé Windows pour savoir que le « Veuillez ne pas éteindre votre ordinateur pendant la mise à jour », c'est vieux chez eux.

Quant à savoir d'où vient l'ajout de cette fonctionnalité sur Ubuntu : ben là on est en plein dans la différence entre technique et perception utilisateur. Du point de vue de l'utilisateur (moi), cette fonctionnalité a été ajoutée à Ubuntu récemment et de façon efficace, les détails techniques du pourquoi du comment et de qui a inventé ça n'importent pas.

La connaissance libre : https://zestedesavoir.com

À noter que maintenant Windows a copié le comportement, le verrouillage majuscule est systématiquement désactivé à l'arrivée sur l'écran de login… par contre, ça fait un moment que je n'ai plus eu le problème avec un Linux (Debian et dérivés). Peut-être le premier jour à l'installation, mais après c'est retenu.

La connaissance libre : https://zestedesavoir.com

… mais je ne parle pas de standardisation mais d'ergonomie. Ça n'a absolument aucun rapport…

La connaissance libre : https://zestedesavoir.com

Ici je parle bien d'un cas particulier et de ce qu'il implique en terme d'ergonomie, avec un utilisateur qui était dans la cible du projet :

The purpose of Linux Mint is to produce a modern, elegant and comfortable operating system which is both powerful and easy to use.

Tu me parles de généralités vagues au niveau de l'ensemble des distributions et avec des suppositions (que je trouve hasardeuses) sur le fonctionnement d'un windowsien. Du coup, j'ai toujours du mal à comprendre quel est le rapport entre mon propos et tes commentaires, à part peut-être le plaisir de cracher sur Windows et Mint ? (en tous cas c'est l'impression que tu me laisse).

De plus, j'explique bien que dans ce cas, le fait que « Linux n'est pas Windows » n'entrait justement pas en ligne de compte. Parce que ça, Collègue l'avait bien compris.

La connaissance libre : https://zestedesavoir.com

les users de Arch en sont généralement très satisfaits et veulent le faire savoir au monde entier ;-)

Ici un ancien utilisateur de Arch pas satisfait, et qui ne voit pas l'intérêt de le faire savoir au monde entier →

(juste pour rappeler que ça existe aussi).

La connaissance libre : https://zestedesavoir.com

Je relativiserais le côté « invisible » des mises à jour Windows, mais je suis d'accord avec les grandes lignes. Disons que sur un PC très puissant c'est sans doute le cas ; sur un PC normal sans SSD, ça provoque des lags incompréhensibles (le système se fout de savoir si tu utilises le PC avant de lancer la MAJ) ; quant aux mises à jour « complètes » (celles qui réinstallent un Windows à côté de Windows), elles peuvent interdire tout traitement lourd pendant une journée de travail – vécu.

D'ailleurs, Ubuntu a implémenté les « mises à jour à l'arrêt de l'ordinateur ». Double avantage par rapport à celles de Windows : le système demande confirmation, et c'est beaucoup plus rapide.

La connaissance libre : https://zestedesavoir.com

Je ne comprends pas où tu veux en venir ?

La connaissance libre : https://zestedesavoir.com

Néanmoins on commence à avoir des jeux qui affichent un vrai gain avec plus de 4 cœurs (+27 % entre 4 et 6 cœurs sur TotalWar Warhammer par exemple).

Quant à ton contre-exemple… ben c'est un contre-exemple, on en trouvera toujours :)

La connaissance libre : https://zestedesavoir.com

en performance monothread (une grosse partie des clients x86 sont joueurs)

L'argument ne tient plus depuis quelques années. Les moteurs de jeux récents gèrent bien 4 threads, et certains beaucoup plus. Cf les tests sérieux de jeux récents (i.e. ceux cohérents avec les attentes des joueurs, pas ceux en 720p options mini et une GeForce 1080 Ti « pour bien montrer l'impact du CPU »). Ça avait notamment posé problème à l'arrivée des Ryzen à cause de leur gestion particulière du SMT et de la communication entre cœurs.

La connaissance libre : https://zestedesavoir.com

Et puis, AMD64 quand même. D'accord, l'architecture a été publiée y'a 18 ans et les premiers CPU y'a presque 15, mais c'est pas à négliger dans l'histoire de x86.

La connaissance libre : https://zestedesavoir.com

Pour un usage type serveur, ça ne m'étonne pas. On a beaucoup de charges serveur aujourd'hui qui ne sont pas limitées par la puissance CPU, mais par autre chose (I/O, typiquement). De plus, beaucoup d'usages CPU sont très massivement parallélisables et s’accommodent bien d'une configuration type « 2 x plus de cœurs, 2 x moins puissants unitairement, mais qui consomment 4 x moins ».

Pour les ordinateurs personnels, par contre, c'est toujours pas ça… la preuve les récents tests des PC Windows 10 sous ARM, comme le Asus NovaGo. Où l'on s’aperçoit que même avec des applications natives ARM les performances ne sont pas au niveau d'un ordinateur x86. J'imagine aussi que c'est une question de perception : des performances considérées comme acceptables sur une tablette ne le sont plus sur un ordinateur, surtout quand tu as en face un ordinateur de même format, de même prix mais sensiblement plus puissant.

La connaissance libre : https://zestedesavoir.com

Pour rebondir sur la question des vis et de Lenovo : on trouve de tout chez Lenovo en terme de réparabilité, mais en gros :

1. Séries grand public : bof (parce qu'ils s'en cognent),
2. Séries ultra-portable / semi-tablettes : par conception, c'est très peu réparable
3. Séries pro « normales » (pas dans le point 2) : là en général c'est pas mal.

D'expérience, ce que l'utilisateur est censé accéder (extension de RAM, stockage…) est très facilement accessible (peu de vis, trappes dédiées…). Le reste… c'est démontable mais ça peut être long et nécessiter de bouger beaucoup de vis. Par exemple, sur mon ThinkPad L430, j'ai pu changer la carte wifi qui était morte. Et surprise, l'une des deux barrettes de RAM est accessible, mais l'autre est planquée sous le clavier.

Assez curieusement je n'ai jamais eu de problème avec les vis de PC portable, mais très souvent avec celles pour PC fixe ou serveur. Mais le problème était systématiquement au niveau de la tête de vis, jamais du pas de vis. Le classique, c'est la vis qui ne tient pas, et dont la tête de vis devient ronde tellement le métal est mou dès qu'on serre un peu.

La connaissance libre : https://zestedesavoir.com

Donc si je résume ta « procédure de test » :

• Tu commences par paramétrer les trois moteurs avec des valeurs arbitraires sans vérifier qu'ils ont les mêmes besoins.
• Tu fais des requêtes sur des tables dont on ne sait rien (volumétrie, index…) sauf à aller fouiller un lien externe.
• Tu ne t'intéresses absolument pas à ce qui fait que ces requêtes sont lentes (CPU ? Accès disque ?) – or c'est important pour pouvoir extrapoler les résultats à quoi que ce soit d'autre.
• Surtout, tu en tires des conclusions sur les différences entre les noteur alors que le vrai choix d'un moteur se fait sur ses fonctionnalités d'abord et avant tout.

En résumé, tu testes un cas particulier et tu te permet d'en tirer des conclusions qui sont de la pure spéculation.

Enfin, ta dernière remarque me laisse penser que tu hébergeais du WordPress sur du MySQL avec autre chose que InnoDB comme moteur, mais tu ne dis pas lequel. Si c'était MyISAM, tu ne garantissais pas la cohérence des données.

Tout ça me fait penser que je ne suis pas certain de vouloir suivre tes formations sur le sujet.

La connaissance libre : https://zestedesavoir.com

Et encore, tes exemples sont relativement cohérents. Mais parfois, on trouve des choix déments qui pourtant concernent des contenus très connus.

Pendant des années, en France, on pouvait trouver facilement en DVD « Les valeurs de la famille Addams » (le second des deux films sortis aux cinéma), mais pas « La Famille Addams » (le premier). Le DVD avait existé, a longtemps été épuisé, mais l'éditeur n'a pas jugé utile de le rééditer jusque environ la sortie des formats HD.

La connaissance libre : https://zestedesavoir.com

Il y en a au moins 2 sous licences libres :

• L'original est sous GPL v3,
• Ma version Kotlin est sous MIT.
• Et j'ai la flemme de vérifier les autres :D

J'ai l'impression qu'on est en plein dans le même cas que les codes donnés en réponse sur StackOverflow : c'est des machins trop petits pour que les auteurs ne serait-ce que pensent à y associer une licence, vu que le code est directement donné dans un message.

La connaissance libre : https://zestedesavoir.com

Le PoE nécessite un switch spécial, et à ma connaissance aucune box d'aucun opérateur français ne le propose.

La connaissance libre : https://zestedesavoir.com

(Je note qu'une personne ici semble trouver inutile de s'excuser quand on a diffusé de la merde. Je trouve ça triste).

La connaissance libre : https://zestedesavoir.com

Ha merde. Moi qui avait fait confiance à Next INpact pour éviter de relayer de la merde… toutes mes confuses !

La connaissance libre : https://zestedesavoir.com

Blanc. Noyé, si c'est en été.

La connaissance libre : https://zestedesavoir.com

À noter que Kotlin (enfin, au moins IntelliJ) permet de convertir du code Java en Kotlin. Ça fonctionne, mais nécessite un peu de nettoyage et de « Kotlinisation » du code.

Par exemple, si je convertis le TapTempo Java directement, j'obtiens (après avoir remis les fonctions directement dans le fichier, sans passer par un objet inutile) :

package com.i2bp.taptempo

import org.apache.commons.cli.CommandLine
import org.apache.commons.cli.CommandLineParser
import org.apache.commons.cli.DefaultParser
import org.apache.commons.cli.HelpFormatter
import org.apache.commons.cli.Option
import org.apache.commons.cli.Options
import org.apache.commons.cli.ParseException

import java.text.DecimalFormat
import java.util.Scanner
import java.util.ArrayDeque
import java.util.Date
import java.util.Deque

fun computeBPM(currentTime: Long, lastTime: Long, occurenceCount: Int): Double {
    var occurenceCount = occurenceCount
    if (occurenceCount == 0) {
        occurenceCount = 1
    }

    val elapsedTime = (currentTime - lastTime).toDouble()
    val meanTime = elapsedTime / occurenceCount

    return 60.0 * 1000 / meanTime
}

fun main(args: Array<String>) {

    var precision = 0
    var resetTime = 5
    var sampleSize = 5
    val options = Options()
    val hitTimePoints = ArrayDeque<Long>()

    val optHelp = Option("h", "help", false, "Display this help message.")
    optHelp.isRequired = false
    options.addOption(optHelp)

    val optPrecision = Option("p", "precision", true, "Set the decimal precision of the tempo display. Default is 0 digits, max is 5 digits.")
    optPrecision.isRequired = false
    options.addOption(optPrecision)

    val optResetTime = Option("r", "reset-time", true, "Set the time in second to reset the computation. Default is 5 seconds.")
    optResetTime.isRequired = false
    options.addOption(optResetTime)

    val optSampleSize = Option("s", "sample-size", true, "Set the number of samples needed to compute the tempo. Default is 5 samples.")
    optSampleSize.isRequired = false
    options.addOption(optSampleSize)

    val optVersion = Option("v", "version", false, "Display the version.")
    optVersion.isRequired = false
    options.addOption(optVersion)

    val parser = DefaultParser()
    val formatter = HelpFormatter()
    var cmd: CommandLine? = null

    try {
        cmd = parser.parse(options, args)
        if (cmd!!.hasOption('p')) {
            precision = Integer.parseInt(cmd.getOptionValue('p'))
            if (precision < 0) {
                precision = 0
            } else if (precision > 5) {
                precision = 5
            }
        }
        if (cmd.hasOption('r')) {
            resetTime = Integer.parseInt(cmd.getOptionValue('r'))
            if (resetTime < 1) {
                resetTime = 1
            }
        }
        if (cmd.hasOption('s')) {
            sampleSize = Integer.parseInt(cmd.getOptionValue('s'))
            if (sampleSize < 1) {
                sampleSize = 1
            }
        }
    } catch (e: ParseException) {
        println(e.javaClass.toString() + ": " + e.message)
        formatter.printHelp("TempoTap", options)
        System.exit(1)
    } catch (e: NumberFormatException) {
        println(e.javaClass.toString() + ": " + e.message)
        formatter.printHelp("TempoTap", options)
        System.exit(1)
    }

    if (cmd!!.hasOption('h') || cmd.hasOption('v')) {
        if (cmd.hasOption('h')) {
            formatter.printHelp("TempoTap", options)
        }
        if (cmd.hasOption('v')) {
            println("Version: 1.0")
        }
        System.exit(0)
    }

    val df = DecimalFormat()
    df.maximumFractionDigits = precision
    df.minimumFractionDigits = precision

    println("Hit enter key for each beat (q to quit).\n")

    val keyboard = Scanner(System.`in`)
    keyboard.useDelimiter("")

    var shouldContinue = true
    while (shouldContinue) {

        var c: Char
        do {
            c = keyboard.next()[0]
            if (c == 'q') {
                shouldContinue = false
                println("Bye Bye!\n")
                break
            }
        } while (c.toInt() != 10)

        if (shouldContinue) {
            val currentTime = System.currentTimeMillis()

            // Reset if the hit diff is too big.
            if (!hitTimePoints.isEmpty() && currentTime - hitTimePoints.last > resetTime * 1000) {
                // Clear the history.
                hitTimePoints.clear()
            }

            hitTimePoints.add(currentTime)
            if (hitTimePoints.size > 1) {
                val bpm = computeBPM(hitTimePoints.last, hitTimePoints.first, hitTimePoints.size - 1)

                val bpmRepresentation = df.format(bpm)
                println("Tempo: $bpmRepresentation bpm")
            } else {
                println("[Hit enter key one more time to start bpm computation...]")
            }

            while (hitTimePoints.size > sampleSize) {
                hitTimePoints.pop()
            }
        }
    }
}

Bref, c'est surtout utile pour :

• Avoir une base de code cohérente.
• Vérifier comment un concept Java est censé se transcrire en Kotlin.

La connaissance libre : https://zestedesavoir.com