Duolingo, sözleşmeli çalışanlar yerine yapay zekayı devreye aldığını duyurdu

Kare tekerleği yuvarlak yapmaya çalışınca, patronun "tekerleği yeniden icat etmeyin" sözü aklıma geliyor. Bu "tekerleği yeniden icat etme" hayaleti hâlâ etrafta çok.

Bunu bir kenara bıraksak bile, insan müdahalesini hiç hesaba katmaması fazla kesin bir yaklaşım gibi görünüyor,
Basit sayısal ya da mesaj düzeltmelerinde LLM yerine insanın devreye girmesi daha verimli olur.

temperature seçeneğini 0 olarak ayarlarsanız, aynı girdi için aynı çıktının garanti edildiğini biliyorum.

“quickSort, quickSort’larla olur” sözü karşısında insanın ense kökü tutuluyor.

LLM'ler aynı girdiye karşı aynı çıktıyı garanti etmiyor; böyle bir yaklaşımda konfigürasyon yönetiminin gerçekten işe yarayabildiği mi söyleniyor...
Yoksa ben hâlâ onu fazla tek boyutlu mu kullanıyorum

Yazıyı okurken lütfen bağlamı mutlaka kontrol edin.

Şu anda kendi kodlama becerimle övünmüyorum. Şu anda örnek olarak kullanılan quickSort() gibi vasat kodların GPT tarafından yüksek öncelikle üretiliyor olmasını eleştiriyorum.

GPT’de birkaç kez arama yaptığınızda, yalnızca quickSort() fonksiyonu sonucunu veren durumların çok olduğunu görürsünüz; ayrıca quickSort() sadece bir örnektir. İş amaçlı olarak GPT’den kod istediğinizde kalite seviyesi çok düşük kodlar sıkça üretiliyor (ücretli kullanıcı deneyimime göre). Geliştiricinin bunu ayırt edebilme yeteneği eksikse, projenin bozulacak bir yöne gitme olasılığının yüksek olduğu yönündeki asıl yazı yazarının görüşüne katıldığım için bu bağlama kadar geldik.

Şimdiden çevremde bu tür vasat kodlarla sıvanmış projelerin sayısı durmadan artıyor.

YOLO modu...

Her kareye bir blok seçilebilecek şekilde yerleştirip sadece görünüşünü CSS ile mi süslemişler? Yine de gerçekten etkileyici.

GPT’nin yanıtında hem quickSort hem de quicSortInPlace var ve yorumlarda [...,quickSort(left), ...equal, ...quickSort(right)] kısmına dikkat çekildiği için, quickSortun quickSortlarla, quickSortInPlace’in de quickSortInPlacelerle karşılaştırılması gerektiğini anlamıştım ama öyle değilmiş sanırım.

Yorumdaki iddia doğruysa, Google fiilen suç teşkil eden eylemlere yardım etmiş olmuyor mu?

Yazı eğlenceli ama, çok fazla yazının “yapay zekayı kullanmamak her derde deva değil ama öte yandan ona körü körüne güvenip ona göre şekillenmek de iyi değil” diye özetlenebiliyor olması biraz yorucu geliyor..

Çok şey öğreniyorum

Elbette karşılaştırma, quickSort() ve quickSortInPlace() fonksiyonlarının performans karşılaştırması olmalı........

Ah.. ne demek istediğinizi anladım. Neyi neyle karşılaştırmak gerektiğini anlayamamışsınız.... quick sort algoritmasının quicksort ve in-place olmak üzere iki farklı uygulama biçimi yoktur......

Benim asıl sorun ettiğim şey, en baştan Array birleştirme yerleşik olan, yukarıdaki kodda yer alan quickSortGPT() ve quickSort()'u (ikisi de GPT'nin ürettiği koddur) yazıp bunu yapay zeka kullanıcılarına sunmalarıydı.

???? Sonuçlarda 2 katı aşan, hatta 3-4 kata varan farkların olduğu bir çıktıyı paylaşıp sonra da bunun 2 kata kadar bile olmadığını söylemek ne demek?

Şimdi bile 40-50 yaşlarındaki geliştiricilerle birlikte çalışmaya kalkınca, onlarca yıl önceki yöntemlerle geliştirme yapmaya çalışanlar yüzünden bazen insanın sabrı taşıyor, haha. Bana kalırsa Japonya’daki gibi gençlerin part-time ya da güvencesiz işlerde değil, kadrolu işlere girebildiği; yaşlıların ise daha çok günlük işler ve part-time işlere yöneldiği bir düzen daha sağlıklı bir toplum yaratır. Kore’de emek gelirinin dağılımı ters piramit gibi olduğu için zaman geçtikçe sadece merdiveni arkadan çekme daha da şiddetleniyor.

> Hemşirelik platformları, veri brokerları aracılığıyla hemşirelerin kredi durumunu kontrol ediyor ve borcu ne kadar fazlaysa o kadar düşük ücret teklif ediyor.

Bu veri nasıl sağlanıyor acaba?

Doğrudan çalıştırıp denedim; biraz daha yavaş olma eğilimi var ama 2 kat kadar değil gibi görünüyor.

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: önce daha büyük partition'ı stack'e ekle  
        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();  
  
    // Virgülden sonra 2 basamağa kadar  
    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

....Ha?