चौकोर पहियों को गोल बनाने की कोशिश की तो बॉस की वह बात याद आ गई कि पहिया फिर से मत बनाओ। "पहिया-फिर-से-मत-बनाओ" वाला भूत आज भी आसपास बहुत है।

इसे एक तरफ भी रख दें, तो यह मान लेना ही बहुत ज़्यादा निर्णायक लगता है कि मानवीय हस्तक्षेप को बिल्कुल भी ध्यान में नहीं रखा जाएगा,
सरल संख्याएँ या संदेश बदलने जैसे मामलों में LLM की तुलना में इंसान का हस्तक्षेप ज़्यादा कुशल हो सकता है।

मेरी समझ के अनुसार, temperature विकल्प को 0 पर सेट करने से एक ही इनपुट के लिए एक ही आउटपुट की गारंटी मिलती है।

"quickSort तो quickSort के साथ ही" जैसी बात सुनकर मेरा माथा ठनक जाता है।

LLM एक ही input के लिए एक जैसा output guarantee नहीं करता, तो क्या इस तरह का configuration management सच में काम करता है...
क्या मैं अभी भी इसे बहुत ही एक-आयामी तरीके से इस्तेमाल कर रहा हूँ

कृपया लिखे गए लेख को पढ़ते समय संदर्भ ज़रूर देखें।

मैं अभी अपनी coding skill का बखान नहीं कर रहा हूँ। मैं यह इंगित कर रहा हूँ कि quickSort() जैसे घटिया code, जो अभी उदाहरण के रूप में इस्तेमाल हो रहे हैं, GPT में ऊँची प्राथमिकता के साथ output हो रहे हैं.

अगर आप GPT search कई बार करके देखें, तो कई मामलों में यह अकेले quickSort() function का result दे देता है, और फिर से कहूँ तो quickSort() सिर्फ एक उदाहरण है। काम के उद्देश्य से GPT से code माँगने पर बहुत घटिया quality का code अक्सर output होता है (यह एक paid user का अनुभव है)। अगर developer खुद ऐसी चीज़ों में फर्क करने की क्षमता के बिना हो, तो परियोजना के बिगड़ने की दिशा में जाने की संभावना बहुत अधिक है — इस मुख्य लेख के लेखक की इस राय से सहमत होते हुए मैं इस संदर्भ तक पहुँचा हूँ।

मेरे आसपास भी इस तरह के घटिया code से पुते हुए projects लगातार बढ़ते जा रहे हैं।

YOLO मोड...

क्या इसमें हर खाने में ब्लॉक चुनने की सुविधा रखकर सिर्फ CSS से उसका बाहरी रूप सजाया गया है? वाकई कमाल है।

GPT के जवाब में quickSort और quicSortInPlace दोनों हैं, और टिप्पणी में '[...quickSort(left), ...equal, ...quickSort(right)]' वाले हिस्से की ओर इशारा किया गया था, इसलिए मैंने समझा था कि quickSort की तुलना quickSort से, और quickSortInPlace की तुलना quickSortInPlace से करनी चाहिए, लेकिन शायद ऐसा नहीं है।

अगर टिप्पणी का दावा सही है, तो क्या Google वास्तव में आपराधिक गतिविधि में मदद नहीं कर रहा है?

लेख दिलचस्प है, लेकिन अब बहुत-से लेख ऐसे लगते हैं जिनका सार बस इतना है कि “AI का इस्तेमाल न करना भी हर समस्या का हल नहीं है, लेकिन उस पर आँख मूंदकर भरोसा करना और उसके मुताबिक ढल जाना भी अच्छा नहीं है”, इसलिए थोड़ा थकान-सा महसूस होता है..

बहुत कुछ सीखने को मिल रहा है

बिल्कुल, तुलना quickSort() और quickSortInPlace() इन दो फ़ंक्शनों के प्रदर्शन की होनी चाहिए........

आह.. अब समझ गया कि आपका मतलब क्या है। लगता है आप यह समझ नहीं पाए कि किस चीज़ की किससे तुलना करनी चाहिए.... quick sort algorithm की quicksort और in-place जैसी दो implementation methods नहीं होतीं......

मैंने शुरू से ही इस बात को समस्या बताया था कि array merge built-in होने के बावजूद, ऊपर दिए गए कोड में quickSortGPT() और quickSort() (दोनों ही GPT द्वारा जनरेट किया गया कोड हैं) लिखकर AI users को दिए जा रहे थे.

???? 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 का परिचय दिया गया।