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() ทั้งสองตัว........

อา.. ผมเข้าใจแล้วว่าคุณหมายถึงอะไร ดูเหมือนว่าคุณยังไม่เข้าใจว่าควรจะเปรียบเทียบอะไรกับอะไรนี่เอง.... อัลกอริทึม quick sort ไม่ได้มีวิธี implement อยู่สองแบบคือ quicksort กับ in-place นะครับ......

ประเด็นที่ผมวิจารณ์ตั้งแต่แรกคือ การเขียน quickSortGPT() กับ quickSort() ในโค้ดข้างต้นซึ่งมีการรวม Array ไว้ในตัวอยู่แล้ว (ทั้งสองอันเป็นโค้ดที่ 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

....เอ๊ะ?