Duolingo、契約社員の代わりにAI導入を発表

四角い車輪を丸くしようとしたら、「車輪を再発明するな」という社長の言葉を思い出しました。車輪再発明亡霊は今でも周りにたくさんいますね。

それはさておき、そもそも人間の介入を考慮していない点があまりにも断定的ですね。
簡単な数値やメッセージの修正であれば、LLMより人間が介入したほうが効率的でしょう。

temperature オプションを 0 に設定すると、同じ入力に対して同じ出力が保証されると理解しています

「quickSortはquickSort同士で」という言葉に、思わずうなじを押さえてしまいます。

LLMは同じ入力に対して同じ出力を保証しないのに、ああいう形での構成管理が通用するということなんでしょうか……
まだ自分はあまりにも一次元的にしか使えていないのかな

記事を読む際は、必ず文脈を確認してください。

今ここで私が自分のコーディング能力を自慢しているわけではありません。いま例として使われている quickSort() のようなお粗末なコードが、GPTで優先度高く出力されている点を指摘しているのです。

GPTで何度か検索してみると、quickSort() 関数の結果だけを単体で提示するケースが多く見られますし、また、quickSort() はあくまで一つの例にすぎません。実務目的でGPTにコードを依頼すると、品質の低すぎるコードが数多く出力されます（有料ユーザーとしての体験です）。そして開発者自身にそれを見分ける能力が欠けている状態では、プロジェクトが壊れていく方向に進む可能性が高い、という本文著者の意見に共感して、私は現在の文脈に至りました。

すでに私の周囲では、このような粗悪なコードが塗り込まれたプロジェクトが増え続けています.

YOLOモード…

各マスにブロックを選べるように配置して、見た目だけをCSSで整えたってことですか？ すごいですね

GPT の応答には quickSort と quicSortInPlace の両方があり、コメントで [...,quickSort(left), ...equal, ...quickSort(right)] の部分を指摘されていたので、quickSort は quickSort 同士、quickSortInPlace は quickSortInPlace 同士で比較すべきだと理解していたのですが、そうではないようですね。

コメントの主張が事実なら、Googleは事実上犯罪行為に加担していることになりませんか？

本文は面白いのですが、あまりにも多くの文章が「AIを使わないのがすべてではないし、だからといって無条件に信頼して慣らされるのもよくない」と要約できてしまう気がして、少し食傷気味ですね……

とても勉強になります

当然、比較は quickSort() と quickSortInPlace() の2つの関数の性能比較であるべきです........

ああ……何を言いたいのか理解しました。何と何を比較すべきかを理解されていなかったのですね……。quick sort アルゴリズムに quicksort と in-place という2つの実装方式があるわけではありません……。

そもそも、Array のマージが組み込まれた上記コード内の quickSortGPT()、quickSort()（どちらも GPT が出力したコードです）を作成して AI ユーザーに提供している点を問題視していたのです。

???? 結果が2倍を超えて3〜4倍も差があるものとして共有しておきながら、2倍まではいかない気がするというのはどういうこと？

今でも40〜50代の開発者と一緒に働こうとすると、何十年も前のやり方で開発しようとする人たちのせいでイライラすることがあるのに、これはやばい。個人的には日本のように若者がバイトや非正規ではなく正規職に就けて、高齢者は日雇いバイト中心で入るほうが、より健全な社会になると思う。韓国は逆ピラミッド型で労働所得を分配しているから、時間がたつほどはしご外しがひどくなる一方だと思う。

看護プラットフォームはデータブローカーを通じて看護師の信用状況を確認し、負債が多いほどより低い賃金を提示する

このデータはどのように提供されるのでしょうか？

実際に実行してみましたが、やや遅い傾向はあるものの、2倍まではいかないようです。

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();  
  
    // 小数点以下2桁まで  
    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

....え?