???? 2 गुना से लेकर 3~4 गुना तक का अंतर दिखाने वाला नतीजा शेयर करके फिर यह कहना कि शायद 2 गुना तक भी नहीं है, इसका क्या मतलब है?

अभी भी जब 40-50 की उम्र के developers के साथ काम करने की कोशिश करते हैं, तो कभी-कभी उन लोगों की वजह से बहुत झुंझलाहट होती है जो दशकों पहले के तरीकों से development करना चाहते हैं, हाहा. निजी तौर पर मुझे लगता है कि जापान की तरह युवाओं को part-time या non-regular jobs की बजाय regular jobs में जाने का मौका मिलना चाहिए, और बुज़ुर्गों को ज़्यादातर daily-wage part-time काम में जाना चाहिए, तभी समाज ज़्यादा स्वस्थ होगा. कोरिया में श्रम आय का बंटवारा उल्टे पिरामिड की तरह हो रहा है, इसलिए समय के साथ ladder खींच लेने वाली प्रवृत्ति ही और गंभीर होती जा रही है.

> नर्सिंग प्लेटफ़ॉर्म डेटा ब्रोकरों के ज़रिए नर्सों की क्रेडिट स्थिति जाँचते हैं, और जितना ज़्यादा कर्ज़ होता है, उतना ही कम वेतन ऑफ़र करते हैं

यह डेटा आखिर उपलब्ध कैसे कराया जाता है?

मैंने इसे सीधे चलाकर देखा, थोड़ा धीमा होने की प्रवृत्ति तो है, लेकिन 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

....उम्?

प्रेज़ेंटेशन शुरू होने से पहले Google और Facebook की sponsorship का परिचय दिया गया।

"गाय खोने के बाद ही बाड़ा ठीक करता है" का मतलब यह नहीं है कि भविष्य की तैयारी मत करो,
उसी तरह "पहिया दोबारा मत बनाओ" का मतलब भी यह नहीं है कि अंतर्दृष्टि पाने में समय मत लगाओ।
ऐसी बातें किस संदर्भ में कही गई थीं, उसे आगे-पीछे से काट दें तो उनका असली मतलब विकृत हो जाता है.

मुझे लगता है कि अमेरिका की सबसे बड़ी खासियत डॉलर है।

एक ही समस्या को हल करने के लिए अगर कई बार दोहराना पड़े, तो context window size से बाहर चला जाता है, और ऐसे में मैंने कई बार AI को टूटते हुए देखा है। ऐसे मामलों में दूसरे लोग क्या करते हैं, यह जानने की उत्सुकता है।
मैं कई बार कोशिश करने के बाद जब यह बेवकूफ़ी करने लगता है, तो model बदल देता हूँ और prompt window नई खोल लेता हूँ।

यह हाल का अनुभव है, लेकिन मैंने हाल ही में अपना एक बहुत ही खास पहिया बनाया।
Nuxt में 1000-पेज वाले ऐप को build करने में 7 मिनट लग रहे थे,
लेकिन कुछ automation छोड़कर उसे फिर से लिखने के बाद मैं 20 सेकंड का build हासिल करने में सफल हुआ।

OSSU Open Source Society University - Computer Science स्वयं सीखें

इसे GeekNews के शुरुआती दिनों में पेश किया गया था। इस बीच इसमें काफ़ी कुछ जोड़ा गया है।

जवाब के लिए धन्यवाद!

आपके द्वारा संलग्न दूसरा quickSortInPlace() भी धीमा implementation है।

नीचे दिया गया कोड चलाकर देखिए।

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

यह गहरी अंतर्दृष्टि से भरा लेख है। वाकई, a16z कमाल है।

मैं आमतौर पर ज़्यादा comments नहीं लिखता, लेकिन मैंने इस लेख पर खास तौर पर comment इसलिए किया क्योंकि मैं लेखक की सोच से काफ़ी हद तक सहमत हूँ। मेरा मानना है कि AI या LLM का महत्वपूर्ण होना असली मुद्दा नहीं है; बल्कि किसी भी माहौल में एक developer के तौर पर 'मैं' तैयार रहना चाहिए।

LLM, अपने training source की प्रकृति के कारण, मुख्य रूप से दुनिया भर में फैले online data के औसत के आसपास की जानकारी देता है। (पहले वाला js quicksort इसका प्रमाण है।) इसलिए मैं इसे आमतौर पर इस बात को परखने के लिए इस्तेमाल करता हूँ कि विचारधारा/design के स्तर पर कोई बात सामान्य नज़रिए से कितनी मेल खाती है या उससे कितनी अलग है, या फिर उन बातों पर सवाल पूछने के लिए जिनके बारे में अब तक यह स्पष्ट नहीं था कि किससे पूछा जाए।

इसके अलावा और बातचीत करने का क्या मतलब है, यह मुझे ठीक से समझ नहीं आता।

अगर मूल रूप से राय यह है कि AI द्वारा जनरेट किया गया कोड कुछ हद तक जोखिम वाले तत्व रख सकता है, इसलिए उसे अच्छी तरह परिष्कृत करके उचित तरीके से इस्तेमाल करना चाहिए, तो मुझे लगता है कि लेखक की इस बात में कौन-सी सोच पक्षपाती है, यह समझा देना पर्याप्त होगा। सारांश में भी इसी तरह का आशय है कि "यह बिना संदर्भ के scaffold/ड्राफ्ट कोड जल्दी उपलब्ध करा सकता है, लेकिन पूर्ण डिज़ाइन और tuning मानव डेवलपर की जिम्मेदारी है"।

मूल रूप से, इसे ऐसा कोड कहा जा सकता है जिसमें collection के creation, operation और merge की लागत के प्रति बिल्कुल भी संवेदनशीलता नहीं है। C++ के मामले में, लगभग 10 साल पहले ही MoveConstructor के लिए प्रस्ताव/implementation आ चुके थे, और memory copy से जुड़ी लागत के प्रति हमेशा सतर्क रहना सबसे बुनियादी बातों में से एक है। quick sort अपने mechanism के अनुसार ऐसा algorithm है जो सभी values के index तय कर सकता है, और हर field के लिए random access उपलब्ध कराना बेहतर होता है.

बिना किसी सनकी optimization के भी, सिर्फ ऊपर की बातें लागू कर देने पर आपके दिए गए link वाले तरीके की तुलना में 2 गुना से अधिक performance अंतर आता है।

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

कोड के इस हिस्से को ध्यान से रखकर सोचिए।

LLM और AI समय के साथ लगातार बेहतर हो रहे हैं। सिर्फ़ कुछ महीने पहले तक, जैसा कहा जाता था वैसी code consistency की उम्मीद करना लगभग मुश्किल था, लेकिन अब अगर उसी स्पेस में AI से शुरुआती setup के लिए माँगा गया कोड फ़ाइलों के रूप में अपलोड कर दिया जाए, और नया कोड लिखते समय हमेशा मौजूदा code style का पालन करने का निर्देश देकर इस्तेमाल किया जाए, तो यह काफ़ी हद तक consistent कोड लिख देता है।

कहा जा रहा है कि yolo mode को auto run mode में बदल दिया गया है।