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.

Eu estava experimentando várias coisas enquanto tentava encontrar uma direção, e achei interessante essa abordagem centrada nas pessoas, mais do que nas ações. Seria algo como um modelo a seguir? Foi uma leitura prazerosa, obrigado.

Parece que o link não está funcionando direito, então estou tentando de novo. https://chatgpt.com/canvas/shared/68341217ae788191b66a523c948b1a8e

Olá. Por curiosidade, tentei dizer: "Vou colocar isso no front-end web, então implemente um algoritmo de quicksort em js". Mas, pelo que vejo, está difícil entender exatamente qual é o problema. Se puderem me explicar, isso me ajudaria muito. Agradeço desde já. https://chatgpt.com/share/68340f9b-b684-8002-8dd5-495d477065cd

Parece ser um projeto em Common Lisp. Então é por isso que a combinação ocicl+make funciona. Acho que seria mais fácil de manter se jogasse isso para o Vibe AI e pedisse para ele simplesmente fazer em typescript+deno.

Acho que você não entendeu bem por que eu mencionei a área de atuação do autor e o que significa ter o próprio domínio de conhecimento.
Delegar todas as decisões à IA sem pensar por conta própria também me parece tolice,
mas também não entendo muito bem as pessoas que estão no extremo oposto.

Por fim, o que eu queria perguntar é: superscv, como você acha que seria bom usar LLMs na programação?

A Coreia também provavelmente vai acabar tendo que estender de forma contínua (..) a idade de aposentadoria por causa do problema das pensões...
O ponto de virada deve ser o momento em que, de tanto aumentar e aumentar, ela acabe ultrapassando a expectativa de vida.
(Acho que dizem que a Rússia já ficou assim.. )

Resumo,

Autor: os próprios desenvolvedores precisam desenvolver e preservar suas capacidades. Além disso, a IA nem funciona tão bem assim.

crawler: Hã? Para mim funciona bem?

superscv: Tem muitos problemas...

crawler: Tem que saber ajustar e usar

superscv: Acho que já se afastou demais da mensagem que o autor queria transmitir desde o começo..