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.

Acho que o maior produto de exportação dos Estados Unidos é o dólar

Quando preciso repetir várias vezes para resolver o mesmo problema, acabo ultrapassando o tamanho da janela de contexto, e já passei várias vezes pela experiência de a IA simplesmente quebrar nessas horas; fico curioso para saber como outras pessoas lidam com isso. Eu, quando tento várias vezes e ela começa a agir de forma meio burra, troco de modelo e abro uma nova janela de prompt.

Experiência recente: criei minha própria roda bem especial.
Ao fazer o build de um app Nuxt com 1000 páginas, levava 7 minutos,
mas depois de abrir mão de algumas automações e reescrever tudo, consegui reduzir o build para 20 segundos.

OSSU Open Source Society University - Estudando Computer Science por conta própria

Acho que isso foi apresentado no início do GeekNews. Desde então, bastante coisa foi adicionada.

Obrigado pela resposta!

A segunda quickSortInPlace() anexada também é uma implementação lenta.

Execute o código abaixo.

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)];
}

const repeat = 100;
const arrLength = 10000;
const unsortedArray = new Array<number>();
for(let i = 0; i < arrLength; i++)
unsortedArray.push(Math.round(Math.random() * arrLength));

let sorted: Array<number>;

const qb = performance.now();
for(let i = 0; i < repeat; i++)
sorted = quickSort(unsortedArray);
const qe = performance.now();

const rqb = performance.now();
for(let i = 0; i < repeat; i++) {
let copied = [...unsortedArray];
quickSortInPlace(copied);
}
const rqe = performance.now();

console.log(q: ${qe - qb} ::: rq: ${rqe - rqb});

É um texto que transmite uma percepção profunda. Como esperado da a16z.

Normalmente não costumo deixar comentários, mas o motivo de eu ter comentado neste texto em particular é porque concordo bastante com a visão do autor. O importante não é a IA ou os LLMs, e sim que, independentemente do ambiente que vier, eu, como desenvolvedor, esteja preparado.

Como os LLMs, pelas características do código-fonte com que foram treinados, acabam oferecendo principalmente dados próximos da média dos dados online espalhados pelo mundo, (o quicksort em js citado antes prova isso), eu geralmente os uso para perguntar se algo, do ponto de vista de ideias/design, está razoavelmente alinhado com uma perspectiva comum ou destoando dela, ou então para tirar dúvidas sobre temas para os quais era meio difícil encontrar a quem perguntar até então.

Além disso, não vejo muito sentido em continuar a conversa.

Se a opinião desde o início era que o código gerado pela IA pode ter alguns fatores de risco e, por isso, seria bom refiná-lo bem e usá-lo de forma adequada, então talvez bastasse explicar em que ponto o texto do autor distorce ou enviesa esse pensamento. Até no resumo há um trecho com sentido parecido: "ela pode fornecer rapidamente código scaffold/rascunho sem contexto, mas o design completo e o ajuste fino continuam sendo responsabilidade dos desenvolvedores humanos".

Basicamente, dá para ver que é um código que não tem nenhuma consideração pelo custo de criar, operar e mesclar coleções. No caso de C++, já havia propostas/implementações de MoveConstructor cerca de 10 anos atrás, e estar sempre muito atento ao custo relacionado à cópia de memória é o mais básico do básico. O quick sort, por seu mecanismo, é um algoritmo capaz de determinar o índice de todos os valores, e é melhor que cada campo ofereça acesso aleatório.

Mesmo sem otimizações maníacas, só aplicando o que foi dito acima já dá uma diferença de desempenho de mais de 2x em relação ao método do link que você passou.

return [...quickSort(left), ...equal, ...quickSort(right)];

Pense bem sobre este trecho do código.

Os LLMs e a IA vêm evoluindo com o tempo. Há apenas alguns meses, era quase impossível esperar algo como consistência no código do jeito que você pedia, mas agora, dentro desse espaço, se você enviar como arquivos os códigos que a IA gerou a partir das solicitações iniciais de configuração e der a instrução de sempre seguir o estilo de código existente ao escrever código novo, ela acaba produzindo um código bem consistente.

Parece que o modo yolo foi renomeado para modo auto run.