ทำไมคอมไพเลอร์ตัวแรกเขียนหน้าล่ามตัวแรก

72

คอมไพเลอร์ตัวแรกเขียนโดย Grace Hopper ในปี 1952 ในขณะที่ล่าม Lisp ถูกเขียนในปี 1958 โดย Steve Russell นักศึกษา John McCarthy การเขียนคอมไพเลอร์ดูเหมือนว่าเป็นปัญหาที่ยากกว่าล่าม ถ้าเป็นเช่นนั้นทำไมคอมไพเลอร์ตัวแรกเขียนหกปีก่อนล่ามคนแรก?

history compiler interpreters

— anguyen
แหล่งที่มา

67

เพราะมีความต้องการคอมไพเลอร์มากกว่าล่ามในเวลา

— วงล้อประหลาด

23

เพื่อรวบรวมล่ามคนแรก? : P (มีเพียงลิ้นบางส่วนในแก้มล่ามมีความซับซ้อน (มากกว่าคอมไพเลอร์ธรรมดา) และมันก็น่ารังเกียจที่จะเขียนหนึ่งที่มีประสิทธิภาพในรหัสเครื่อง)

— Vality

4

หากคุณใช้คำสั่งในการดำเนินการ CPU ของคุณเป็นการตีความคำเหล่านั้นซึ่งเป็นวิธีที่ฉันเห็น (ใช้งานผ่านฮาร์ดแวร์) ดังนั้นการอ้างว่าล่ามตัวแรกถูกเขียนขึ้นหลังจากคอมไพเลอร์ตัวแรกไม่มี Btw ฉันรู้ว่านี่ไม่ได้ช่วยคำถาม / คำตอบ มันเป็นเพียงการแสดงความคิดเห็นที่น่าสนใจในมุมมองที่แตกต่าง

— Pedro Henrique A. Oliveira

11

McCarthy ไม่ได้เขียนล่าม LISP McCarthy คิดค้นการคำนวณทางคณิตศาสตร์ Steve Russell หนึ่งในนักเรียนใน MIT AI Lab ในเวลานั้นได้ตระหนักว่าเขาสามารถเขียนล่ามเพื่อดำเนินการเที่ยวบินของ McCarthy แห่งจินตนาการและที่เหลือเป็นประวัติศาสตร์

— John R. Strohm

5

ในความเป็นจริงฉันได้ยินมาว่า McCarthy เชื่อว่า LISP ไม่สามารถนำไปใช้งานได้ มันเป็นรัสเซลที่ตระหนักว่าฟังก์ชั่นสากลแมคคาร์จากคู่มือ LISP ก) เป็นล่ามและ b) เป็น implementable

— Jörg W Mittag

97

การเขียนคอมไพเลอร์ดูเหมือนว่าเป็นปัญหาที่ยากกว่าล่าม

อาจเป็นจริงในวันนี้ แต่ฉันจะเถียงว่าไม่ใช่เมื่อ 60 ปีก่อน เหตุผลสองสามประการ:

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

— ร่าเริง
แหล่งที่มา

65

และหากไม่มีคอมไพเลอร์คุณจะต้องเขียนล่ามในห้องประชุม

— เฟืองวงล้อประหลาด

34

คอมไพเลอร์แรกที่ผู้คน (เมื่อผู้คนเป็นล่ามเราไม่ต้องการคอมพิวเตอร์) จากนั้นบางคนต้องคิดว่าจะเขียนคอมไพเลอร์ในภาษาที่รวบรวม (มีเพียงภาษาเดียวที่พวกเขามี แต่เป็นเวลาที่รวบรวมมนุษย์ของฉัน)

— ctrl-alt-delor

1

ที่จริงแล้ว .... ฉันเพิ่งอ่านว่าคอมพิวเตอร์แนะนำ Apollo ที่ใช้ในเที่ยวบิน Moon 60s มีล่าม: รายการ wiki "... ล่ามให้คำแนะนำมากกว่า AGC สนับสนุนอย่างเป็นธรรมชาติ ... " ฉันคิดว่า "interpreter" นี้คือ เหมือน ล่าม"Sweet 16" ที่ฝังอยู่ในคอมพิวเตอร์ Apple II เก่ากว่า LISP

— Calphool

6

@ ratchetfreak และมันก็เป็น เช่นเดียวกับคอมไพเลอร์ตัวแรก

— RBarryYoung

3

@ Richard: เมื่อผู้คนเป็นล่าม / เครื่องคิดเลขชื่องานของพวกเขาถูกเรียกว่า "คอมพิวเตอร์" ดังนั้นเมื่อผู้คนเป็นล่ามพวกเขาจึงเป็นคอมพิวเตอร์จริงๆ โครงการแมนฮัตตันใช้ "คอมพิวเตอร์" นับพัน (ชื่องานจริง ๆ ) ซึ่งนักฟิสิกส์นิวเคลียร์ส่งการคำนวณทางไปรษณีย์เพื่อดำเนินการ ที่จริงแล้วโครงการนี้ยังใช้นักคณิตศาสตร์ที่แยกการคำนวณจากวิศวกรที่กำหนดการคำนวณจากทฤษฎีของนักฟิสิกส์เพื่อส่ง "คอมพิวเตอร์"

— slebetman

42

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

ในขณะที่ส่วนติดต่อผู้ใช้ที่ดีกว่าถูก จำกัด เป็นหลักในการชกต่อยบัตรและเครื่องพิมพ์โทรพิมพ์ ในปีพ. ศ. 2504 ระบบ SAGEได้กลายเป็นจอแสดงผลหลอด Cathode-Ray (CRT)เครื่องแรกบนคอมพิวเตอร์ ดังนั้นธรรมชาติของการโต้ตอบของล่ามจึงไม่เป็นที่นิยมหรือเป็นธรรมชาติจนกระทั่งในภายหลัง

คอมพิวเตอร์จำนวนมากในปี 1950 ใช้สวิตช์แผงด้านหน้าเพื่อโหลดคำสั่งและผลลัพธ์เป็นเพียงแถวของหลอดไฟ / ไฟ LED และผู้เล่นมือสมัครเล่นก็ใช้สวิตช์แผงด้านหน้าและหลอด LED ในปี 1970 บางทีคุณอาจจะคุ้นเคยกับการที่น่าอับอายAltair 8800

ข้อ จำกัด อื่น ๆ ของฮาร์ดแวร์ทำให้ล่ามไม่สามารถทำได้ มีหน่วยความจำหลัก (เช่น RAM) ในคอมพิวเตอร์ในช่วงปี 1950 มี จำกัด อย่างมาก ก่อนหน้าวงจรรวมเซมิคอนดักเตอร์ (ซึ่งไม่ได้มาจนถึงปี 1958) หน่วยความจำถูก จำกัด ไว้ที่หน่วยความจำแกนแม่เหล็กหรือหน่วยความจำบรรทัดล่าช้าซึ่งวัดเป็นบิตหรือคำโดยไม่มีคำนำหน้า เมื่อรวมกับความช้าของหน่วยความจำสำรอง (เช่นดิสก์หรือเทป) จะถือว่าสิ้นเปลืองหากไม่สามารถทำได้ที่จะมีหน่วยความจำส่วนใหญ่ที่ใช้สำหรับล่ามก่อนที่โปรแกรมจะถูกแปล

ข้อ จำกัด ของหน่วยความจำยังคงเป็นปัจจัยสำคัญเมื่อทีมนำโดย John Backus ที่ IBM สร้างคอมไพเลอร์ FORTRAN ในปี 1954-57 นี้คอมไพเลอร์ที่เป็นนวัตกรรมใหม่ที่ประสบความสำเร็จเพียงเพราะมันเป็นคอมไพเลอร์เพิ่มประสิทธิภาพ

คอมพิวเตอร์ส่วนใหญ่ในปี 1950 แทบจะไม่ได้มีระบบปฏิบัติการใด ๆ เลยคุณลักษณะที่ทันสมัยเช่นการเชื่อมโยงแบบไดนามิกและการจัดการหน่วยความจำเสมือนดังนั้นแนวคิดของล่ามจึงรุนแรงเกินไปและใช้ไม่ได้ในเวลานั้น

ภาคผนวก

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

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

จากมุมมองของวิทยาการคอมพิวเตอร์คอมไพเลอร์และล่ามเป็นทั้งนักแปลและมีความซับซ้อนในการใช้งาน

— mctylr
แหล่งที่มา

คอมพิวเตอร์ใช้โทรพิมพ์ก่อนที่จะมีการแชร์เวลาหรือไม่ ฉันคาดว่าพวกเขาจะใช้เครื่องพิมพ์บรรทัดหรือแกนม้วนเทป ไม่เช่นนั้นคอมพิวเตอร์จะต้องรอ 1-8 วินาทีหลังจากแต่ละบรรทัดของข้อความจะแสดงถึง 1-8 วินาทีที่คอมพิวเตอร์สามารถเป็นได้ แต่ไม่ได้ทำสิ่งที่มีประโยชน์

— supercat

2

@supercat - ใช่ใช้โทรพิมพ์ แต่พวกเขาก็ยังห่างไกลจาก "โต้ตอบ" คอมพิวเตอร์เครื่องแรกที่ฉันตั้งโปรแกรมมีหน่วยความจำประกอบด้วยคำ 18 บิต - 1K ของพวกเขา หน่วยความจำตัวเองเป็นดรัมหมุนดังนั้นเมื่อคุณเปิดคอมพิวเตอร์คุณต้องรอจนกระทั่งหน่วยความจำมาถึงความเร็ว มันมีโทรพิมพ์ติดอยู่และคุณสามารถ A) อ่านตัวอักษรที่พิมพ์จากคีย์บอร์ดหรืออ่านโดยเครื่องอ่านเทปกระดาษ (จากมุมมองของคอมพิวเตอร์ทั้งคู่เหมือนกัน) B) เขียนตัวอักษรไปยังเครื่องพิมพ์ " "ของโทรพิมพ์ Ah, great day - GREAT days .. ! GRUEL ของฉันอบอุ่นใช่หรือไม่? :-)

— Bob Jarvis

@BobJarvis: ปีไหนจะเป็นเช่นนั้น?

— supercat

1

@supercat - 1973 - แต่คอมพิวเตอร์ที่เป็นปัญหา (EDP-18 โดยผลิตภัณฑ์การศึกษาข้อมูล) เป็นผู้สูงอายุค่อนข้างแล้ว ถึงกระนั้นก็เป็นสิ่งที่เรามี (และมีคอมพิวเตอร์เครื่องใดก็ได้ที่จะยุ่งกับในโรงเรียนมัธยมในช่วงต้นยุคกลาง 70- เป็นเรื่องแปลก) ดังนั้นเราจึงคิดว่ามันน่าอัศจรรย์ :-)

— Bob Jarvis

2

นี่เป็นคำตอบที่ดีกว่าและสมบูรณ์กว่าคำตอบที่ยอมรับ

— Jim Garrison

12

ภาษาการเขียนโปรแกรมแรกนั้นค่อนข้างง่าย (ไม่มีการเรียกซ้ำ) และใกล้กับสถาปัตยกรรมของเครื่องซึ่งมันง่ายมาก แปลแล้วก็เป็นกระบวนการที่ซับซ้อน

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

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

ความเป็นจริงความเรียบง่ายที่จำเป็นของคอมไพเลอร์นั้นคอมไพเลอร์ไม่ได้ดีมาก (การปรับโค้ดให้ดียังอยู่ในช่วงวัยเด็กเมื่อพิจารณาเลย) รหัสเครื่องที่เขียนด้วยมือมีอย่างน้อยก็จนถึงช่วงปลายทศวรรษที่หกในบางแห่งชื่อเสียงของการมีประสิทธิภาพมากกว่ารหัสคอมไพเลอร์ที่สร้างขึ้นอย่างมีนัยสำคัญ แม้กระทั่งแนวคิดของอัตราส่วนการขยายโค้ดที่เปรียบเทียบขนาดของรหัสที่คอมไพล์กับงานของโปรแกรมเมอร์ที่ดีมาก มันมักจะมากกว่า 1 สำหรับคอมไพเลอร์ส่วนใหญ่ (ทั้งหมด?) ซึ่งหมายถึงโปรแกรมที่ช้ากว่าและที่สำคัญกว่านั้นคือโปรแกรมขนาดใหญ่ที่ต้องการหน่วยความจำมากขึ้น นี่ยังเป็นปัญหาในอายุหกสิบเศษ

ความสนใจของคอมไพเลอร์คือความสะดวกในการเขียนโปรแกรมโดยเฉพาะอย่างยิ่งสำหรับผู้ใช้ที่ไม่ได้ใช้ผู้เชี่ยวชาญเช่นนักวิทยาศาสตร์ในด้านต่าง ๆ ความสนใจนี้ไม่ใช่ประสิทธิภาพของรหัส แต่ถึงกระนั้นเวลาโปรแกรมเมอร์ก็ถือว่าเป็นทรัพยากรราคาถูก ค่าใช้จ่ายอยู่ในช่วงเวลาคอมพิวเตอร์จนถึงปี 2518-2523 เมื่อราคาเปลี่ยนจากฮาร์ดแวร์มาเป็นซอฟต์แวร์ ซึ่งหมายความว่าแม้คอมไพเลอร์ไม่ได้ดำเนินการอย่างจริงจังโดยผู้เชี่ยวชาญบาง

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

กรณีของ Lispนั้นพิเศษมากเพราะเป็นภาษาที่ง่ายมากซึ่งทำให้เป็นไปได้ (และคอมพิวเตอร์ก็ใหญ่ขึ้นใน 58) ที่สำคัญกว่านั้นLisp interpreter เป็นข้อพิสูจน์ของแนวคิดเกี่ยวกับความชัดเจนในตัวเองของ Lisp ( meta-circularity ) ซึ่งเป็นอิสระจากปัญหาการใช้งานใด ๆ

ความสำเร็จที่กระเพื่อมนั้นเกิดจากความจริงที่ว่าความชัดเจนของตนเองนี้ทำให้มันเป็นแบบทดสอบที่ยอดเยี่ยมสำหรับการศึกษาโครงสร้างการเขียนโปรแกรมและการออกแบบภาษาใหม่ (และเพื่อความสะดวกในการคำนวณสัญลักษณ์)

— Babou
แหล่งที่มา

3

ฉันวิธีการที่เป็นตัวหนา

— Pharap

@Phap เป็นสไตล์ที่ไม่เหมาะสมเหรอ? จุดประสงค์ของฉันคือการทำให้ข้อมูลที่สำคัญง่ายต่อการค้นหาในขณะที่ช่วยให้มีสไตล์ที่เป็นอิสระกว่าการแจกแจงข้อเท็จจริงแบบง่าย ๆ ฉันต้องยอมรับว่ามันดูไม่ค่อยมีประสิทธิภาพสำหรับเว็บไซต์ SE นี้

— babou

@ anonymous-downvoter Downvoting โดยไม่มีความคิดเห็นอธิบายแสดงให้เห็นว่าบางคนอาจจะโง่ อย่างไรก็ตามมันไม่ได้บอกว่าใคร

— babou

4

ฉันไม่เห็นด้วยกับหลักฐานของคำถาม

Adm. คอมไพเลอร์ตัวแรกของ Hopper (A-0) เป็นเหมือนลิงเกอร์หรือภาษามาโคร เธอเก็บรูทีนย่อยไว้บนเทป (แต่ละอันกำหนดหมายเลขไว้) และโปรแกรมของเธอจะถูกเขียนเป็นรายการของรูทีนย่อยและอาร์กิวเมนต์ คอมไพเลอร์จะคัดลอกรูทีนย่อยที่ร้องขอจากเทปและสั่งซื้อใหม่ลงในโปรแกรมที่สมบูรณ์

เธอใช้คำว่า "รวบรวม" ในแง่เดียวกับที่รวบรวมกวีนิพนธ์บทกวี: รวบรวมรายการต่าง ๆ เข้าด้วยกันเป็นเล่มเดียว

คอมไพเลอร์ตัวแรกนั้นไม่มี lexer หรือ parser เท่าที่ฉันสามารถบอกได้ซึ่งทำให้มันเป็นบรรพบุรุษที่อยู่ห่างไกลของคอมไพเลอร์สมัยใหม่ หลังจากนั้นเธอก็สร้างคอมไพเลอร์ตัวอื่น (B-0 หรือที่รู้จักว่า FLOW-MATIC) โดยมีเป้าหมายที่จะมีรูปแบบคล้ายกับภาษาอังกฤษมากขึ้น

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

คำตอบที่ดีกว่าที่มีการอ้างอิงที่นี่: https://stackoverflow.com/a/7719098/122763

— Mark E. Haase
แหล่งที่มา

3

อีกส่วนหนึ่งของสมการคือคอมไพเลอร์เป็นขั้นตอนที่เป็นนามธรรมเหนือผู้ประกอบ ก่อนอื่นเรามีรหัสเครื่องที่เขียนโค้ดยาก "เรา" เป็นผู้รวบรวม ทุกการกระโดดและการหักล้าง ฯลฯ ถูกคำนวณด้วยมือเป็นฐานสิบหก (หรือฐานแปด) แล้วเจาะลงในเทปกระดาษหรือการ์ด ดังนั้นเมื่อผู้ชุมนุมเข้ามาในที่เกิดเหตุมันเป็นการประหยัดเวลาครั้งใหญ่ ขั้นตอนต่อไปคือแอสเซมเบลอร์แมโคร ที่ให้ความสามารถในการเขียนแมโครที่จะขยายเป็นชุดคำสั่งเครื่อง ดังนั้น Fortran และ Cobol จึงก้าวไปข้างหน้าอย่างมาก การขาดทรัพยากร (หน่วยความจำหน่วยความจำและวงจรซีพียู) หมายความว่าล่ามวัตถุประสงค์ทั่วไปต้องรอให้เทคโนโลยีเติบโต ล่ามยุคแรกส่วนใหญ่เป็นเอ็นจิ้นแบบไบต์ - โค้ด (เช่น Java หรือ CLR ของวันนี้ แต่มีความสามารถน้อยกว่ามาก) UCSD Pascal เป็นภาษาที่นิยมมากและรวดเร็ว MS Basic เป็นเอ็นจิ้นรหัสไบต์ภายใต้ประทุน

ในแง่ของค่าใช้จ่ายในการเรียนการสอนนั้นขึ้นอยู่กับโปรเซสเซอร์ที่กำลังทำงานอยู่ทั้งหมด อุตสาหกรรมผ่านความวุ่นวาย RISC ใหญ่และ CISC ชั่วครู่หนึ่ง ฉันเองเขียนแอสเซมเบลอร์สำหรับ IBM, Data General, Motorola, Intel (เมื่อปรากฏขึ้น), TI และอื่น ๆ อีกมากมาย มีความแตกต่างอย่างมีนัยสำคัญพอสมควรในชุดคำสั่งการลงทะเบียนและอื่น ๆ ที่จะมีผลต่อสิ่งที่จำเป็นในการ "ตีความ" p-code

ตามการอ้างอิงเวลาฉันเริ่มเขียนโปรแกรมใน บริษัท โทรศัพท์ประมาณ 1972

— บิลพี่น้อง
แหล่งที่มา

2

หากคุณไม่ได้เก็บทุกอย่างไว้ในหน่วยความจำรหัสที่คอมไพล์จะมีความรวดเร็วมากกว่า อย่าลืมว่าในครั้งนี้มีการรวมฟังก์ชั่นเข้ากับโค้ดที่คอมไพล์แล้ว หากคุณไม่ได้รวบรวมคุณไม่ทราบว่าฟังก์ชั่นที่คุณต้องการคืออะไร ดังนั้นคุณกำลังเรียกใช้ฟังก์ชั่นจาก ... โอ้ไม่ได้มาจากดิสก์เราอยู่ในช่วง 50 ต้น ๆ แต่มาจากการ์ด! ในรันไทม์!

แน่นอนว่ามันเป็นไปได้ที่จะหาวิธีแก้ไขปัญหา แต่พวกเขายังไม่พบเพราะภาษานั้นง่ายมากและไม่ไกลจากรหัสเครื่อง และการรวบรวมนั้นง่ายและเพียงพอ

— Gangnus
แหล่งที่มา

1

ก่อนที่จะเขียนคอมไพเลอร์ตัวแรกผู้เขียนโค้ดแอสเซมเบลอร์ซึ่งมีความก้าวหน้าอย่างมากเมื่อเทียบกับรหัสไบนารี่ธรรมดา ในเวลานั้นมีข้อโต้แย้งที่สำคัญว่าโค้ดที่คอมไพล์โดยคอมไพเลอร์จะมีประสิทธิภาพน้อยกว่าโค้ดแอสเซมเบลอร์ - ในเวลานั้นความสัมพันธ์ของ (ราคาคอมพิวเตอร์) กับ (ราคาโปรแกรมเมอร์) แตกต่างกันมากในทุกวันนี้ ดังนั้นจึงมีความต้านทานอย่างมากต่อคอมไพเลอร์จากมุมมองนั้น

แต่คอมไพเลอร์นั้นมีประสิทธิภาพมากกว่าล่าม หากคุณแนะนำให้เขียนล่าม ณ เวลานั้นผู้คนจะคิดว่าคุณบ้า คุณลองนึกภาพการซื้อคอมพิวเตอร์หนึ่งล้านดอลลาร์แล้วเสีย 90% ของอำนาจในการแปลรหัส

— gnasher729
แหล่งที่มา

ฉันไม่รู้มากเกี่ยวกับคอมพิวเตอร์ในปี 1950 แต่อย่างน้อยสำหรับเครื่อง von Neumann อย่างง่าย ๆ ของทศวรรษต่อมาค่าใช้จ่ายของล่ามจะเป็นสองถึงห้าคำแนะนำ อาร์กิวเมนต์เพิ่มเติม หากคุณทำให้ชุดคำสั่งที่ตีความถูกต้องอยู่ในระดับสูงเพียงพอ (ดังนั้นคุณจึงรันคำสั่งเครื่องหลายคำสั่งต่อล่าม) สิ่งนี้จะน้อยกว่า 90% และอาจเป็นที่ยอมรับได้ ดูเพิ่มเติม: ออกมา

3

ก่อนที่จะเขียนคอมไพเลอร์ตัวแรกโปรแกรมส่วนใหญ่จะถูกเขียนด้วยรหัสเครื่องจริงไม่ใช่ภาษาแอสเซมบลี (ตัวช่วยจำรหัสสหกรณ์)

— mctylr

2

@delnan ระบบเหล่านั้นทำงานด้วยนาฬิกาใน kiloHertz ดังนั้นการลดประสิทธิภาพลง 3-5 เท่าน่าจะเป็นความแตกต่างระหว่างโปรแกรมที่เสร็จสมบูรณ์ก่อนที่ระบบจะประสบความสำเร็จก่อนที่ระบบจะล้มเหลวเนื่องจากฮาร์ดแวร์ขัดข้อง (เช่นหลอดสูญญากาศเป่า) หรือไม่ ความล้มเหลวของฮาร์ดแวร์เกิดขึ้นทุกวันในปี 1950 ถ้าฉันจำได้ถูกต้อง

— mctylr

delnan: แสดงล่ามที่สามารถตีความได้ด้วยค่าใช้จ่ายห้าคำสั่ง และ Forth ไม่ใช่ภาษาที่ถูกตีความมันเป็นสิ่งที่น่ารังเกียจ :-) ขออภัยฉันหมายถึงภาษาที่มีเธรด บางอย่างเช่น BASIC ใช้คำสั่ง gazillions เพื่อตีความหนึ่งคำสั่ง

— gnasher729

@ ผู้ประกาศ: ในปี 1974 ฉันได้สร้างล่าม BASIC ประสิทธิภาพสูงสำหรับ Keronix (อะแฮ่ม, Data General Nova clones) ที่ใช้รหัส P-byte เพื่อเข้ารหัสคำสั่ง BASIC ใช้เวลาประมาณ 25-50 คำสั่งในการ "ตีความ" pCode, 10 คำสั่งสำหรับการดึงข้อมูลไบต์ (ฉันทำโทเค็นหนึ่งหลังในปี 1969 ซึ่งใช้เวลามากกว่าเพราะต้องมีการแยกวิเคราะห์การแสดงออกอีกครั้ง) แต่มันไม่ใช่ "gazillions" และไม่ใช่

— Ira Baxter

1

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

โปรดทราบว่าเป้าหมายของคอมไพเลอร์ก่อนหน้านี้ไม่ใช่การสร้างไฟล์ภาษาแอสเซมบลีหรือรหัสวัตถุบนดิสก์ แต่เพื่อจบโค้ดใน RAM ที่พร้อมใช้งาน นี่เป็นเรื่องง่ายที่น่าประหลาดใจจริง ๆ เมื่อไม่มีระบบปฏิบัติการที่จะเข้าไป คอมไพเลอร์สามารถสร้างรหัสเริ่มต้นที่ปลายด้านหนึ่งของหน่วยความจำและจัดสรรตัวแปรและเป้าหมายสาขาเริ่มต้นที่อื่น ๆ หากคำสั่งถูกทำเครื่องหมายด้วยป้ายกำกับ "1234" คอมไพเลอร์จะเก็บไว้ในตัวแปรที่เรียกว่า "1234" คำสั่งเพื่อข้ามไปยังที่อยู่การสร้างรหัสปัจจุบันสร้างตัวแปรนั้นหากไม่มีอยู่ คำสั่ง "goto 1234" จะสร้างตัวแปร "1234" หากไม่มีอยู่จากนั้นข้ามไปยังตัวแปรนั้น [ซึ่งหวังว่าจะมีการข้ามไปยังตำแหน่งที่เหมาะสมซึ่งจัดเก็บไว้ก่อนที่คำสั่งนั้นจะเรียกใช้งาน]gotoป้ายกำกับที่ยังไม่ได้รับการกำหนดเนื่องจากมันรู้ว่าเมื่อใดที่gotoคอมไพล์ที่จะข้ามไปยังตัวแปร นั่นอาจไม่ใช่วิธีที่มีประสิทธิภาพที่สุดในการสร้างรหัส แต่ก็เพียงพอสำหรับขนาดของโปรแกรมที่คอมพิวเตอร์คาดว่าจะจัดการ

— SuperCat
แหล่งที่มา

1

ดิสก์? ummmm ... ไม่มี เทป. เทปใหญ่ช้าและหมุน และอีกมากมาย ฉันจำได้ว่าจะไปบรรยายที่เกรซเมอเรย์ฮอปเปอร์ (น่าสนใจสำหรับฉันเป็นทวีคูณเพราะฉันเป็นคนวิเคราะห์ระบบหลักและเป็นคนกลางในการปลดกองทัพเรือ ROTC ที่วิทยาเขต เธอเล่าเรื่องราวที่เธอพูดเธอคิดขึ้นมาด้วยความคิดในการเขียนส่วนที่ไม่ได้ใช้ของโปรแกรมเป็นเทป - เธอเรียกมันว่า "การใช้ที่เก็บข้อมูลเสริม" "แต่" เธอพูดว่า "ความคิดนั้นยังไม่เกิดขึ้นจนกว่า IBM จะทำสิ่งเดียวกันและเรียกมันว่า Virtual Memory" CAPT Hopper ไม่ชอบ IBM ... :-)

— Bob Jarvis

@ BobJarvis: ฉันไม่ได้พิจารณาเรื่องนั้น แต่การออกแบบ one-pass ทั่วไปแบบเดียวกับที่ใช้ในการคอมไพล์โค้ดพร้อมใช้ที่รันกับ RAM สามารถทำงานได้ดีกับเทปไดรฟ์ เอาต์พุตจากคอมไพเลอร์จะไปที่เทปจากนั้นเทปจะถูกกรอกซ้ำและอ่านไปยังที่อยู่หน่วยความจำตามลำดับและรันโดยตรงโดยไม่จำเป็นต้องมีส่วนใด ๆ ของคอมไพเลอร์ในหน่วยความจำในเวลาเดียวกัน

— supercat

0

เพราะล่ามต้องการคอมไพเลอร์เพื่อให้สามารถทำงานได้

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

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

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

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

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

— The Spooniest
แหล่งที่มา

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

— supercat

@supercat: ฉันไม่รู้ว่าตัวแปลพื้นฐานที่คุณพูดถึงนั้นถูกสร้างขึ้นมาอย่างไร แต่ฉันไม่ได้พูดถึงคอมไพเลอร์ที่ใช้ในการผลิตล่าม ฉันกำลังพูดถึงคอมไพเลอร์ที่เป็นส่วนหนึ่งของล่าม ในฐานะที่เป็นส่วนหนึ่งของรหัสแอปเปิ้ล] [ล่ามพื้นฐานต้องการวิธีการในการอ่านไฟล์ข้อความที่มีรหัส BASIC และสร้างต้นไม้ไวยากรณ์จากข้อความนั้นซึ่งมันจะดำเนินการ รหัสที่ทำนี่คือคอมไพเลอร์; มันไม่ได้สร้างรหัสเครื่อง แต่ก็ยังคงทำงานการอ่านในรหัสและแปลเป็นรูปแบบอื่น

— The Spooniest

ล่ามพื้นฐานของไมโครคอมพิวเตอร์โดยทั่วไปไม่ได้สร้างอะไรเลยแม้แต่คล้ายกับต้นไม้ไวยากรณ์ ฉันไม่คุ้นเคยกับล่าม Apple BASIC ดั้งเดิม (เรียกว่า "จำนวนเต็ม BASIC") แต่ล่ามพื้นฐานถูกนำมาใช้โดย Microsoft สำหรับ Apple ("Applesoft BASIC"), พลเรือจัตวาและ บริษัท อื่น ๆ ที่จัดเก็บข้อความโปรแกรมเป็น - ยกเว้นสองสิ่ง : (1) แต่ละบรรทัดนำหน้าด้วยหมายเลขบรรทัด 16 บิตและที่อยู่ 16 บิตของบรรทัดถัดไปและตามด้วยศูนย์ไบต์; (2) คำหลักแต่ละคำถูกแทนที่ด้วยไบต์เดียวที่มีชุดบิตสูง อื่น ๆ กว่าที่แสดงออกถูกแยกวิเคราะห์ ...

— SuperCat

... ตัวละครโดยตัวละครจากซ้ายไปขวา; คำสั่งเช่น A = 1234 "จะแปลงตัวเลข 1, 2, 3 และ 4 เป็นตัวเลขทศนิยมในขณะใช้งาน

— supercat

@supercat: นั่นฟังดูใกล้กับ bytecode มากกว่าแผนผังต้นไม้ดังนั้นฉันจึงมีข้อผิดพลาดในเรื่องนั้น แต่ประเด็นหลักยังคงอยู่: pseudo-bytecode จะต้องสร้างจากข้อความและรหัสที่ทำเช่นนี้เป็นคอมไพเลอร์

— The Spooniest

-1

อีกปัจจัยหนึ่ง: เมื่อคอมไพเลอร์ตัวแรกเขียนต้นทุนของเวลาเครื่องสูงกว่าตอนนี้มาก ล่ามใช้เวลาของเครื่องมากขึ้น

— Loren Pechtel
แหล่งที่มา