ก่อนการบรรยาย มีการแนะนำผู้สนับสนุนจาก Google และ Facebook

ผมมองว่า เช่นเดียวกับที่คำว่า "วัวหายแล้วค่อยล้อมคอก" ไม่ได้หมายความว่าไม่ต้องเตรียมพร้อมสำหรับอนาคต
คำว่า "อย่าประดิษฐ์ล้อขึ้นมาใหม่" ก็ไม่ได้หมายความว่าไม่ควรลงทุนเวลาเพื่อให้ได้มาซึ่งความเข้าใจลึกซึ้ง
หากตัดคำพูดเหล่านี้ออกจากบริบทที่มันถูกพูดขึ้นมา ความหมายที่แท้จริงก็จะบิดเบือนไป

ผมคิดว่าสินค้าขึ้นชื่อที่สุดของสหรัฐฯ คือดอลลาร์

พอทำซ้ำหลายรอบเพื่อแก้ปัญหาเดิม ก็จะหลุดเกินขนาดของ context window และผมก็เจอหลายครั้งว่า AI เหมือนพังไปเลย เลยอยากรู้ว่าในกรณีแบบนี้คนอื่นจัดการกันอย่างไร
ส่วนผมถ้าลองหลายครั้งแล้วยังทำตัวเหมือนโง่ ๆ ก็จะเปลี่ยนโมเดลแล้วเปิดหน้าต่างพรอมป์ต์ใหม่

นี่เป็นประสบการณ์ล่าสุดของผมเอง แต่เมื่อไม่นานมานี้ผมได้สร้างวงล้อที่พิเศษมากของตัวเองขึ้นมาอันหนึ่ง
การบิลด์แอปบน Nuxt ที่มี 1000 หน้าเคยใช้เวลา 7 นาที
แต่หลังจากยอมละทิ้งระบบอัตโนมัติบางอย่างแล้วเขียนขึ้นใหม่ ผลลัพธ์คือบิลด์ได้สำเร็จใน 20 วินาที

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

ปกติผมไม่ค่อยเขียนคอมเมนต์เท่าไร แต่เหตุผลที่คอมเมนต์ในบทความนี้เป็นพิเศษก็เพราะผมเห็นด้วยกับความคิดของผู้เขียนอย่างมาก ผมคิดว่าสิ่งสำคัญไม่ใช่ AI หรือ LLM แต่ไม่ว่าสภาพแวดล้อมแบบไหนจะมาถึง ตัว "ผม" ในฐานะนักพัฒนาต้องพร้อมอยู่เสมอ

ด้วยลักษณะของซอร์สที่ใช้ในการฝึก LLM จึงมักให้ข้อมูลที่อยู่ใกล้กับค่าเฉลี่ยของข้อมูลออนไลน์ที่กระจายอยู่ทั่วโลกเป็นหลัก (ก่อนหน้านี้กรณี js quicksort ก็พิสูจน์เรื่องนี้ได้) เพราะฉะนั้นโดยทั่วไปผมจึงใช้มันเพื่อถามว่าในด้านแนวคิด/การออกแบบ สิ่งนั้นสอดคล้องหรือคลาดไปจากมุมมองทั่วไปมากน้อยแค่ไหน หรือใช้ถามเรื่องที่ก่อนหน้านี้ไม่ค่อยแน่ใจว่าจะไปถามที่ไหนดี

ผมไม่ค่อยแน่ใจว่าการคุยต่อไปอีกจะมีความหมายอย่างไร

ตั้งแต่แรกแล้ว ถ้าความเห็นคือโค้ดที่ AI สร้างให้ในตอนแรกอาจมีความเสี่ยงอยู่บ้าง จึงควรขัดเกลาให้ดีและนำไปใช้อย่างเหมาะสม ก็คงพอจะอธิบายได้ว่าบทความของผู้เขียนมีแนวคิดส่วนไหนที่เอนเอียงไปบ้าง เพราะแม้แต่ในบทสรุปก็มีข้อความในทำนองเดียวกันว่า "สามารถสร้าง scaffold/โค้ดร่างที่ไร้บริบทได้อย่างรวดเร็ว แต่การออกแบบและการจูนให้สมบูรณ์ยังเป็นหน้าที่ของนักพัฒนามนุษย์" อยู่เหมือนกัน

โดยพื้นฐานแล้ว นี่ถือเป็นโค้ดที่ไม่เข้าใจภาระของการสร้าง การใช้งาน และการรวม collection เลยแม้แต่น้อย ในกรณีของ C++ นั้น ตั้งแต่ราว 10 ปีก่อนก็มีทั้งข้อเสนอ/การนำ MoveConstructor ไปใช้แล้ว และการระแวดระวังภาระที่เกี่ยวข้องกับการคัดลอกหน่วยความจำก็เป็นพื้นฐานอย่างยิ่งอยู่เสมอ quick sort ตามกลไกของมันเป็นอัลกอริทึมที่สามารถกำหนด index ของค่าทั้งหมดได้ และแต่ละฟิลด์ก็ควรรองรับ random access

ต่อให้ไม่ทำ optimization แบบสุดโต่ง แค่นำสิ่งที่กล่าวมาข้างต้นไปใช้ ก็ได้ประสิทธิภาพต่างจากวิธีในลิงก์ที่คุณให้มาเกิน 2 เท่าแล้ว

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

ลองวางโค้ดส่วนนี้ไว้ แล้วคิดดูให้ดี ๆ

LLM และ AI พัฒนาขึ้นเรื่อย ๆ ตามกาลเวลา เมื่อไม่กี่เดือนก่อน เรื่องอย่างความสม่ำเสมอของโค้ดยังแทบคาดหวังไม่ได้เลย แต่ตอนนี้ถ้าให้ AI อัปโหลดโค้ดที่ขอให้ตั้งค่าเริ่มต้นไว้ในสเปซนั้นเป็นไฟล์ และเมื่อเขียนโค้ดใหม่ก็กำชับให้ยึดตามสไตล์ของโค้ดเดิมเสมอ ก็จะได้โค้ดที่มีความสม่ำเสมอค่อนข้างดีทีเดียว

ดูเหมือนว่า yolo mode ถูกเปลี่ยนเป็น auto run mode แล้วครับ

ฉันกำลังลองทำหลาย ๆ อย่างไปพร้อมกับค่อย ๆ หาทิศทางอยู่พอดี แต่แนวทางที่เน้นผู้คนมากกว่าการลงมือทำก็น่าสนใจดีนะครับ คล้าย ๆ กับการมีแบบอย่างหรือเปล่า? อ่านได้เพลินมาก ขอบคุณครับ

ดูเหมือนว่าลิงก์จะทำงานได้ไม่ค่อยดี เลยลองใหม่อีกครั้งครับ https://chatgpt.com/canvas/shared/68341217ae788191b66a523c948b1a8e

สวัสดีครับ/ค่ะ ด้วยความสงสัยเลยลองพิมพ์ว่า "จะเอาไปใส่ในเว็บฟรอนต์ ช่วยเขียนอัลกอริทึม quicksort เป็น js ให้หน่อย" แต่สำหรับผม/ฉันแล้วค่อนข้างดูออกยากว่าอะไรคือปัญหา ถ้าช่วยบอกให้หน่อยจะเป็นประโยชน์มากเลยครับ/ค่ะ ขอบคุณล่วงหน้าครับ/ค่ะ https://chatgpt.com/share/68340f9b-b684-8002-8dd5-495d477065cd

เป็นโปรเจกต์ Common Lisp สินะ เพราะอย่างนั้นถึงใช้ชุด ocicl+make ได้สินะ ให้ Vibe AI จัดการอันนี้แล้วสั่งให้ทำเป็น typescript+deno ไปเลยน่าจะดูแลง่ายกว่านะ

ดูเหมือนว่าคุณจะยังไม่ค่อยเข้าใจว่าทำไมผมถึงพูดถึงสาขาของผู้เขียน และคำว่าโดเมนของตัวเองหมายถึงอะไร
การมอบหมายการตัดสินใจทุกอย่างให้ AI โดยไม่มีความคิดของตัวเองก็ดูเป็นเรื่องไม่ฉลาดเหมือนกัน
แต่คนที่อยู่สุดโต่งในอีกด้านหนึ่ง ผมก็ไม่ค่อยเข้าใจเหมือนกัน

สุดท้ายนี้มีเรื่องที่อยากถามคือ คุณ superscv คิดว่าควรใช้ LLM กับการเขียนโค้ดอย่างไรถึงจะดี