Deixando isso de lado, é categórico demais presumir que nem se considera a intervenção humana,
no caso de ajustes simples em números ou mensagens, a intervenção humana tende a ser mais eficiente do que um LLM.

Pelo que eu sei, definir a opção temperature como 0 garante a mesma saída para a mesma entrada.

A frase "quickSort com quickSort" me faz levar a mão à nuca.

Os LLMs não garantem a mesma saída para a mesma entrada; será que um controle de versão desse jeito funciona mesmo...?
Será que eu ainda estou usando isso de forma unidimensional demais?

Ao ler o texto, por favor confira o contexto.

Não estou me gabando da minha habilidade de programação. O que estou apontando é que códigos ruins como o quickSort(), usado agora como exemplo, estão sendo exibidos com alta prioridade pelo GPT.

Se você fizer várias buscas no GPT, verá que em muitos casos ele fornece isoladamente o resultado da função quickSort() e, de novo, quickSort() é apenas um exemplo. Quando se pede código ao GPT para uso em trabalho, ele frequentemente gera códigos de qualidade muito baixa (falo pela experiência de um usuário pago). Se o próprio desenvolvedor não tiver a capacidade de distinguir isso, concordo com a opinião do autor do texto de que há uma grande chance de o projeto seguir por um caminho que o destrua, e foi assim que cheguei ao contexto atual.

Ao meu redor, já está aumentando continuamente o número de projetos recheados com esse tipo de código péssimo.

Modo YOLO...

Eles organizaram de forma que fosse possível selecionar um bloco em cada célula e usaram CSS só para estilizar a aparência? É realmente impressionante.

Na resposta do GPT havia tanto quickSort quanto quicSortInPlace, e como você apontou nos comentários a parte [...,quickSort(left), ...equal, ...quickSort(right)], eu entendi que a comparação deveria ser feita entre quickSort com quickSort e quickSortInPlace com quickSortInPlace, mas pelo visto não é isso.

Se a alegação do comentário for verdadeira, isso não significa que o Google está, na prática, ajudando a cometer um crime?

O texto é interessante, mas fico um pouco cansado porque parece que muitos artigos podem ser resumidos como: “não usar IA não é a solução para tudo, mas confiar cegamente nela e se deixar domesticar também não é uma boa”..

Aprendo muito.

Obviamente, a comparação deve ser feita entre o desempenho das duas funções quickSort() e quickSortInPlace()........

Ah.. entendi o que você quis dizer. Pelo visto, você não tinha entendido o que deveria ser comparado.... o algoritmo quick sort não tem dois modos de implementação, quicksort e in-place......

Desde o início, o ponto criticado foi o fato de terem escrito quickSortGPT() e quickSort() no código acima — ambos códigos gerados pelo GPT — com mesclagem de Array embutida, e de terem fornecido isso aos usuários de IA.

Compartilham um resultado mostrando uma diferença que passa de 2x e chega a 3~4x, e depois dizem que talvez não seja nem 2x?

Mesmo agora, quando tento trabalhar com desenvolvedores na faixa dos 40-50 anos, às vezes dá nos nervos por causa de gente que quer desenvolver do jeito de décadas atrás, aff. Pessoalmente, acho que, como no Japão, seria uma sociedade mais saudável se os jovens pudessem entrar em empregos formais em vez de bicos ou trabalho precário, e os idosos ficassem mais em trabalhos diários e bicos. Na Coreia, a distribuição da renda do trabalho está acontecendo em forma de pirâmide invertida, então, com o passar do tempo, só piora esse negócio de puxar a escada para trás.

> As plataformas de enfermagem verificam, por meio de corretores de dados, a situação de crédito das enfermeiras e, quanto mais dívidas elas têm, menor é o salário oferecido.

Como esses dados são fornecidos?

Eu executei diretamente, e há uma tendência de ser um pouco mais lento, mas não parece chegar a 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);  
  
        // Eliminação de recursão de cauda: empurra primeiro a partição maior  
        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();  
  
    // até 2 casas decimais  
    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

....Hã?

Antes da apresentação, houve uma introdução ao patrocínio do Google e do Facebook.

Assim como “depois que a vaca foge é que se conserta o curral” não quer dizer que você não deva se preparar para o futuro,
acredito que “não reinvente a roda” também não quer dizer que você não deva investir tempo para obter insight.
Quando se corta o contexto em que esse tipo de frase surgiu, seu verdadeiro sentido fica distorcido.