19 ธ.ค. 2568·2 นาที
Von Neumann และคอมพิวเตอร์แบบเก็บโปรแกรมที่เปิดทางให้ซอฟต์แวร์
เรียนรู้ว่าแนวคิดเก็บโปรแกรม—ที่มักเชื่อมโยงกับ John von Neumann—ทำให้ซอฟต์แวร์นำกลับมาใช้ซ้ำได้ คอมพิวเตอร์อเนกประสงค์ และการเขียนโปรแกรมสมัยใหม่เป็นไปได้อย่างไร
เรียนรู้ว่าแนวคิดเก็บโปรแกรม—ที่มักเชื่อมโยงกับ John von Neumann—ทำให้ซอฟต์แวร์นำกลับมาใช้ซ้ำได้ คอมพิวเตอร์อเนกประสงค์ และการเขียนโปรแกรมสมัยใหม่เป็นไปได้อย่างไร
แกนกลางของการคอมพิวติ้งสมัยใหม่คือคำถามง่ายๆ: อะไรที่ทำให้เครื่องหนึ่งเครื่องสามารถทำงานต่างๆ ได้โดยไม่ต้องรื้อเปลี่ยนเครื่องใหม่ทุกครั้ง? คอมพิวเตอร์อิเล็กทรอนิกส์ยุคแรกคำนวณได้เร็ว แต่ “การเปลี่ยนงาน” มักหมายถึงการปรับการตั้งค่าทางกายภาพ แนวคิดเก็บโปรแกรมคือจุดเปลี่ยนที่ทำให้คอมพิวเตอร์กลายเป็นเครื่องที่โปรแกรมได้จริงๆ
คอมพิวเตอร์แบบเก็บโปรแกรมจะเก็บ คำสั่ง ของงาน (โปรแกรม) ไว้ในหน่วยความจำชนิดเดียวกับ ข้อมูล ที่โปรแกรมทำงานด้วย แทนที่จะต่อสายใหม่หรือปรับแผงสวิตช์ คุณสามารถโหลดชุดคำสั่งใหม่เข้าไปในหน่วยความจำแล้วรันงานอื่นได้
ฟังดูชัดเจนในวันนี้ แต่มันเป็นการเปลี่ยนแปลงเชิงลึก:
นี่ไม่ใช่แค่เรื่องประวัติศาสตร์ แนวคิดเก็บโปรแกรมอธิบายว่าเหตุใด “ซอฟต์แวร์” จึงแยกจาก “ฮาร์ดแวร์” และทำไมการอัปเดตอุปกรณ์วันนี้จึงปลดล็อกฟีเจอร์ใหม่โดยไม่ต้องเปลี่ยนชิปภายใน
ต่อไปเราจะเดินผ่านปัญหาที่คอมพิวเตอร์ยุคแรกเผชิญ แนวทางเก็บโปรแกรมเปลี่ยนอะไร ผู้คนและเอกสารที่ร่างความคิดนี้ (รวมถึงรายงาน EDVAC ที่มีชื่อเสียง) และเหตุใดคำว่า “สถาปัตยกรรม von Neumann” จึงกลายเป็นคำที่ใช้กันแพร่หลาย
แม้ชื่อ John von Neumann จะถูกเชื่อมโยงกับการเก็บโปรแกรมอย่างมาก แต่เครดิตเป็นของทีมและยุคสมัยที่กว้างกว่านั้น นักวิจัยหลายคนกำลังมุ่งสู่แนวคิดคล้ายกันในขณะที่สร้างคอมพิวเตอร์อิเล็กทรอนิกส์เครื่องแรก บทความนี้จะรักษาบริบทนั้นไว้ เพราะความเข้าใจในความร่วมมือช่วยอธิบายว่าทำไมแนวคิดกระจายตัวเร็วและกลายเป็นรูปแบบเริ่มต้นของคอมพิวเตอร์ส่วนใหญ่ที่ตามมา
ก่อนแนวคิดเก็บโปรแกรม คอมพิวเตอร์ยุคแรกหลายเครื่องไม่ได้ “รันซอฟต์แวร์” ในความหมายปัจจุบัน พวกมันคำนวณได้เร็ว แต่การบอกให้ทำสิ่งใหม่มักหมายถึงการเปลี่ยนสภาพกายภาพของเครื่องเอง
วิธีที่ใช้กันทั่วไปคือแผงปลั๊ก สายแพตช์ และแผงสวิตช์ ผู้ปฏิบัติการจะต่อสายระหว่างช่องเสียบ ตั้งค่าช่องสวิตช์ และบางครั้งปรับหน่วยเวลาส่งสัญญาณเพื่อให้สัญญาณมาถึงในลำดับที่ถูกต้อง “โปรแกรม” ไม่ใช่ไฟล์ที่โหลด แต่เป็นผังการเดินสายชั่วคราว
การตั้งค่านี้ใช้งานได้ แต่มีต้นทุนที่ซ่อนอยู่: งานใหม่แต่ละครั้งเป็นเหมือนโครงการวิศวกรรมขนาดเล็ก หากต้องการเปลี่ยนลำดับการทำงาน (บวก คูณ เปรียบเทียบ วนซ้ำ) อาจต้องย้ายการเชื่อมต่อเป็นสิบหรือเป็นร้อยจุด สายที่ต่อผิดเพียงเส้นเดียวอาจสร้างข้อผิดพลาดที่ตรวจไม่พบได้ง่าย เพราะตรรกะกระจายอยู่ตามการเชื่อมต่อฮาร์ดแวร์แทนที่จะเขียนเป็นขั้นตอนที่อ่านได้
การตั้งค่าใหม่อาจใช้ชั่วโมงหรือวัน โดยเฉพาะเมื่อเครื่องต้องปิดไฟอย่างระมัดระวัง เดินสายใหม่ และทดสอบ นั่นหมายถึงความยืดหยุ่นจำกัด: เครื่องพวกนี้มักถูกจองให้ทำงานชนิดเดียวเป็นเวลานาน เพราะการสลับงานสร้างความวุ่นวายมาก
สมมติว่ามีเครื่องตั้งค่าเพื่อคำนวณตารางยิงปืนใหญ่—งานที่ซ้ำและมีสูตรคงที่ ถ้านักวิจัยต้องการให้เครื่องเดียวกันแก้ปัญหาอื่น เช่น คำนวณสถิติสำมะโน ประกอบด้วยลำดับการปฏิบัติและการเก็บข้อมูลระหว่างขั้นตอนที่ต่างกัน จะไม่ใช่แค่ “แก้โปรแกรมแล้วรัน” แต่ต้องออกแบบแผงปลั๊กใหม่และตรวจสอบใหม่ทั้งหมด
นี่คือโลกที่คอมพิวเตอร์แบบเก็บโปรแกรมออกแบบมาเพื่อหนีออกไป
คอมพิวเตอร์แบบเก็บโปรแกรมคือเครื่องที่คำสั่ง (โปรแกรม) อยู่ในหน่วยความจำที่เดียวกับข้อมูลที่โปรแกรมใช้ กล่าวคือ คอมพิวเตอร์ไม่แยก “สิ่งที่จะทำ” ออกจาก “สิ่งที่จะทำงานด้วย” — ทั้งสองถูกเก็บเป็นรูปแบบบิตในหน่วยความจำ
เมื่อบรรพบุรุษคอมพิวเตอร์พูดถึง หน่วยความจำ พวกเขาหมายถึงพื้นที่เก็บข้อมูลภายในที่เร็วและสามารถใช้งานโดยตรง—สิ่งที่เราเชื่อมโยงกับ RAM ในปัจจุบัน นี่คือที่ที่โปรเซสเซอร์อ่านและเขียนได้อย่างรวดเร็วในขณะรันโปรแกรม
ซึ่งต่างจากที่เก็บข้อมูลระยะยาวอย่างฮาร์ดไดรฟ์หรือ SSD ที่ดีสำหรับเก็บไฟล์เมื่อไฟดับ แต่ไม่ใช่กระดานขีดเขียนทันทีที่โปรเซสเซอร์ใช้ดึงคำสั่งต่อไปและอัปเดตผลลัพธ์ระหว่างขั้นตอน
เมื่อคำสั่งถูกเก็บในหน่วยความจำ การเปลี่ยนงานง่ายขึ้นอย่างมาก: คุณสามารถโหลดโปรแกรมใหม่ลงในหน่วยความจำแล้วรัน โดยไม่ต้องสร้าง หรือต่อสาย หรือปรับฮาร์ดแวร์อีกต่อไป เครื่องเดียวสามารถทำเงินเดือนตอนเช้า และคำนวณบอลิสติกส์ตอนบ่าย—เพราะ “วิธีทำงาน” เป็นแค่ชุดบิตที่เปลี่ยนได้
ลองนึกถึงครัวที่เก็บ สูตรอาหาร และ วัตถุดิบ ไว้ในตู้เดียวกัน พ่อครัว (โปรเซสเซอร์) จะหยิบสูตรขั้นตอนถัดไป (คำสั่ง) และวัตถุดิบ (ข้อมูล) จากตู้บ่อยๆ
อยากทำเมนูอื่นไหม? ไม่ต้องรีโนเวตครัว แค่เปลี่ยนสูตรขณะใช้เตาและอุปกรณ์เดียวกัน
John von Neumann ไม่ได้ “ประดิษฐ์คอมพิวเตอร์” เพียงคนเดียว และเขาไม่ได้คิดแนวคิดเก็บโปรแกรมขึ้นคนเดียว สิ่งที่เขาทำ—อย่างชาญฉลาด—คือช่วยเปลี่ยนแนวคิดที่มีแนวโน้มดีให้กลายเป็นการออกแบบที่อธิบายชัดและแพร่หลายจนวิศวกรและห้องทดลองอื่นนำไปต่อยอดได้
Von Neumann มีส่วนร่วมในการทำงานคอมพิวเตอร์ช่วงสงครามและหลังสงคราม ให้คำปรึกษาแก่ทีมและเน้นโครงสร้างตรรกะของการออกแบบ เขามีความสามารถในการอธิบายทางเลือกทางเทคนิคที่ซับซ้อนอย่างเป็นระเบียบ ซึ่งสำคัญเมื่อการพัฒนาคอมพิวเตอร์อิเล็กทรอนิกส์เกิดขึ้นอย่างรวดเร็วและหลายกลุ่มต่างแก้ปัญหาเดียวกันพร้อมกัน
ที่สำคัญ เขายังเขียนและเผยแพร่คำอธิบายที่มีอิทธิพลว่าคอมพิวเตอร์จะเก็บ คำสั่งโปรแกรมไว้ในหน่วยความจำเดียวกับข้อมูล กรอบความคิดที่ชัดเจนนี้ทำให้คนอื่นๆ สามารถพูดคุย สอน และทำซ้ำแนวทางได้ง่ายขึ้น
ชื่อมักติดกับคนที่คำอธิบายกลายเป็นจุดอ้างอิง ไม่จำเป็นต้องเป็นคนแรกที่คิดแนวคิด Von Neumann เขียนงานที่ถูกอ่านและอ้างอิงมาก ดังนั้นผู้อ่านต่อมาจึงเชื่อมโยงการจัดระเบียบแบบเก็บโปรแกรมกับเขา
การเรียกเช่นนี้ช่วยให้ประวัติศาสตร์ง่ายขึ้น: พูดว่า “สถาปัตยกรรม von Neumann” สะดวกกว่ารายชื่อผู้มีส่วนร่วมทั้งหมด แต่คำย่อแบบนี้อาจทำให้ภาพความเป็นจริงคลุมเครือได้
การพัฒนาอิเล็กทรอนิกส์ยุคแรกเป็นงานร่วมมือข้ามสถาบันระหว่างนักคณิตศาสตร์ วิศวกร และโปรแกรมเมอร์ แนวคิดเก็บโปรแกรมเจริญขึ้นผ่านการอภิปราย ร่างต้นฉบับ ต้นแบบ และการแก้ไขจากหลายทีม บทบาทถาวรของ von Neumann คือช่วยกลั่นกรองและเผยแพร่ความคิด—เร่งการยอมรับแนวทางมากกว่าการคิดมันขึ้นคนเดียว
EDVAC (Electronic Discrete Variable Automatic Computer) เป็นหนึ่งในโครงการคอมพิวเตอร์ช่วงหลังสงครามที่มุ่งไปไกลกว่าการสร้างเครื่องแบบ “งานเดียว” สำคัญเท่ากับงานฮาร์ดแวร์คือการตัดสินใจเขียนแนวคิดการออกแบบให้อ่านได้และแชร์ได้ ในเวลานั้นการสร้างคอมพิวเตอร์ยังเป็นงานทดลองเชิงวิศวกรรม—ความรู้กระจายอยู่ในสมุดบันทึกห้องปฏิบัติการ การประชุม และหัวของผู้เชี่ยวชาญไม่กี่คน รายงานสามารถเปลี่ยนความรู้นั้นให้กลายเป็นสิ่งที่ทีมอื่นๆ พูดคุย วิจารณ์ และนำไปใช้ได้
"First Draft of a Report on the EDVAC" (มักเรียกสั้นๆ ว่า “รายงาน EDVAC”) นำเสนอแนวคิดเก็บโปรแกรมอย่างชัดเจน: คอมพิวเตอร์ควรเก็บคำสั่งโปรแกรมในหน่วยความจำภายในชนิดเดียวกับข้อมูล หน่วยความจำนั้นไม่ใช่แค่ที่เก็บตัวเลขขณะคำนวณ แต่มันยังเก็บขั้นตอนที่บอกเครื่องว่าต้องทำอะไรต่อไป
การกรอบความคิดนี้ทำให้คอมพิวเตอร์รู้สึกน้อยลงเหมือนอุปกรณ์จุดประสงค์ตายตัว และมากขึ้นเป็นเครื่องทั่วไปที่สามารถ “เปลี่ยนงาน” ได้โดยการเปลี่ยนสิ่งที่อยู่ในหน่วยความจำ คุณไม่ต้องเดินสายใหม่เพื่อสลับจากงานหนึ่งเป็นอีกงานหนึ่ง แต่โหลดลำดับคำสั่งที่ต่างกันแทน
นอกจากแนวคิด รายงานยังช่วยมาตรฐานคำศัพท์ที่คนทั่วไปใช้พูดถึงคอมพิวเตอร์: หน่วยความจำ การควบคุม หน่วยคำนวณ และอินพุต/เอาต์พุตเป็นส่วนหน้าที่ที่ทำงานร่วมกัน การมีโมเดลและคำอธิบายที่นิยมอ่านกันไม่ได้แค่ช่วยอธิบาย EDVAC แต่ยังให้แบบคิดร่วมสำหรับสาขาที่จะสร้าง เปรียบเทียบ และปรับปรุงคอมพิวเตอร์แบบเก็บโปรแกรมต่อไป
มักมีคำถามว่า “ใครเป็นผู้คิดค้นคอมพิวเตอร์แบบเก็บโปรแกรม?” แต่ในความจริงวิศวกรรมและวิทยาศาสตร์ไม่ค่อยได้มาเป็นชื่อคนเดียว แนวคิดมักพัฒนาไปพร้อมกัน ถูกกลั่นกรองผ่านการอภิปราย และกลายเป็นข้อเท็จจริงเมื่อถูกสาธิตในฮาร์ดแวร์ที่ทำงานได้
John von Neumann ถูกเชื่อมโยงอย่างมากกับแนวคิดนี้ แต่ผลงานยุคแรกเกี่ยวข้องกับหลายคนและหลายกลุ่ม:
คอมพิวเตอร์แบบเก็บโปรแกรมไม่ใช่การค้นพบข้อเดียว มันรวม (1) กระโดดเชิงแนวคิดว่าคำสั่งสามารถอยู่ในหน่วยความจำแบบเดียวกับข้อมูล (2) วิศวกรรมที่ต้องสร้างหน่วยความจำและหน่วยควบคุมที่เชื่อถือได้ และ (3) วิธีปฏิบัติการเขียนโปรแกรมที่ทำให้การออกแบบใช้งานได้ คนต่างๆ มีส่วนในแต่ละชิ้นส่วนต่างกัน
อีกเหตุผลที่เครดิตกระจายคือ การเสนอไอเดียไม่เท่ากับการสร้างเครื่องที่ใช้งานได้จริง รายงานและการอภิปรายทำให้แนวคิดชัดเจน ต้นแบบและระบบที่ใช้งานจริงพิสูจน์ว่ามันทำได้ ประวัติศาสตร์ที่รอบคอบจะให้คุณค่ากับทั้งสองด้านโดยไม่ยัดเยียดคำตัดสินว่าใครเป็นผู้คิดค้นแรกสุด
เมื่อคนพูดว่า “สถาปัตยกรรม von Neumann” พวกเขามักหมายถึงแบบจำลองง่ายๆ ที่สอนกันแพร่หลายว่าคอมพิวเตอร์แบบเก็บโปรแกรมจัดระเบียบอย่างไร มันไม่ใช่แบรนด์หรือเครื่องประวัติศาสตร์เดียว แต่นิยมใช้เป็นฉลากสำหรับแผนพื้นฐานที่เห็นได้ในคอมพิวเตอร์หลายเครื่อง
ในระดับแนวคิด ภาพจะมีลักษณะดังนี้:
แนวคิดสำคัญคือ CPU ไม่มีที่แยกเฉพาะสำหรับ “โปรแกรม” กับ “ตัวเลข” มันดึงทุกอย่างที่ต้องการจากหน่วยความจำ
CPU รันโปรแกรมโดยทำซ้ำวงจรที่มักอธิบายว่า fetch–decode–execute:
คำอธิบายนี้เรียบง่าย แต่จับแก่นได้: โปรแกรมคือชุดคำสั่งในหน่วยความจำ และ CPU เดินตามชุดนั้นทีละคำสั่ง
การรวมคำสั่งและข้อมูลในหน่วยความจำทำให้คอมพิวเตอร์เป็น อเนกประสงค์ ในทางปฏิบัติอย่างมาก:
ดังนั้น “สถาปัตยกรรม von Neumann” จึงเข้าใจได้ดีที่สุดว่าเป็นคำย่อสำหรับแบบเก็บโปรแกรมที่มี CPU หน่วยความจำร่วมเก็บคำสั่งและข้อมูล และ I/O—แนวคิดที่ถูกเชื่อมโยงกับคำอธิบายชัดเจนของ von Neumann แม้เรื่องจริงจะซับซ้อนกว่านั้น
คนมักพูดถึง “von Neumann” และ “Harvard” เสมือนเป็นปรัชญาตรงข้าม แต่จริงๆ แล้วคือสองวิธีปฏิบัติในการจัดเก็บ คำสั่งโปรแกรม และ ข้อมูล เพื่อให้คอมพิวเตอร์ดึงสิ่งที่ต้องการได้
ในการออกแบบแบบ von Neumann คำสั่งและข้อมูลอยู่ในหน่วยความจำเดียวกันและมักวิ่งผ่านเส้นทางหลักเดียวไปยัง CPU
เรียบง่ายเชิงแนวคิด: โปรแกรมเป็นไบต์ในหน่วยความจำ ใกล้กับตัวเลข ข้อความ และรูปภาพที่มันทำงานด้วย การใช้งานทั่วไปทำได้ตรงไปตรงมา—ซอฟต์แวร์สามารถโหลด เปลี่ยน และเก็บเหมือนข้อมูลอื่นๆ
ข้อแลกเปลี่ยน: เมื่อคำสั่งและข้อมูลใช้เส้นทางร่วมกัน อาจแข่งขันเรื่องแบนด์วิดธ์กันได้ (มักเรียกว่าคอขวด)
แนวทาง Harvard แยก ที่เก็บคำสั่ง ออกจาก ที่เก็บข้อมูล และมักมีเส้นทางแยกสำหรับการดึงแต่ละอย่าง
การแยกนี้ช่วยให้ดึงคำสั่งถัดไปขณะเดียวกับอ่าน/เขียนข้อมูลได้ง่ายขึ้น เหมาะกับระบบเล็กๆ และคาดเดาได้ ตัวอย่างทั่วไปคือไมโครคอนโทรลเลอร์หลายตัวที่โค้ดโปรแกรมอยู่ในแฟลช แต่ตัวแปรอยู่ใน RAM
ซีพียูสมัยใหม่มักดูเหมือน “von Neumann” ในมุมมองของซอฟต์แวร์ (address space เดียว รูปแบบโปรแกรมเดียว) ขณะเดียวกันก็ยืมแนวคิด Harvard ภายใน เช่น แคชคำสั่งและแคชข้อมูลแยกกัน เพื่อประสิทธิภาพ ให้โปรแกรมรู้สึกเหมือนหน่วยความจำเดียว แต่ฮาร์ดแวร์สามารถดึงโค้ดและข้อมูลพร้อมกันได้ดีขึ้น
สรุป: ไม่มีผู้ชนะสากล Von Neumann เน้นความเรียบง่ายและความยืดหยุ่น Harvard เน้นการแยกและผ่านข้อมูลมากขึ้น หลายเครื่องผสมทั้งสองเพื่อลดต้นทุน พลังงาน และเพิ่มความเร็ว
คอมพิวเตอร์แบบเก็บโปรแกรมไม่เพียงแต่ รัน การคำนวณ แต่สามารถ โหลดชุดคำสั่งจากหน่วยความจำ ประมวลผล แล้วโหลดชุดคำสั่งอื่นทีหลัง การเปลี่ยนแปลงนี้ทำให้ซอฟต์แวร์ใช้ซ้ำและแชร์ได้: โปรแกรมถูกเขียนครั้งเดียว บันทึก คัดลอก ปรับปรุง และแจกจ่ายได้โดยไม่ต้องยุ่งกับฮาร์ดแวร์
เมื่อโปรแกรมอยู่ในหน่วยความจำ เครื่องทางกายภาพเดียวสามารถทำงานหลายอย่างได้เพียงเปลี่ยนคำสั่งที่อ่าน นี่คือความหมายแท้จริงของคำว่า "อเนกประสงค์": เครื่องเดียว โปรแกรมหลายตัว คอมพิวเตอร์ไม่ได้ถูกกำหนดโดยเวิร์กโฟลว์เดียว แต่กลายเป็นแพลตฟอร์ม
ตัวอย่างที่เห็นได้ชัดคือแล็ปท็อปที่คุณใช้ทั้งอีเมล เกม และสเปรดชีต แนวคิดเดิมยังคงอยู่: ฮาร์ดแวร์คงเดิม แต่โปรแกรมที่โหลดเปลี่ยนพฤติกรรมเมื่อคุณสลับแอพ
เมื่อคำสั่งถูกมองเป็นข้อมูลในหน่วยความจำ การสร้างชั้นซอฟต์แวร์ที่ช่วยให้เขียนโค้ดเป็นไปได้จริง:
เครื่องมือเหล่านี้พึ่งพาสมมุติฐานที่ว่าโปรแกรมเก็บได้ ย้ายได้ และจัดการได้เหมือนข้อมูล ซึ่งทำให้ซอฟต์แวร์กลายเป็นระบบนิเวศ ไม่ใช่ชิ้นงานที่ผูกติดกับการเดินสายของเครื่องแต่ละเครื่อง
มุมมองยาว: แนวคิดเก็บโปรแกรมนำไปสู่คอมไพเลอร์และ OS ซึ่งทำให้เครื่องมือสำหรับนักพัฒนาทันสมัยขึ้น—และวันนี้เราเห็นชั้นนามธรรมใหม่ที่ให้คุณอธิบายแอพเป็นภาษาธรรมชาติและให้เครื่องมือสร้างโค้ด ตัวอย่างเช่น Koder.ai เป็นแพลตฟอร์มที่ให้คุณสร้างเว็บ แบ็กเอนด์ หรือแอพมือถือผ่านอินเทอร์เฟซแชท โดยอาศัยโมเดลภาษาและเวิร์กโฟลว์ agent-based ช่วยให้จากความตั้งใจ (“ควรทำอะไร?”) มาสู่คำสั่งที่รันได้ (ซอร์สโค้ดที่คุณส่งออก ปรับใช้ และย้อนกลับด้วย snapshot)
ผลคือวงจรที่เกิดประโยชน์ต่อกัน: โปรแกรมเก็บไว้ได้ ทำให้มีเครื่องมือดีกว่า เครื่องมือดีกว่าทำให้โปรแกรมซับซ้อนขึ้น—เปลี่ยนคอมพิวเตอร์ให้เป็นเครื่องมืออเนกประสงค์
แนวคิดเก็บโปรแกรมทำให้คอมพิวเตอร์ยืดหยุ่น แต่ก็ชี้ให้เห็นข้อจำกัดเชิงปฏิบัติที่วิศวกรยังพูดถึง: “คอขวด von Neumann” เปรียบเสมือนการจราจรติดขัดบนทางจาก CPU (คนทำงาน) ไปยังหน่วยความจำ (คลังสินค้า)
ในการออกแบบเก็บโปรแกรมปกติ คำสั่งและข้อมูลอยู่ในหน่วยความจำเดียวกัน CPU ดึงคำสั่ง แล้วดึงข้อมูลที่ต้องใช้ แล้วเขียนผลลัพธ์กลับ—มักผ่านการเชื่อมต่อเดียวกัน ถ้าการเชื่อมต่อนั้นส่งข้อมูลไม่พอ CPU จะต้องรอ แม้ว่ามันจะคำนวณได้เร็วกว่านั้นก็ตาม
มีสองปัจจัยที่เกี่ยวข้อง:
CPU อาจทำงานเป็นพันล้านครั้งต่อวินาที แต่ถ้าหน่วยความจำไม่สามารถส่งคำสั่งและข้อมูลให้ต่อเนื่อง ประสิทธิภาพจะถูกจำกัดโดยขั้นตอนที่ช้าที่สุด: การดึงไบต์เข้าออก
นี่เป็นข้อพิจารณาทางวิศวกรรมที่แพร่หลาย และคอมพิวเตอร์สมัยใหม่ใช้เทคนิคหลายอย่างเพื่อลดผลกระทบ:
เทคนิคเหล่านี้ไม่ได้ลบเส้นทางพื้นฐานทิ้ง แต่ช่วยให้ถนนที่มีอยู่ทำงานได้ราบรื่นขึ้น—ให้ CPU ทำงานได้มากขึ้นและรอน้อยลง
แนวคิดเก็บโปรแกรมไม่ใช่ของจัดแสดงในพิพิธภัณฑ์—มันคือวิธีที่การคอมพิวติ้งประจำวันยังคงมีความยืดหยุ่น อุปกรณ์ของคุณไม่ต้อง "เดินสายใหม่" เพื่อทำสิ่งใหม่; เพียงโหลดคำสั่งต่างกันลงหน่วยความจำแล้วรัน
บนโทรศัพท์ แตะไอคอนแอพแล้วระบบปฏิบัติการจะโหลดโค้ดของแอพจากที่เก็บไปยังหน่วยความจำ จากนั้น CPU จะรันมัน บนแล็ปท็อปก็เช่นกันเมื่อคุณเปิดเบราว์เซอร์ แก้เอกสาร หรือเล่นเกม ในเซิร์ฟเวอร์ยิ่งเห็นชัด: เครื่องเดียวอาจรันงานหลายพันงานที่เปลี่ยนตลอดเวลา—คำสั่งต่างกัน ถูกโหลดและรันโดยไม่ต้องเปลี่ยนฮาร์ดแวร์
แม้ฟีเจอร์ที่เราคิดว่าเป็น “ฮาร์ดแวร์” มักนิยามโดยซอฟต์แวร์ เครือข่าย การถอดรหัสวิดีโอ การปรับปรุงภาพถ่าย และนโยบายจัดการพลังงาน มักอัปเดตผ่านเฟิร์มแวร์และซอฟต์แวร์ระบบ—คำสั่งใหม่ ฮาร์ดแวร์เดิม
ภาษาระดับสูงอย่าง Python และ JavaScript มักรันผ่านตัวแปลหรือเครื่องเสมือน แทนที่ CPU จะรันซอร์สโค้ดโดยตรง โปรแกรมของคุณจะถูกแปลงเป็นรูปแบบที่มีโครงสร้าง (bytecode หรือลำดับคำสั่งภายใน) ซึ่งเก็บในหน่วยความจำและรันทีละขั้น เช่น JVM ของ Java, .NET, WebAssembly, และเอนจิน JavaScript ในเบราว์เซอร์—ทั้งหมดอาศัยแนวคิด: คำสั่งเป็นข้อมูลที่เครื่องโหลด ย้าย และรันได้
เพราะคำสั่งเป็นเพียงข้อมูล การโจมตีมักพยายามแอบส่งโค้ดอันตรายผ่านข้อมูล—ตัวอย่างคลาสสิกคือการฉีดโค้ด การป้องกันเช่น การป้องกันหน่วยความจำ บันทึกโค้ดด้วยลายเซ็น และการแบ่งพื้นที่หน่วยความจำที่ไม่สามารถรันได้ มีไว้เพื่อป้องกันไม่ให้ข้อมูลที่ไม่เชื่อถือกลายเป็นคำสั่งที่ระบบรันได้
ทั้งหมดวนกลับสู่คำสัญญากลางของแนวคิดเก็บโปรแกรม: ความยืดหยุ่นผ่านซอฟต์แวร์—พฤติกรรมใหม่บนฮาร์ดแวร์เดิม
เมื่อดูคอมพิวเตอร์หรืออ่านสเปก คำถามเหล่านี้ช่วยให้คุณมองเห็นรูปแบบพื้นฐาน:
ถ้าคุณต้องการบทความพื้นฐานแบบนี้เพิ่มเติม ลองดูข้อความใน /blog
หมายเหตุ: ถ้าคุณทดลองวิธีสมัยใหม่ในการเปลี่ยน “คำสั่ง” ให้กลายเป็นระบบที่รันได้—ไม่ว่าจะเขียนโค้ดเองหรือใช้เครื่องมือแชทสร้างแอพ—ควรบันทึกสิ่งที่เรียนรู้ Koder.ai ยังมีโปรแกรมรับเครดิตสำหรับเนื้อหาที่เผยแพร่และการแนะนำ ซึ่งอาจเป็นวิธีปฏิบัติที่ดีในการสนับสนุนการทดลองและบทช่วยสอนเพิ่มเติม
คอมพิวเตอร์แบบเก็บโปรแกรมจะเก็บ คำสั่งโปรแกรมไว้ในหน่วยความจำภายในแบบเดียวกับที่เก็บข้อมูล ซึ่งคำสั่งเหล่านั้นคือสิ่งที่โปรแกรมจะทำ เมื่อต้องการเปลี่ยนงาน คุณเพียงโหลดชุดคำสั่งใหม่ลงในหน่วยความจำ แทนที่จะต้องเดินสายหรือปรับฮาร์ดแวร์
ก่อนแนวคิดเก็บโปรแกรม เครื่องหลายเครื่องถูก "โปรแกรม" ด้วย แผงปลั๊ก สายแพตช์ และการตั้งสวิตช์ การเปลี่ยนลำดับการดำเนินการอาจต้องใช้เวลาเป็นชั่วโมงหรือวันในการเดินสายและทดสอบ และสายที่ต่อผิดเพียงเส้นเดียวอาจก่อให้เกิดข้อผิดพลาดที่ตามหายาก
ในบริบทนี้ “หน่วยความจำ” หมายถึงพื้นที่ทำงานความเร็วสูงของคอมพิวเตอร์ (ที่ใกล้เคียงกับ RAM สมัยใหม่) ซึ่ง CPU อ่านและเขียนขณะรันโปรแกรม มันต่างจากที่เก็บข้อมูลระยะยาว (เช่น ดิสก์/SSD) ที่เก็บไฟล์เมื่อปิดเครื่องไว้
รายงาน EDVAC อธิบายแนวคิดว่าควรเก็บ คำสั่งและข้อมูลไว้ในหน่วยความจำภายในร่วมกัน พร้อมจัดวางคำศัพท์ที่ใช้อธิบายส่วนต่างๆ ของคอมพิวเตอร์ (หน่วยความจำ การควบคุม คณิตศาสตร์ อินพุต/เอาต์พุต) ความชัดเจนนี้ช่วยให้ทีมอื่นสามารถพูดคุย เปรียบเทียบ และสร้างระบบแบบเดียวกันได้เร็วขึ้น
ชื่อของ John von Neumann ติดกับแนวคิดนี้เพราะบทเขียนของเขาถูกเผยแพร่อย่างกว้างขวางและอธิบายแนวคิดได้ชัดเจน แต่เขาไม่ได้เป็นผู้คิดค้นคนเดียว แนวทางเก็บโปรแกรมพัฒนาขึ้นจากชุมชนที่กว้างขวาง—วิศวกร นักคณิตศาสตร์ และโปรแกรมเมอร์ยุคแรก—ที่มีส่วนร่วมหลากหลายด้าน
โดยทั่วไป “สถาปัตยกรรม von Neumann” หมายถึงแบบจำลองที่มี:
เป็นคำย่อที่สะดวกสำหรับอธิบายการจัดระเบียบแบบเก็บโปรแกรม ไม่ได้หมายความว่าเป็นเครื่องประวัติศาสตร์เครื่องเดียวหรือผู้คิดค้นเพียงคนเดียวดังนั้น
ในแบบสไตล์ von Neumann คำสั่งและข้อมูลอยู่ในหน่วยความจำเดียวกัน (และมักใช้เส้นทางร่วมไปยัง CPU)
ในแบบสไตล์ Harvard คำสั่งและข้อมูลถูกเก็บแยกกัน (และมักมีเส้นทางแยกต่างหาก)
ระบบสมัยใหม่หลายตัวผสมทั้งสองแนวทาง เช่น มีโมเดลหน่วยความจำเดียวในระดับซอฟต์แวร์ แต่มีแคชแยกคำสั่ง/ข้อมูลภายในฮาร์ดแวร์
“คอขวด von Neumann” คือข้อจำกัดด้านประสิทธิภาพที่เกิดจากการที่ CPU และหน่วยความจำแชร์เส้นทางเดียวกัน ทำให้ข้อมูลและคำสั่งต้องวิ่งผ่านช่องทางเดียวกันจนเกิดการคอยรอ เทคนิคลดผลกระทบได้แก่ แคช เล็กๆ ใกล้ CPU, การดึงล่วงหน้า (prefetching) และ การขนานงาน (หลายคอร์/การซ้อนการเข้าถึงหน่วยความจำกับการคำนวณ) เหล่านี้ช่วยลดการรอ แต่ไม่ได้ลบข้อจำกัดพื้นฐานทิ้งไป
เพราะโปรแกรมคือข้อมูลที่สามารถโหลดเข้าไปในหน่วยความจำได้ จึงสามารถอัปเดตพฤติกรรมโดยเปลี่ยนซอฟต์แวร์แทนการเปลี่ยนชิป นี่คือเหตุผลที่อุปกรณ์เดียวกันรันแอพต่างๆ ได้ และการอัปเดตเฟิร์มแวร์/OS สามารถเพิ่มฟีเจอร์โดยไม่ต้อง redesign ฮาร์ดแวร์
เพราะคำสั่งถูกแทนด้วยข้อมูลในหน่วยความจำ ผู้โจมตีบางครั้งพยายามแอบส่งโค้ดอันตรายผ่านข้อมูลปกติ (เช่น การฉีดโค้ด) การป้องกันเช่น การป้องกันหน่วยความจำ, การเซ็นโค้ด, และการทำให้บางพื้นที่ไม่สามารถประมวลผลได้ มีไว้เพื่อป้องกันไม่ให้ข้อมูลที่ไม่เชื่อถือกลายเป็นคำสั่งที่ระบบรันได้