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?

Sunumdan önce Google ve Facebook sponsorluğu tanıtıldı.

"Atı alan Üsküdar'ı geçti" sözü geleceğe hazırlanmamak gerektiği anlamına gelmediği gibi,
"Tekerleği yeniden icat etme" sözünün de içgörü kazanmak için zaman harcamamak gerektiği anlamına gelmediğini düşünüyorum.
Bu tür sözlerin hangi durumda söylendiğini bağlamından koparırsanız, asıl anlamı çarpıtılmış olur.

Bence ABD'nin en büyük ihraç ürünü dolar.

Aynı sorunu çözmek için aynı şeyi defalarca tekrarlayınca bağlam penceresi boyutunu aşıyorum ve böyle durumlarda yapay zekanın bozulduğunu birkaç kez yaşadım; bu durumda başkaları ne yapıyor merak ediyorum.
Ben birkaç kez denedikten sonra aptallaşmaya başlarsa modeli değiştirip yeni bir prompt penceresi açıyorum.

Yakın zamanda yaşadığım bir deneyimdi; kısa süre önce kendime özgü çok özel bir tekerlek yeniden icat ettim.
Nuxt ile 1000 sayfalık bir uygulamayı build etmek 7 dakika sürüyordu,
birkaç otomasyonu bırakıp her şeyi yeniden yazınca bunu 20 saniyelik bir build süresine indirmeyi başardım.

OSSU Open Source Society University - Computer Science kendi kendine öğrenme

Sanırım GeekNews’in ilk dönemlerinde tanıtılmıştı. Bu süre içinde epey fazla şey eklendi.

Cevabınız için teşekkürler!

Eklediğiniz ikinci quickSortInPlace() de yavaş bir implementasyon.

Aşağıdaki kodu çalıştırın.

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

Derin içgörüler hissettiren bir yazı. Yine a16z kalitesi.

Normalde pek yorum yazmam ama özellikle bu yazıya yorum bırakmamın nedeni, yazarın düşüncelerine oldukça katılıyor olmam. Önemli olan AI ya da LLM’ler değil; hangi ortam gelirse gelsin, geliştirici olarak "ben"in hazırlıklı olması gerektiğini düşünüyorum.

LLM’ler, eğitildikleri kaynakların doğası gereği, çoğunlukla dünya geneline yayılmış çevrimiçi verilerin ortalamasına yakın çıktılar sunuyor. (Az önceki js quicksort örneği bunu kanıtlıyor.) Bu yüzden genelde onları, fikir/tasarım açısından genel bakışla ne kadar örtüştüğünü ya da nerede ayrıştığını görmek ve şimdiye kadar kime soracağımı bilemediğim şeyleri sormak için çok kullanıyorum.

Ek olarak daha fazla konuşmanın ne anlamı olduğunu pek bilmiyorum.

En başta, yapay zekanın ürettiği kodun bazı risk unsurları taşıyabileceği için onu iyi süzüp uygun şekilde kullanmanın iyi olacağı yönünde bir görüşse, yazarın yazısında hangi düşüncenin yanlı olduğunu açıklamanız yeterli olur diye düşünüyorum. Özet metinde de "bağlamdan yoksun scaffold/taslak kodu hızlıca sağlayabilir, ancak tam bir tasarım ve ince ayar insan geliştiricinin sorumluluğudur" şeklinde benzer bir anlam taşıyan içerik var.

Temelde koleksiyonların oluşturulması, işletilmesi ve birleştirilmesinin yüküne hiçbir empati göstermeyen bir kod olduğu söylenebilir. C++ açısından bakarsak, yaklaşık 10 yıl önce bile MoveConstructor için öneriler/uygulamalar ortaya çıkmıştı ve bellek kopyalamayla ilgili yük konusunda her zaman son derece hassas olmak en temel ilkelerden biridir. quick sort, mekanizması gereği tüm değerlerin index'ini belirleyebilen bir algoritmadır ve her alan için random access sağlanması daha iyidir.

Maniak düzeyde optimizasyon yapmadan bile yalnızca yukarıdaki noktaları uygularsanız, paylaştığınız bağlantıdaki yöntemle arasında 2 kattan fazla performans farkı oluşur.

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

Kodun bu kısmını iyice durup düşünün.