Notes ของ Ada Lovelace เกี่ยวกับ Analytical Engine อธิบายอัลกอริทึมที่ทำซ้ำได้ มาดูว่าแนวคิดยุคแรกของเธอสอดคล้องกับการออกแบบโปรแกรมและการคิดเชิงคอมพิวเตอร์ในปัจจุบันอย่างไร
คุณคงเคยได้ยินสรุปสั้น ๆ ว่า: Ada Lovelace เขียน “อัลกอริทึมแรก” ชุดคำสั่งที่ตั้งใจให้ Charles Babbage’s Analytical Engine ปฏิบัติ หลายคนยังอ้างถึงมันเพราะเป็นตัวอย่างแรก ๆ ที่ชัดเจนของสิ่งที่เราวันนี้เรียกว่า programming—การแยกเป้าหมายออกเป็นขั้นตอนที่แม่นยำซึ่งเครื่องสามารถทำตามได้
บทความนี้ไม่ได้พยายามประกอบฟันเฟืองของ Engine ใหม่หรือพิสูจน์ข้อเท็จจริงทางประวัติศาสตร์ทุกข้อ แต่เน้นที่แนวคิดการเขียนโปรแกรมในงานของ Lovelace: วิธีเปลี่ยนโจทย์คณิตศาสตร์ให้เป็นสิ่งที่เครื่องทำได้ วิธีแทนค่าข้อมูล และวิธีสื่อขั้นตอนเพื่อให้ผู้อื่น (หรือสิ่งอื่น) รันมันได้
Notes อันมีชื่อของ Lovelace อ่านแล้วเหมือนสะพานเชื่อมคณิตศาสตร์กับการออกแบบซอฟต์แวร์ แม้ว่าเครื่องจะเป็นภาพสมมติ แต่แนวคิดนั้นคุ้นเคยกับใครก็ตามที่เคยพยายามให้คอมพิวเตอร์ทำอะไรสักอย่างให้เชื่อถือได้
นี่คือสิ่งที่เราจะจับตาไปตลอดบทความ:
จุดมุ่งหมายง่าย ๆ คือ: มองอัลกอริทึม "แรก" ของ Lovelace ให้น้อยลงเป็นของจัดแสดงในพิพิธภัณฑ์ และมากขึ้นเป็นแม่แบบแรก ๆ ของการคิดเชิงคอมพิวเตอร์ที่ยังสะท้อนวิธีเรายังออกแบบโปรแกรมในวันนี้
Augusta Ada King, Countess of Lovelace—ที่รู้จักกันดีในชื่อ Ada Lovelace—เติบโตท่ามกลางทางแยกระหว่างกวีนิพนธ์และคณิตศาสตร์ แม่ของเธอส่งเสริมการเรียนรู้เชิงเข้มข้น และ Ada ก็กลายเป็นส่วนหนึ่งของวงสังคมเล็ก ๆ ของนักวิทยาศาสตร์และนักคิดเด่น ๆ เธอไม่ได้เป็นอัจฉริยะผู้โดดเดี่ยว แต่เป็นผู้ร่วมงานที่มีพรสวรรค์ซึ่งตั้งคำถามได้ชัดเจนเกี่ยวกับสิ่งที่เครื่องสามารถ มีความหมาย ไม่ใช่แค่ทำได้
Charles Babbage เป็นที่รู้จักจากแผนการคำนวณกลไกเมื่อ Ada พบเขา Babbage สามารถออกแบบฮาร์ดแวร์ในหัว: ฟันเฟือง แกน และวงล้อตัวเลขเรียงกันเป็นระบบ ส่วน Ada มีพรสวรรค์ด้านการอธิบาย—เอาความคิดทางเทคนิคที่ซับซ้อนแล้วแปลงเป็นแนวคิดที่มีโครงสร้างและสื่อสารได้
ความสัมพันธ์ของพวกเขาทำงานได้เพราะจุดแข็งต่างกัน Babbage ผลักวิสัยทัศน์เชิงวิศวกรรมไปข้างหน้า; Ada ผลักวิสัยทัศน์เชิงแนวคิดไปข้างหน้า โดยเฉพาะความคิดที่ว่าเครื่องสามารถตามลำดับการดำเนินการที่คนออกแบบไว้ล่วงหน้าได้
Analytical Engine ของ Babbage ไม่ใช่แค่เครื่องคิดเลขที่ดีกว่า บนกระดาษมันอธิบายเครื่องอเนกประสงค์: เครื่องที่เก็บค่า ดำเนินการ และรันขั้นตอนที่วางแผนไว้ทีละขั้น คิดว่าเป็นแบบร่างแรกสำหรับสิ่งที่วันนี้เราเรียกว่า programmable computer—แม้ว่าจะไม่ได้สร้างเสร็จในชีวิตของพวกเขาก็ตาม
ทศวรรษ 1840 เป็นช่วงเวลาที่คณิตศาสตร์ อุตสาหกรรม และระบบอัตโนมัติกำลังก้าวเข้ามาพบกัน ผู้คนต้องการวิธีการที่เชื่อถือได้—ตาราง สูตร และกระบวนการที่ทำซ้ำได้—เพราะข้อผิดพลาดมีค่าใช้จ่ายสูงและวิทยาศาสตร์กำลังก้าวไกล ในบริบทนั้น ความสนใจของ Ada ใน "วิธีสอนเครื่อง" ไม่ใช่แค่ความอยากรู้ แต่เป็นการตอบสนองตามกาลเวลา: แปลงเหตุผลของมนุษย์ให้เป็นกระบวนการที่ทำซ้ำและตรวจสอบได้
ก่อนที่ Ada Lovelace จะอธิบายอัลกอริทึม ต้องมีเครื่องที่คุ้มค่าที่จะ "ตั้งโปรแกรม" ก่อน Charles Babbage คิดว่า Analytical Engine เป็นเครื่องคิดเลขอเนกประสงค์: ไม่ใช่อุปกรณ์สำหรับสูตรเดียว แต่เป็นเครื่องที่สามารถตั้งค่าให้ทําลําดับการดำเนินการต่าง ๆ ได้
แนวคิดหลักเรียบง่าย: หากคุณแยกปัญหาเป็นขั้นตอนเลขคณิตเล็ก ๆ (บวก ลบ คูณ หาร) เครื่องควรทำขั้นตอนเหล่านั้นอย่างเชื่อถือได้ ตามลำดับที่ถูกต้อง และกี่ครั้งก็ได้เมื่อจำเป็น
นั่นคือการก้าวจากการคำนวณครั้งเดียวสู่วิธีการที่นำกลับมาใช้ใหม่ได้
Babbage อธิบายสองส่วนหลัก:
สำหรับ input และ output Engine ถูกออกแบบให้รับคำสั่งและข้อมูลโดยใช้บัตรเจาะรู (ได้แรงบันดาลใจจากกี่ทอผ้า) และผลิตผลลัพธ์ในรูปแบบที่มนุษย์ใช้ได้—พิมพ์หรือบันทึกไว้
ถ้าตัดไปเทียบกับวันนี้:
นี่คือเหตุผลที่ Analytical Engine มีความหมาย: มันร่างการแยกหน้าที่ที่เราใช้จนถึงทุกวันนี้—ฮาร์ดแวร์ที่ทำตามขั้นตอน กับ โปรแกรมที่กำหนดขั้นตอนเหล่านั้น
เมื่อคนพูดถึง Ada Lovelace และอัลกอริทึมแรก พวกเขามักหมายถึงชุด "Notes" ที่เธอแนบไว้กับการแปลภาษาอังกฤษของบทความของ Luigi Menabrea เกี่ยวกับ Charles Babbage’s Analytical Engine
Menabrea อธิบายแนวคิดของเครื่อง Lovelace ก้าวไปไกลกว่านั้น: เธอมอง Engine เป็นสิ่งที่คุณสามารถ สั่งงาน ได้—ไม่ใช่แค่ชื่นชม การเปลี่ยนแปลงนี้คือเหตุผลที่ Notes มีความสำคัญในประวัติศาสตร์การเขียนโปรแกรม พวกมันอ่านแล้วเหมือนการคิดเชิงคอมพิวเตอร์: แยกเป้าหมายเป็นขั้นตอนที่ชัดเจน เลือกการแทนค่า และคาดการณ์ว่าเครื่องจักรจะทำตามอย่างไร
Notes ของ Lovelace อธิบายสิ่งที่เราวันนี้เรียกว่า program design เธออธิบายส่วนต่าง ๆ ของ Engine (เช่น หน่วยเก็บข้อมูลและ "mill" ที่ประมวลผล) ในแง่ของการจัดลำดับและควบคุมการดำเนินการ แนวคิดศูนย์กลางเรียบง่ายแต่ลึกซึ้ง: หาก Analytical Engine สามารถทำการดำเนินการตามลำดับที่กำหนดบนสัญลักษณ์ที่กำหนดได้ วิธีการต้องถูกเขียนลงในรูปแบบที่เครื่องสามารถดำเนินการได้
นี่คือจุดที่งานของเธอเริ่มใกล้เคียงกับการเขียนโปรแกรมสมัยใหม่ มันไม่ใช่แค่ทฤษฎี แต่มันคือวิธีการ
ที่สำคัญที่สุด Notes รวมตัวอย่างที่ทำเป็นตารางขั้นตอน วางไว้อย่างเป็นบรรทัดต่อบรรทัดว่าควรให้เครื่องทำอะไร—ค่าตัวเลขอยู่ที่ตำแหน่งไหน การดำเนินการถัดไปคืออะไร และผลลัพธ์ถูกเก็บไว้ที่ไหน
รูปแบบตารางนั้นเป็นบรรพบุรุษของ pseudocode, flowcharts และตารางตารางคำสั่งในปัจจุบัน: แผนที่ชัดเจน ตรวจสอบได้ ที่คุณสามารถติดตามโดยไม่ต้องเดา ไม่ว่าคุณจะสร้าง Analytical Engine หรือไม่ กฎนิสัยนี้—การแปลงไอเดียให้เป็นลำดับที่รันได้—คือหัวใจของการเขียนซอฟต์แวร์
อัลกอริทึม ในภาษาทั่วไปคือวิธีการที่ทำซ้ำได้: ชุดขั้นตอนชัดเจนที่จะพาคุณจากจุดเริ่มต้นถึงคำตอบได้อย่างมั่นคง เหมือนสูตรที่ไม่ขึ้นกับสัญชาตญาณ—ถ้าทำตามขั้นตอน คุณจะได้ผลเหมือนกันทุกครั้ง
ตัวอย่างอัลกอริทึมที่โด่งดังของ Ada ตั้งใจคำนวณ Bernoulli numbers—ลำดับค่าที่ปรากฏในหลายส่วนของคณิตศาสตร์ (เช่น สูตรผลรวม 1 + 2 + … + n และบางส่วนของแคลคูลัส) คุณไม่จำเป็นต้องรู้ทฤษฎีเบื้องหลังเพื่อเห็นว่าทำไมมันเป็นกรณีทดสอบที่ดีสำหรับเครื่องคำนวณแรก ๆ
มันท้าทายในทางที่เหมาะสม:
กล่าวคือ มันซับซ้อนพอจะพิสูจน์ว่าเครื่องตามขั้นตอนได้ แต่ยังเป็นระเบียบพอที่จะเขียนเป็นขั้นตอน
แก่นของอัลกอริทึมมีโครงสร้างที่คุ้นเคยที่เราใช้ในโปรแกรมสมัยใหม่:
ในมุมนี้ Lovelace ไม่ได้แค่แสดงการคำนวณตัวเลข—เธอแสดงวิธีจัดระเบียบการคำนวณหลายขั้นตอนให้เครื่องปฏิบัติได้โดยไม่ต้องเดา
เมื่อคนพูดถึงอัลกอริทึม Bernoulli ของ Lovelace มักสนใจผลลัพธ์ (“โปรแกรมแรก”) มากกว่างานออกแบบที่ทำให้ขั้นตอนน่าเชื่อถือ ความสำเร็จจริง ๆ ไม่ใช่แค่การจัดรายการการดำเนินการ แต่คือการปั้นให้เครื่องทำตามได้โดยไม่ต้องประดิษฐ์
แทนที่จะมองว่า “คำนวณ Bernoulli numbers” เป็นงานเดียว Notes แยกเป็นงานย่อยที่ทำซ้ำและตรวจสอบได้: คำนวณค่ากลาง รวมตามสูตร บันทึกผลลัพธ์ แล้วไปกรณีถัดไป
การแยกย่อยนี้สำคัญเพราะแต่ละส่วนย่อยตรวจสอบได้แยกกัน หากผลออกมาผิด คุณไม่ต้องดีบักทั้งอัลกอริทึม แต่ตรวจสอบชิ้นส่วนเดียว
คอมพิวเตอร์กลไกไม่สามารถ “คิดในใจ” ได้ ทุกค่าที่จะต้องใช้ต่อไปต้องถูกเก็บไว้ที่ไหนสักแห่ง Notes ระบุเรื่องนี้อย่างระมัดระวัง บางตัวเลขเป็นค่าชั่วคราว บางตัวเป็นผลลัพธ์สุดท้ายที่ต้องถูกเก็บเพื่อใช้ในขั้นต่อไป
นี่เป็นรูปแบบแรกของการคิดเกี่ยวกับ program state:
ลำดับการดำเนินการเป็นคุณสมบัติด้านความปลอดภัย การคำนวณบางอย่างต้องทำก่อนเพื่อหลีกเลี่ยงการใช้ค่าที่ยังไม่ได้เตรียม หรือการเขียนทับค่าที่ยังจำเป็น
ในคำพูดสมัยใหม่ Lovelace กำลังออกแบบ control flow ให้โปรแกรมมีเส้นทางชัดเจน: ทำ A ก่อน จากนั้น B แล้ว C—เพราะทำ B ก่อนจะให้คำตอบผิดโดยไม่รู้ตัว
หนึ่งในแนวคิดที่ “ทันสมัย” ที่ซ่อนอยู่ในตารางขั้นตอนของ Lovelace คือการทำซ้ำ: คำสั่งชุดเดียวกันทำซ้ำหลายครั้ง ไม่ใช่เพราะติดอยู่ แต่เพราะการทำซ้ำเป็นวิธีที่เร็วและชัดเจนที่สุด
การทำซ้ำในโปรแกรมหมายถึง: ทำสูตรเล็ก ๆ ตรวจสอบว่าเสร็จหรือยัง ถ้ายังให้ทำสูตรเดิมอีกครั้ง จุดสำคัญคือมีสิ่งที่เปลี่ยนในแต่ละครั้ง—มักเป็นเคาน์เตอร์ ตำแหน่งในตาราง หรือค่าที่สะสม—ทำให้โปรแกรมเดินไปข้างหน้าจนถึงเส้นชัย
ในสัญกรณ์ของ Lovelace คุณเห็นการกลับไปยังขั้นก่อนหน้าอย่างเป็นระบบ แทนที่จะเขียนซ้ำคำสั่งเหมือนกันหลาย ๆ ครั้ง เธอกำหนดรูปแบบแล้วบอกว่าจะวนกลับเมื่อใด นั่นคือเมล็ดพันธุ์ของสิ่งที่เราเรียกว่า iteration ในวันนี้
ถ้าคุณเขียนโค้ด คุณจะเห็นรูปแบบนี้เป็น for loops (“ทำซ้ำ N ครั้ง”) หรือ while loops (“ทำจนกว่าเงื่อนไขจะเป็นจริง”) ตารางของเธอยังมีส่วนประกอบของลูปที่คุ้นเคย:
สมมติคุณต้องการผลรวมจาก 1 ถึง 5
total = 0\n- เริ่มด้วย i = 1\n- บวก i เข้า total\n- เพิ่ม i ทีละ 1\n- ถ้า i ยังไม่เกิน 5 ให้ทำขั้นตอนบวกและเพิ่มซ้ำนี่คือการวนซ้ำแบบเรียบง่าย: ลูปเล็ก ๆ ที่อัปเดตเคาน์เตอร์และสะสมผล Lovelace ไม่ได้แค่โชว์สิ่งที่คำนวณได้ แต่แสดงว่าโครงสร้างการทำซ้ำสามารถเขียนให้ชัดเจนพอที่เครื่อง (และมนุษย์ในอนาคต) จะดำเนินการได้อย่างเชื่อถือได้
กระบวนการอาจดูสมเหตุสมผลในหัว แต่ยังทำให้เครื่องหรือคนอื่นปฏิบัติตามไม่ได้หากไม่มีวิธีอ้างถึงปริมาณที่เปลี่ยนแปลงได้ นั่นคือที่มาของตัวแปรและสัญกรณ์
คิดว่าตัวแปรเป็นกล่องที่มีป้าย ชื่อป้ายคงที่ แต่ข้างในเปลี่ยนได้ขณะทำงาน
ถ้าคุณกำลังคำนวณลำดับ อาจมี:
ถ้าไม่มีกล่องพวกนี้ คุณต้องอธิบายเป็นประโยคยาว ๆ (“เอาตัวเลขที่คำนวณเมื่อสองขั้นก่อน…”) ซึ่งจะยุ่งเหยิงเร็วมาก
ใน Notes สัญลักษณ์และป้ายชื่อไม่ใช่เพื่อให้ดูเป็นทางการ แต่วางไว้เพื่อให้กระบวนการรันได้ สัญกรณ์ชัดเจนตอบคำถามปฏิบัติ:\n\n- ค่าตัวไหนกำลังถูกอัปเดตตอนนี้?\n- ค่าตัวไหนต้องเก็บไว้ใช้ต่อ?\n- ค่าชั่วคราวไหนเขียนทับได้?
เมื่อกระบวนการยาว คำชี้แจงเล็ก ๆ เหล่านี้ป้องกันความผิดพลาดที่พบได้บ่อยที่สุด: สับสนค่าที่มีลักษณะคล้ายกัน
การตั้งชื่อตัวแปรที่ดียังเป็นวิธีถูกที่สุดเพื่อลดบั๊ก ลองเปรียบ x1, x2, x3 กับ current_sum, term_index, next_term: ชุดที่สองบอกว่าแต่ละกล่องใช้ทำอะไร
ประเภท (types) เพิ่มความปลอดภัยอีกชั้น การตัดสินใจว่าสิ่งใดเป็น integer, decimal, list หรือ record เหมือนการเลือกชนิดของภาชนะ—ข้อผิดพลาดบางอย่างจะเป็นไปไม่ได้หรือจับได้ง่ายขึ้นตั้งแต่ต้น
ตัวแปรและสัญกรณ์เปลี่ยน "ไอเดียฉลาด ๆ" ให้กลายเป็นขั้นตอนที่ใครก็ทำซ้ำได้อย่างถูกต้อง (รวมถึงเครื่องด้วย)
Abstraction หมายถึงการมุ่งไปที่สิ่งสำคัญและซ่อนรายละเอียดที่ไม่จำเป็น มันต่างจากการบอกว่า "จัดเรียงรายการนี้" กับการอธิบายทุกการสลับและเปรียบเทียบด้วยมือ Notes ของ Lovelace แสดงสัญชาตญาณนี้ตั้งแต่แรก: เธอตั้งใจสื่อวิธีการโดยไม่บังคับให้ผู้อ่านลงไปติดอยู่กับกลไกทางกายภาพของเครื่อง
คุณสมบัติเด่นของ Notes คือการทำให้แกนหลักแยกออกจากการกระทำทางกล The Analytical Engine มี "วิธีทำ" ของมัน (ฟันเฟือง store mill) แต่ Notes เน้นที่ "สิ่งที่ต้องทำ": ลำดับการดำเนินการที่จำเป็นเพื่อให้ได้ผลลัพธ์
การแยกนี้คือเมล็ดพันธุ์ของการออกแบบซอฟต์แวร์:
เมื่อคุณสามารถอธิบายวิธีการโดยไม่ต้องอธิบายเครื่องซ้ำ คุณก็ถือว่าการคำนวณเป็นสิ่งที่พกพาได้—นำไปใช้อีกบนฮาร์ดแวร์ต่างกันหรือโดยคนต่างกันได้
ตารางทีละขั้นใน Notes คล้ายกับ "procedure" ต้น ๆ: ชุดขั้นตอนที่เรียกใช้ซ้ำได้ โค้ดสมัยใหม่ทำให้เป็นรูปธรรมด้วยฟังก์ชัน โมดูล และคอมโพเนนต์นำกลับมาใช้ได้
ฟังก์ชันที่ดีทำหน้าที่เหมือนการนำเสนอของ Lovelace:
นี่คือเหตุผลที่ abstraction ไม่ใช่การคลุมเครือ แต่มันคือการทำให้ ใช้งานได้ การนำกลับมาใช้จึงเกิดขึ้นตามธรรมชาติ: เมื่อวิธีการถูกรูปแบบชัดเจน คุณเรียกใช้มันในบริบทใหม่ ๆ รวมกับวิธีอื่น ๆ และสร้างระบบใหญ่ขึ้นโดยไม่จมในรายละเอียด
Ada Lovelace ไม่ได้แค่บอกว่า Analytical Engine ทำอะไรได้—เธอแสดงวิธีทำให้ขั้นตอนไม่คลุมเครือสำหรับคนอื่น (หรือเครื่อง) นั่นคือพลังเงียบของ Notes: เธอปฏิบัติต่อการอธิบายเป็นส่วนหนึ่งของงาน ไม่ใช่ของประดับ
เหตุผลหนึ่งที่การนำเสนอของเธอยังทันสมัยคือการใช้ตารางขั้นตอน โครงสร้างตารางบังคับให้ตัดสินใจที่ข้อความพร่ามัวอาจปิดซ่อนไว้:
นั่นลดความคลุมเครือในแบบเดียวกับ pseudocode ของวันนี้ คุณอาจอ่านย่อหน้าและคิดว่าคุณเข้าใจ—จนกว่าจะลองรันจริง ตารางขั้นตอนทำให้เส้นทางการดำเนินการมองเห็นได้ ซึ่งเป็นสิ่งที่เอกสารโปรแกรมที่ดีมุ่งหวังจะทำ
Notes ของ Lovelace รวมสิ่งที่เรายังคงพยายามรวมกัน:
นั่นสอดคล้องกับคอมเมนต์, docstrings, และ README สมัยใหม่ README อธิบายเป้าหมายและบริบท คอมเมนต์ในบรรทัดอธิบายขั้นตอนที่ซับซ้อน Docstrings ระบุ inputs/outputs และ edge cases เมื่อขาดสิ่งใดสิ่งหนึ่ง ผู้ใช้มักต้องเดา และการเดาคือที่ที่บั๊กเกิด
เมื่อคุณเอกสารกระบวนการ (โค้ดหรืออื่น ๆ) เขียนราวกับว่าคนอื่นจะทำซ้ำโดยไม่มีคุณ:\n\n- ระบุ inputs และ outputs ให้ชัดเจน ("ให้ X ผล Y")\n- ลงข้อสมมติ (หน่วย, ลำดับ, กฎการปัดเศษ)\n- เขียนขั้นตอนเป็นลำดับหมายเลข หรือเป็นตารางสถานะสั้น ๆ\n- ตั้งชื่อตัวแปรกลาง และใช้ชื่อนั้นสม่ำเสมอ\n- รวมตัวอย่างงานสั้น ๆ ให้คนตรวจสอบด้วยมือได้
นั่นไม่ใช่งานเพิ่มแต่เป็นวิธีที่ทำให้วิธีการนำกลับมาใช้ได้
Ada Lovelace มักถูกแนะนำด้วยป้าย "โปรแกรมเมอร์คนแรก" ซึ่งเป็นคำย่อที่มีประโยชน์ แต่ก็อาจทำให้ความจริงที่น่าสนใจกว่าถูกลดความสำคัญ ข้อถกเถียงไม่ใช่เรื่องศักดิ์ศรีเพียงอย่างเดียว แต่มันเกี่ยวกับความหมายของคำว่า โปรแกรม, คอมพิวเตอร์, และ การเป็นผู้เขียนงาน
ถ้า "โปรแกรมเมอร์" หมายถึงคนที่เขียนคำสั่งสำหรับเครื่องอเนกประสงค์ Ada มีสิทธิ์อ้างได้ เดิมใน Notes เธออธิบายวิธีทีละขั้นตอนสำหรับสร้าง Bernoulli numbers—หลัก ๆ เป็นแผนว่าถ้า Engine อยู่ มันจะคำนวณค่าไม่ใช่เรื่องเล็ก
แต่ประวัติศาสตร์ถกเถียงเพราะ:\n\n- Analytical Engine ไม่ได้เสร็จสมบูรณ์ในยุคนั้น ดังนั้นโปรแกรมไม่สามารถรันยืนยันได้\n- บางส่วนของวิธีอาจสะท้อนการร่วมมือกับ Charles Babbage ที่คิดเรื่องกระบวนการของเครื่องมานานแล้ว\n- มีระบบอัตโนมัติเก่าก่อนหน้านั้น (เช่น Jacquard loom) แม้ไม่ใช่ความหมายเดียวกับ "เครื่องที่ตั้งโปรแกรมได้" ในเชิงทั่วไป
แยกการคิดค้นไอเดียการคำนวณออกจากการสร้างเครื่องที่ใช้งานได้ Babbage ให้คุณค่าทางสถาปัตยกรรม: เครื่องที่มี memory ("store"), processor ("mill"), และการควบคุมผ่านบัตรเจาะรู Lovelace ให้คุณค่าเชิงการตีความและการสื่อ: เธอชี้ว่าเครื่องสามารถ แทน สิ่งต่าง ๆ ได้อย่างไรและกระบวนการจะถูก เขียนลง อย่างไรเพื่อให้เครื่องทำตามได้
โปรแกรมไม่ได้เลิกเป็นโปรแกรมเพราะฮาร์ดแวร์ยังไม่มี ในคำสมัยใหม่ มันเหมือนการเขียนซอฟต์แวร์สำหรับแพลตฟอร์มที่ยังเป็นทฤษฎี—หรือระบุอัลกอริทึมก่อนชิปรองรับ
วิธีที่เคารพต่อยุคนั้นคือมองเป็นความร่วมมือระหว่างบทบาทต่าง ๆ:\n\n- Babbage: การออกแบบเครื่อง, ความทะเยอทะยานทางคณิตศาสตร์ และการพัฒนาแบบยาวนาน\n- Lovelace: การแปล ขยาย อธิบาย และความสามารถพิเศษในการเชื่อมขั้นตอนนามธรรมกับเครื่องอเนกประสงค์\n- Menabrea (และคนอื่น ๆ): คำอธิบายก่อนหน้าที่ Lovelace แปลและแปลงให้ละเอียดขึ้นมาก
สิ่งที่เราพูดด้วยความมั่นใจได้คือ: Notes ของ Lovelace ช่วยกำหนดความหมายของการเขียนโปรแกรม—ไม่ใช่แค่การคำนวณ แต่การแสดงอย่างระมัดระวังของกระบวนการที่เครื่องสามารถปฏิบัติตามได้
Notes ของ Lovelace สำคัญเพราะมันแสดง วิธีคิด เมื่อเปลี่ยนไอเดียเป็นแผนที่เครื่องรันได้ แม้คุณจะไม่เคยจับบัตรเจาะรูหรือฟันเฟือง กลุ่มบทเรียนหลักยังสอดคล้องกับการออกแบบโปรแกรมสมัยใหม่: ให้โครงงานมีโครงสร้างชัดเจน ตั้งชื่อให้ดี ใช้การทำซ้ำอย่างตั้งใจ และสร้างชิ้นที่นำกลับมาใช้ได้
โครงสร้างชนะความฉลาดเฉพาะตัว. โปรแกรมง่ายต่อการสร้างและดูแลเมื่อแบ่งเป็นขั้นตอนที่มีจุดประสงค์ชัดเจน แนวทางของ Lovelace สนับสนุนการออกแบบรูปทรงของวิธีการก่อนลงรายละเอียด
ความชัดเจนเป็นฟีเจอร์. ตารางและคำอธิบายของเธอไม่ใช่ของประดับ แต่เป็นส่วนหนึ่งของโปรแกรม เมื่อ "คุณในอนาคต" (หรือเพื่อนร่วมงาน) ตามเหตุผลได้เร็ว โปรแกรมจะเชื่อถือได้มากขึ้น
การทำซ้ำคือเครื่องมือไม่ใช่ลูกเล่น. ลูปช่วยขยายวิธีการ จุดสำคัญคือต้องกำหนดว่ามีอะไรซ้ำ อะไรเปลี่ยน และเมื่อใดจะหยุด
Abstraction เปิดทางให้ reuse. ถ้าขั้นตอนหนึ่งทำงานได้ครั้งหนึ่ง มันควรเรียกใช้ได้อีกด้วยอินพุตต่างกัน นั่นคือเมล็ดพันธุ์ของฟังก์ชัน โมดูล และไลบรารี
ถ้าคุณเคยใช้เวิร์กโฟลว์แบบ “สร้างโดยการอธิบาย”: เขียนข้อกำหนด วนแผน แล้วออกโค้ด คุณได้ทำซ้ำจิตวิญญาณของ Notes ของ Lovelace: ทำให้ขั้นตอนชัดเจน เก็บ state ให้ชัด และอธิบายข้อสมมติให้การรันทำซ้ำได้
นั่นคือเหตุผลที่แพลตฟอร์ม vibe-coding อย่าง Koder.ai เข้ากับเรื่องนี้เป็นอย่างดี Koder.ai ให้คุณสร้างเว็บ แบ็กเอนด์ และแอปมือถือผ่านอินเทอร์เฟซแชท แต่หลักการเดียวกันใช้ได้: ผลลัพธ์ดีกว่าเมื่อคุณระบุ inputs/outputs ตั้งชื่อให้สอดคล้อง และขอรูปแบบเป็นขั้นตอน (โหมดการวางแผนช่วยล็อก "Notes" ของคุณก่อนจะสร้างหรือเปลี่ยนโค้ด)
ใช้รอบตรวจสอบนี้ก่อนเริ่มโค้ด หรือเมื่อดีบักสิ่งที่รู้สึกว่ารกรุงรัง:\n\n1. เป้าหมาย: พูดให้ออกว่ารโปรแกรมให้ผลอะไรในหนึ่งประโยคหรือไม่?\n2. Inputs/outputs: เข้าอะไรออกอะไร รูปแบบเป็นอย่างไร?\n3. แยกย่อย: มี 3–7 ขั้นตอนหลักอะไรบ้าง? (ถ้ามากให้รวมกลุ่ม)\n4. ตั้งชื่อ: ค่าหลักคืออะไร ตั้งชื่อให้สม่ำเสมอ\n5. หาการทำซ้ำ: ขั้นตอนไหนทำซ้ำ อะไรเปลี่ยนในแต่ละครั้ง?\n6. เงื่อนไขหยุด: อะไรที่จบแต่ละลูปหรือกระบวนการ? หลีกเลี่ยงงานไม่สิ้นสุดอย่างไร?\n7. บล็อกที่ใช้ซ้ำได้: ขั้นตอนไหนควรกลายเป็นฟังก์ชันนำกลับมาใช้ได้?\n8. อธิบาย: ผู้อ่านจะเข้าใจแผนจากคอมเมนต์หรือเอกสารโดยไม่ต้องรันโค้ดไหม?
ถ้าต้องการเสริมทักษะการออกแบบแบบ "จด Notes ก่อน" เหล่านี้จะช่วยได้:\n\n- /blog/how-to-write-better-requirements\n- /blog/pseudocode-examples
รวมกันแล้ว นิสัยเหล่านี้เปลี่ยนการเขียนโปรแกรมจาก "ทำให้มันทำงาน" เป็น "ทำให้มันเข้าใจได้"—การเปลี่ยนแปลงที่ Notes ของ Lovelace ชี้นำไว้ตั้งแต่ต้น
Ada Lovelace’s “first algorithm” คือขั้นตอนทีละข้อ (ปรากฏใน Notes ของเธอ) ที่ตั้งใจให้ Charles Babbage’s Analytical Engine ดำเนินการ เป็นที่รู้จักเพราะมันถือว่าการคำนวณเป็น ลำดับของการดำเนินการที่วางแผนไว้บนค่าที่เก็บไว้ ซึ่งคล้ายกับการเขียนโปรแกรมสมัยใหม่ แม้ว่าเครื่องจะไม่ถูกสร้างขึ้นให้เสร็จในยุคนั้นก็ตาม
บทความนี้เน้นที่ แนวคิดด้านการเขียนโปรแกรม ในงานของ Lovelace—วิธีการแสดงขั้นตอนให้สามารถทำงานได้จริง ตรวจสอบได้ และเข้าใจได้—มากกว่าการพยายามสร้างเครื่อง Analytical Engine ใหม่หรือแก้ไขข้อถกเถียงทางประวัติศาสตร์ทุกประการ
Analytical Engine เป็นเครื่องที่ถูกออกแบบให้เป็นเครื่องคำนวณแบบอเนกประสงค์ โดยมีความสามารถที่จะ:
สถาปัตยกรรมนี้สำคัญเพราะมันแยก ฮาร์ดแวร์ที่ลงมือปฏิบัติ ออกจาก โปรแกรมที่ระบุขั้นตอน—ความแยกเดียวกันนี้คือพื้นฐานของคอมพิวเตอร์สมัยใหม่
Bernoulli numbers เป็นลำดับที่ปรากฏในสูตรทางคณิตศาสตร์หลายแห่ง เหมาะเป็นตัวอย่างเพราะแต่ละค่าขึ้นกับค่าก่อนหน้า ต้องการ การคำนวณหลายขั้นตอน, การเก็บผลลัพธ์ชั่วคราว, และ ขั้นตอนที่ทำซ้ำได้—สิ่งที่อยากทดสอบกับเครื่องที่ตั้งโปรแกรมได้
ตารางขั้นตอนบังคับให้ต้องระบุอย่างชัดเจน:
นั่นทำให้มันคล้ายกับ pseudocode สมัยใหม่และช่วยให้ผู้อื่น ‘รัน’ ขั้นตอนโดยไม่ต้องเดา
การทำซ้ำที่ Lovelace แสดงออกมาเป็นรูปแบบดั้งเดิมของ iteration: กำหนดชุดคำสั่งเล็ก ๆ, เปลี่ยนค่าในแต่ละครั้ง (เช่น เคาน์เตอร์หรือผลรวมบางส่วน), แล้วหยุดเมื่อเงื่อนไขเป็นจริง ในโค้ดสมัยใหม่จะเทียบได้กับ for/while โดยมี:
เพราะเครื่องไม่สามารถ ‘จดจำ’ บริบทแบบมนุษย์ได้ การมีป้ายชื่อสำหรับค่าต่าง ๆ (เหมือนตัวแปร) จะช่วยติดตาม:
สิ่งนี้ลดความผิดพลาดที่มักเกิดจากการสับสนระหว่างค่าที่ดูคล้ายกัน
Abstraction แยก วิธีการ (algorithm) ออกจาก กลไก (การทำงานของเครื่อง) นั่นคือรากฐานของคอมโพเนนต์ที่นำกลับมาใช้ซ้ำได้:
ในโค้ดสมัยใหม่ นี่คือเหตุผลที่ฟังก์ชันและโมดูลช่วยให้ระบบขยายตัวได้
ป้าย ‘first programmer’ ถูกถกเถียงกันเพราะ:
ข้อสรุปที่ปลอดภัยคือ Notes ของเธอชัดเจนในการนิยามว่า การ ‘เขียนโปรแกรม’ คือการเขียนขั้นตอนที่ไม่มีความคลุมเครือให้เครื่องทำตามได้
ใช้การตรวจสอบแบบรวดเร็วก่อนเริ่มโค้ด:
สำหรับคู่มือที่เกี่ยวข้อง ดู /blog/how-to-write-better-requirements และ /blog/pseudocode-examples