Duolingo annonce l’adoption de l’IA à la place des travailleurs contractuels

Quand j’ai essayé de rendre une roue carrée ronde, je me suis souvenu de ce que disait le patron : il ne faut pas réinventer la roue. Les esprits hantés par ce mantra sont encore nombreux autour de nous.

En laissant cela de côté, je trouve bien trop catégorique le fait de ne même pas envisager une quelconque intervention humaine,
Pour de simples ajustements de chiffres ou de messages, l’intervention humaine serait pourtant plus efficace qu’un LLM.

Je crois savoir qu’en définissant l’option temperature sur 0, on garantit la même sortie pour une même entrée.

La phrase « quickSort avec quickSort » me donne envie de me tenir la nuque.

Les LLM ne garantissent pas la même sortie pour une même entrée, donc ce genre de gestion de configuration fonctionne vraiment...?
Est-ce que c’est juste moi qui l’utilise encore de manière trop unidimensionnelle ?

Lorsque vous lisez l’article, vérifiez bien le contexte.

Je ne suis pas en train de me vanter de mon niveau en programmation. Ce que je souligne ici, c’est que du code médiocre comme quickSort(), utilisé dans l’exemple actuel, est mis en avant avec une priorité élevée par GPT.

Quand on fait plusieurs recherches avec GPT, il arrive souvent qu’il fournisse uniquement le résultat d’une fonction quickSort(). Et encore une fois, quickSort() n’est qu’un exemple. Quand on demande du code à GPT pour un vrai travail, il produit très souvent du code de qualité médiocre (je parle ici en tant qu’utilisateur payant). Si le développeur n’a pas lui-même la capacité de faire la différence, alors je partage l’avis de l’auteur de l’article : il y a de fortes chances que le projet prenne une mauvaise direction et finisse par être détérioré. C’est dans ce contexte que j’en suis arrivé à cette conclusion.

Autour de moi, je vois déjà de plus en plus de projets recouverts de ce type de code médiocre.

Mode YOLO...

Ils ont disposé les cases de façon à pouvoir sélectionner un bloc pour chacune, puis n’ont habillé que l’apparence avec du CSS ? C’est impressionnant, en tout cas.

Comme la réponse de GPT contenait à la fois quickSort et quicSortInPlace, et qu’un commentaire signalait la partie [...,quickSort(left), ...equal, ...quickSort(right)], j’avais compris qu’il fallait comparer quickSort avec quickSort et quickSortInPlace avec quickSortInPlace, mais visiblement ce n’est pas le cas.

Si l’affirmation du commentaire est exacte, Google n’aide-t-il pas de fait à commettre une infraction ?

Le texte est amusant, mais je commence à ressentir une certaine fatigue, parce que trop d’articles semblent pouvoir se résumer à : « ne pas utiliser l’IA n’est pas la solution à tout, mais lui faire une confiance aveugle et s’y soumettre n’est pas non plus souhaitable ».

J’en apprends beaucoup.

Bien sûr, la comparaison doit porter sur les performances des deux fonctions quickSort() et quickSortInPlace()........

Ah… j’ai compris ce que vous vouliez dire. Vous n’aviez pas compris ce qu’il fallait comparer avec quoi… l’algorithme quick sort n’a pas deux modes d’implémentation, quicksort et in-place……

Dès le départ, c’est le fait de rédiger puis de fournir aux utilisateurs de l’IA les fonctions quickSortGPT() et quickSort() du code ci-dessus (toutes deux générées par GPT), avec la fusion de tableaux intégrée, que je critiquais.

Partager un résultat affichant un écart de plus du double, allant jusqu’à 3 à 4 fois, puis dire que ce n’est probablement pas jusqu’à 2 fois ?

Même aujourd’hui, quand j’essaie de travailler avec des développeurs dans la quarantaine ou la cinquantaine, il y a des moments où ça me rend dingue à cause de ceux qui veulent développer avec des méthodes d’il y a plusieurs décennies, lol. Personnellement, je pense que, comme au Japon, la société serait plus saine si les jeunes pouvaient obtenir des emplois stables plutôt que des petits boulots ou des postes précaires, et si les personnes âgées occupaient surtout des emplois journaliers ou des petits boulots. En Corée, la répartition des revenus du travail se fait selon une pyramide inversée, donc plus le temps passe, plus le phénomène consistant à retirer l’échelle aux suivants ne fait que s’aggraver.

Les plateformes de soins infirmiers vérifient la situation de crédit des infirmières via des courtiers en données, et plus elles ont de dettes, plus le salaire proposé est bas

Comment ces données sont-elles fournies ?

Je l’ai exécuté moi-même, et il a bien tendance à être un peu plus lent, mais ça ne semble pas aller jusqu’à 2x.

function quickSortInPlace(arr, left = 0, right = arr.length - 1) {  
    if (left >= right) return;  
  
    const pivotIndex = partition(arr, left, right);  
    quickSortInPlace(arr, left, pivotIndex - 1);  
    quickSortInPlace(arr, pivotIndex + 1, right);  
}  
  
function partition(arr, left, right) {  
    const pivot = arr[right];  
    let i = left;  
  
    for (let j = left; j < right; j++) {  
        if (arr[j] < pivot) {  
            [arr[i], arr[j]] = [arr[j], arr[i]];  
            i++;  
        }  
    }  
  
    [arr[i], arr[right]] = [arr[right], arr[i]];  
    return i;  
}  
  
function quickSort(arr) {  
    if (arr.length <= 1) return arr;  
  
    const pivot = arr[arr.length - 1];  
    const left = [];  
    const right = [];  
  
    for (let i = 0; i < arr.length - 1; i++) {  
        if (arr[i] < pivot) {  
            left.push(arr[i]);  
        } else {  
            right.push(arr[i]);  
        }  
    }  
  
    return [...quickSort(left), pivot, ...quickSort(right)];  
}  
  
// =============  
  
function quickSortGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSort expects an array');  
    }  
    if (arr.length <= 1) return [...arr];  
  
    const pivot = arr[Math.floor(arr.length / 2)];  
    const left = [];  
    const equal = [];  
    const right = [];  
  
    for (const el of arr) {  
        if (el < pivot) left.push(el);  
        else if (el > pivot) right.push(el);  
        else equal.push(el);  
    }  
  
    return [...quickSortGPT(left), ...equal, ...quickSortGPT(right)];  
}  
  
function quickSortInPlaceGPT(arr) {  
    if (!Array.isArray(arr)) {  
        throw new TypeError('quickSortInPlace expects an array');  
    }  
  
    const stack = [[0, arr.length - 1]];  
  
    while (stack.length) {  
        const [lo, hi] = stack.pop();  
        if (lo >= hi) continue;  
  
        const pivotIndex = partitionGPT(arr, lo, hi);  
  
        // Tail‑recursion elimination: push larger partition first  
        if (pivotIndex - 1 - lo > hi - (pivotIndex + 1)) {  
            stack.push([lo, pivotIndex - 1]);  
            stack.push([pivotIndex + 1, hi]);  
        } else {  
            stack.push([pivotIndex + 1, hi]);  
            stack.push([lo, pivotIndex - 1]);  
        }  
    }  
    return arr;  
}  
  
function medianOfThreeGPT(a, b, c) {  
    return (a - b) * (c - a) >= 0 ? a  
        : (b - a) * (c - b) >= 0 ? b  
            : c;  
}  
  
function partitionGPT(arr, lo, hi) {  
    const mid = lo + ((hi - lo) >> 1);  
    const pivotValue = medianOfThreeGPT(arr[lo], arr[mid], arr[hi]);  
  
    while (true) {  
        while (arr[lo] < pivotValue) lo++;  
        while (arr[hi] > pivotValue) hi--;  
  
        if (lo >= hi) return hi;  
  
        [arr[lo], arr[hi]] = [arr[hi], arr[lo]];  
        lo++;  
        hi--;  
    }  
}  
  
function testQuicksort(qs, qsp) {  
    const repeat = 100;  
    const arrLength = 100000;  
    const unsortedArray = new Array();  
    for (let i = 0; i < arrLength; i++)  
        unsortedArray.push(Math.round(Math.random() * arrLength));  
  
    let sorted = [];  
  
    const qb = performance.now();  
    for (let i = 0; i < repeat; i++)  
        sorted = qs(unsortedArray);  
    const qe = performance.now();  
  
    const rqb = performance.now();  
    for (let i = 0; i < repeat; i++) {  
        let copied = [...unsortedArray];  
        qsp(copied);  
    }  
    const rqe = performance.now();  
  
    // jusqu’à 2 chiffres après la virgule  
    const p1 = ((qe - qb) / repeat).toFixed(2);  
    const p2 = ((rqe - rqb) / repeat).toFixed(2);  
    
    console.log(`Quicksort: ${p1} ms, In-place: ${p2} ms`);  
}  
  
function main() {  
    const useGPT = process.argv.includes('--gpt');  
    console.log(`Using ${useGPT ? 'GPT' : 'geekNews'} quicksort implementation.`);  
    if (useGPT) {  
        testQuicksort(quickSortGPT, quickSortInPlaceGPT);  
    } else {  
        testQuicksort(quickSort, quickSortInPlace);  
    }  
}  
  
main();  

===
node q.js
Using geekNews quicksort implementation.
Quicksort: 29.55 ms, In-place: 9.94 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 28.42 ms, In-place: 9.07 ms
node q.js
Using geekNews quicksort implementation.
Quicksort: 26.91 ms, In-place: 9.15 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 28.73 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 26.87 ms, In-place: 9.22 ms
node q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.97 ms, In-place: 9.30 ms
node --version
v22.14.0

bun q.js
Using geekNews quicksort implementation.
Quicksort: 32.05 ms, In-place: 17.39 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 30.97 ms, In-place: 17.82 ms
bun q.js
Using geekNews quicksort implementation.
Quicksort: 29.73 ms, In-place: 16.14 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 30.61 ms, In-place: 12.63 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 31.09 ms, In-place: 12.76 ms
bun q.js --gpt
Using GPT quicksort implementation.
Quicksort: 33.24 ms, In-place: 12.75 ms
bun --version
1.2.14

deno q.js
Using geekNews quicksort implementation.
Quicksort: 32.30 ms, In-place: 6.79 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.79 ms, In-place: 6.86 ms
deno q.js
Using geekNews quicksort implementation.
Quicksort: 26.09 ms, In-place: 6.85 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 27.18 ms, In-place: 7.92 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.34 ms, In-place: 8.12 ms
deno q.js --gpt
Using GPT quicksort implementation.
Quicksort: 25.39 ms, In-place: 8.09 ms
deno --version
deno 2.3.3 (stable, release, x86_64-pc-windows-msvc)
v8 13.7.152.6-rusty
typescript 5.8.3

....Hein ?