การเขียนโค้ดและการจับคู่การเขียนโปรแกรมด้วย AI

กำไร:

• ความสามารถในการเขียนฟังก์ชัน คลาส และโมดูลไปยัง AI พร้อมคำจำกัดความอินพุต-เอาท์พุตและข้อจำกัดที่ชัดเจน
• ความสามารถในการใช้ AI เป็นคู่การเขียนโปรแกรมและความคืบหน้าทีละขั้นตอนในส่วนเล็กๆ ที่ตรวจสอบได้
• ความสามารถในการตรวจจับข้อผิดพลาดของลอจิกและ Edge case โดยการคอมไพล์โค้ดที่สร้างโดย AI และรันด้วยตัวอย่างเล็กๆ น้อยๆ

การเขียนโปรแกรมคู่เกิดขึ้นเมื่อนักพัฒนาสองคนทำงานในปัญหาเดียวกัน โดยคนหนึ่งเขียนและอีกคนแก้ไข การเขียนโค้ดด้วย AI เป็นเวอร์ชันดิจิทัลของความสัมพันธ์นี้ คุณเป็นผู้กำหนดทิศทาง ข้อจำกัด และเกณฑ์การยอมรับ AI สร้างร่างด่วน คุณตรวจสอบแต่ละขั้นตอนโดยการรวบรวมและทดสอบ กับดักที่ใหญ่ที่สุดที่นี่คือบอก AI “เขียนแอปพลิเคชันนี้ให้ฉันตั้งแต่ต้นจนจบ” และยอมรับบล็อก 200 บรรทัดแบบสุ่มสี่สุ่มห้า การเขียนโปรแกรมคู่ที่ดีต้องดำเนินการในขั้นตอนเล็กๆ แต่ละขั้นตอนควรเข้าใจได้ ทดสอบได้ และย้อนกลับได้

ในหน่วยการเรียนรู้นี้ คุณจะได้เรียนรู้วิธีการพิมพ์ฟังก์ชัน คลาส และโมดูลที่มีสัญญาอินพุต-เอาท์พุตที่ชัดเจน วิธีแนะนำ AI ทีละขั้นตอน และเราจะดูวิธีตรวจจับข้อผิดพลาดของลอจิกและ Edge case ด้วยการรันโค้ดที่สร้างขึ้นพร้อมตัวอย่างเล็กๆ น้อยๆ เป้าหมายไม่ใช่ความเร็ว แต่เป็นความเร็วที่ได้รับการยืนยัน

แนวคิด: สัญญาอินพุต-เอาท์พุต: คำจำกัดความที่ชัดเจนของอินพุตที่ฟังก์ชันใช้ และลักษณะการทำงานของเอาต์พุตและข้อผิดพลาดที่สัญญาไว้ Edge case: อินพุตที่ไม่ธรรมดาแต่สามารถเกิดขึ้นได้จริง (ว่างเปล่า, ศูนย์, ลบ, ใหญ่มาก, null) การพัฒนาแบบค่อยเป็นค่อยไป: ดำเนินการกับชิ้นงานขนาดเล็กและตรวจสอบแต่ละขั้นตอน

พิมพ์รหัสพร้อมสัญญาสุทธิ

พื้นฐานของรหัสคุณภาพคือการกำหนด "สิ่งที่คุณต้องการ" ให้แน่ชัดก่อนเริ่มงาน เมื่อเขียนฟังก์ชันลงใน AI ควรให้ห้าสิ่งต่อไปนี้: ภาษาและเวอร์ชัน ประเภทอินพุตและความหมาย ผลลัพธ์ เงื่อนไขข้อผิดพลาด และข้อจำกัด (ประสิทธิภาพ การห้ามไลบรารีภายนอก สไตล์) ซึ่งจะทำให้ AI คาดเดาไม่ได้

1. เขียนสัญญา. อินพุต เอาท์พุต ข้อผิดพลาด ข้อจำกัด
2. ขอหน่วยเล็กๆครับ. ฟังก์ชั่นที่มีความรับผิดชอบเดียว มันไม่ใช่โมดูลขนาดใหญ่
3. ขอบล็อกทดสอบ เพิ่มการรัน/การทดสอบตัวอย่าง 2-3 รายการถัดจากโค้ด
4. คอมไพล์และรัน ลองใช้เคส Edge ตรวจสอบเอาต์พุตด้วยตา
5. ไปที่ขั้นตอนถัดไป เมื่อชิ้นส่วนได้รับการยืนยันแล้ว ให้สร้างต่อ

พรอมต์ฟังก์ชันตามสัญญา: "เขียนฟังก์ชันสำหรับ TypeScript 5 วัตถุประสงค์: คำนวณจำนวนรวมของสินค้าในตะกร้าสินค้า อินพุต: { ราคา: หมายเลข, ปริมาณ: หมายเลข }[] อาร์เรย์ เอาต์พุต: จำนวน (รวม) กฎ: ข้อผิดพลาด Throw หากปริมาณหรือราคาเป็นลบ ส่งคืนค่า 0 สำหรับอาร์เรย์ว่าง จำนวนการปัดเศษเป็นทศนิยม 2 ตำแหน่งสำหรับข้อผิดพลาดทศนิยม อย่าใช้ไลบรารีภายนอก เพิ่มกรณีทดสอบ 5 กรณีด้านล่างฟังก์ชัน (ปกติ ว่างเปล่า ปริมาณติดลบ ราคาทศนิยม รายการเดียว)”

นำทาง AI เป็นคู่

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

ข้อความแจ้งความคืบหน้าแบบเพิ่มหน่วย: "เราจะเขียนโปรแกรมอ่านที่อ่านไฟล์ CSV และแปลงบรรทัดเป็นออบเจ็กต์ ไปทีละขั้นตอน เพื่อไปยังขั้นตอนถัดไปโดยไม่ต้องยืนยันแต่ละขั้นตอน ขั้นตอนที่ 1: เพียงเขียนโครงกระดูกที่แยกไฟล์ออกเป็นบรรทัดและแยกบรรทัดส่วนหัว อย่าเพิ่งเพิ่มการแปลงประเภทหรือการจัดการข้อผิดพลาด โปรดอธิบายให้สั้นกระชับ"

อธิบายและปรับแก้โค้ดพร้อมท์: "อธิบายฟังก์ชันที่คุณเพิ่งเขียน ไม่ใช่ทีละบรรทัด แต่ต้องตัดสินใจทีละบรรทัด: การตัดสินใจออกแบบใดที่คุณทำและทำไม กรณี Edge ใดที่คุณจัดการ และอย่างไร กรณีใดที่คุณจงใจแยกออก เขียนรายการสมมติฐาน 3 ข้อในโค้ดที่ฉันไม่ควรพลาด"

เคล็ดลับ: อย่ายอมรับโค้ดที่สร้างโดย AI โดยไม่เข้าใจ “อธิบายเรื่องนี้ให้ฉันฟังหน่อยสิ คุณสันนิษฐานอะไรไว้” คำถามทั้งสองเผยให้เห็นข้อผิดพลาดที่ซ่อนอยู่และช่วยให้คุณสามารถปกป้องโค้ดนั้นได้ เนื่องจากโค้ดยังคงเป็นความรับผิดชอบของคุณ การใส่โค้ดที่คุณไม่เข้าใจลงในการผลิตก็เหมือนกับการส่งสัญญาโดยไม่ต้องลงนาม

พรอมต์ที่อ่อนแอ / พรอมต์ที่แข็งแกร่ง

อ่อนแอ: "เขียนฟังก์ชันการเรียงลำดับ" (ผลลัพธ์: ภาษาใด สิ่งที่กำลังเรียงลำดับ มีเสถียรภาพหรือไม่ ข้อจำกัดด้านประสิทธิภาพคืออะไร โค้ดที่คลุมเครือและอาจไม่ตรงกับข้อกำหนด) แข็งแกร่ง: "สำหรับ Java 17 ให้เขียนวิธีการที่เรียงลำดับวัตถุ List<Employee> ก่อนตามแผนก (ตัวอักษร) จากนั้นตามเงินเดือน (มากไปน้อย) อย่าแทนที่รายการเดิม คืนรายการใหม่ ให้แผนก null อยู่ลำดับสุดท้าย อธิบายความซับซ้อน ของวิธีการในบรรทัดความคิดเห็น ระบุเพิ่มบล็อกทดสอบหลักด้วย 4 ตัวอย่าง"

พรอมต์อันทรงพลัง; รวมถึงเกณฑ์การเรียงลำดับ (สองระดับ) กฎผลข้างเคียง (แทนที่ต้นฉบับ) ลักษณะการทำงานที่เป็นโมฆะ และความคาดหวังในการทดสอบ หากไม่มีรายละเอียดเหล่านี้ AI จะสร้างวิธีแก้ปัญหาที่น่าเชื่อถือแต่ไม่ถูกต้อง ตัวอย่างเช่น อาจทำให้รายการเดิมเสียหาย และสิ่งนี้จะนำไปสู่ข้อผิดพลาดแบบเงียบ ๆ ที่อื่น

การตรวจสอบความถูกต้องด้วย Edge Cases และตัวอย่างขนาดเล็ก

รหัสที่ทำงานในสถานการณ์ที่มีความสุขไม่ใช่รหัสที่ถูกต้อง บังคับแต่ละฟังก์ชันที่ผลิตอย่างมีสติ:

ประเภทเคสขอบ

อินพุตตัวอย่าง

พฤติกรรมที่คาดหวัง

อินพุตว่างเปล่า

อาร์เรย์/สตริงว่าง

ไม่ใช่ข้อผิดพลาด ผลลัพธ์ว่างเปล่าแบบลอจิคัล

ศูนย์/ลบ

0, -1

กำหนดและประพฤติปฏิบัติให้ถูกต้อง

คุ้มค่ามาก

บันทึกนับล้าน

การควบคุมล้น/ประสิทธิภาพ

เป็นโมฆะ/ไม่ได้กำหนด

พื้นที่หายไป

ข้อผิดพลาดที่ควบคุมหรือค่าเริ่มต้น

ซ้ำ/ผิดปกติ

ซ้ำ, ลำดับย้อนกลับ

ผลลัพธ์ที่ถูกต้อง

เคสมินิ

กรณีที่ 1 — ข้อผิดพลาดในการปัดเศษแบบเงียบ AI เขียนฟังก์ชันที่รวบรวมเงินประเภททศนิยม (ทศนิยม) 0.1 + 0.2 ให้ 0.30000000000000004 ข้อผิดพลาดได้รับการแก้ไขเมื่อวิศวกรเพิ่มกฎ "ปัดเศษเป็น 2 หลักและใช้เพนนีทั้งหมด" กฎ 3 บรรทัดป้องกันความแปรปรวนหลายพันเพนนีในการกระทบยอดรายเดือน

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

กรณีที่ 3 — รายได้ทีละขั้นตอน นักพัฒนาพิมพ์โมดูลนำเข้า 150 บรรทัดพร้อมกัน เมื่อเขาพบข้อผิดพลาดเขาก็ไม่สามารถหาที่มาของมันได้ Developer อีกคนแบ่งงานเดียวกันออกเป็น 5 ขั้นตอนเล็กๆ ทดสอบแต่ละขั้นตอนภายใน 2 นาที และตรวจพบข้อผิดพลาดทันทีในขั้นตอนที่ 3

ข้อผิดพลาดทั่วไป

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

โดยสรุป

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

งานสมัคร

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

รายการตรวจสอบ

• [ ] ฉันเขียนสัญญาซึ่งรวมถึงอินพุต เอาท์พุต ข้อผิดพลาด และข้อจำกัด
• [ ] ฉันสร้างโค้ดด้วยขั้นตอนเล็กๆ แทนที่จะเป็นบล็อกใหญ่บล็อกเดียว
• [ ] ฉันได้เพิ่มบล็อกการทดสอบ/ตัวอย่างการทำงานถัดจากโค้ด
• [ ] ฉันได้ทดสอบ Edge Case อย่างน้อย 5 ชิ้นอย่างมีสติ
• [ ] ฉันอธิบายโค้ดให้ AI ​​ทราบและตรวจสอบสมมติฐานแล้ว
• [ ] ฉันแก้ไขข้อผิดพลาดที่พบและยืนยันการแก้ไขด้วยการทดสอบซ้ำ