ตัวอย่างของเมื่อใดที่เราจะใช้ภาษาที่แปลแล้วสำหรับภาษาที่คอมไพล์แล้ว?

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

มี (ความรู้ของฉัน) ไม่มีสิ่งเช่น "ภาษา" ตีความหรือ "ภาษา" เรียบเรียง

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

ตอนนี้ถ้าคุณมีคำถามคือเมื่อคุณใช้ตัวแปลภาษากับล่ามภาษามันจะลงไปที่โปร / คอนของคอมไพเลอร์กับล่ามและวัตถุประสงค์ของโครงการ

ตัวอย่างเช่นคุณอาจใช้ JRuby คอมไพเลอร์เพื่อการรวมที่ง่ายขึ้นกับไลบรารี java แทน MRI ruby ​​interpreter มีแนวโน้มที่จะมีเหตุผลในการใช้ MRI ruby ​​interpreter สำหรับ JRuby ฉันไม่คุ้นเคยกับภาษา แต่ไม่สามารถพูดกับสิ่งนี้ได้

ประโยชน์ที่ได้รับการขนานนามของล่าม:

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

ประโยชน์ของผู้เรียบเรียง:

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

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

ดังนั้นTL; DRนั้นโดยพื้นฐานแล้วการเปรียบเทียบพื้นฐานเป็นกรณี ๆ กันของล่ามเทียบกับคอมไพเลอร์สำหรับกรณีการใช้งานเฉพาะของคุณ

นอกจากนี้ FFI: อินเตอร์เฟซฟังก์ชั่นต่างประเทศในคำอื่น ๆ อินเตอร์เฟซสำหรับการทำงานร่วมกับภาษาอื่น ๆ อ่านเพิ่มเติมที่วิกิพีเดีย

จุดสำคัญที่นี่คือการใช้งานภาษาจำนวนมากทำไฮบริดของทั้งคู่ ภาษาที่ใช้กันมากในปัจจุบันทำงานโดยการรวบรวมโปรแกรมเป็นรูปแบบกลางเช่น bytecode แล้วดำเนินการในล่าม นี่คือวิธีการใช้ Java, C #, Python, Ruby และ Lua อันที่จริงแล้วนี่เป็นวิธีการใช้งานภาษาส่วนใหญ่ในปัจจุบัน ดังนั้นความจริงก็คือภาษาวันนี้ทั้งตีความและรวบรวมรหัสของพวกเขา ภาษาเหล่านี้บางภาษามีคอมไพเลอร์ JIT เพิ่มเติมเพื่อแปลงไบต์เป็นโค้ดเนทีฟสำหรับการดำเนินการ

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

เมื่อคุณถามเกี่ยวกับข้อดีของการตีความและรวบรวมภาษาคุณอาจหมายถึงอย่างอื่น คุณอาจถามเกี่ยวกับข้อดีของการพิมพ์แบบสแตติก / ไดนามิกข้อดีของการแจกจ่ายโปรแกรมแบบเนทีฟข้อดีของการรวบรวม JIT และ AOT เหล่านี้เป็นปัญหาทั้งหมดที่ได้รับการ conflated กับการตีความ / การรวบรวม แต่เป็นปัญหาที่แตกต่างกัน

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

ตอนนี้ก่อนที่ทุกคนจะสงสัย ... ใช่สามารถตีความ C / C ++ / C # / Java ได้และสามารถรวบรวมสคริปต์ JavaScript และ Bash ได้ ไม่ว่าจะมีล่ามหรือคอมไพเลอร์ที่ใช้งานได้สำหรับภาษาเหล่านี้เป็นคำถามอื่นหรือไม่

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

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

อย่างไรก็ตามมีบางสิ่งที่ถือได้ว่าเป็นตัวอย่างในโลกแห่งความจริง: ซอร์สโค้ด hidnig เมื่อนำไปใช้งาน ด้วยวิธีดั้งเดิมโค้ดที่คอมไพล์แล้วผู้พัฒนาได้ปรับใช้โค้ด macine ที่สามารถเรียกใช้งานได้ของโปรแกรมและข้อมูล ด้วยโค้ดที่แปลแล้วซอร์สโค้ดเองนั้นจะต้องถูกปรับใช้ซึ่งสามารถตรวจสอบและวิศวกรรมย้อนกลับได้ด้วยความพยายามน้อยกว่าสิ่งที่มันเป็นรหัสเครื่องจักรพื้นเมืองวิศวกรย้อนกลับ สิ่งหนึ่งที่ยกเว้นคือภาษาเช่น C # และ Java ซึ่งรวบรวมเป็นภาษา / bytecode ทันที (MSIL สำหรับ C # และ Java bytecode สำหรับ Java) ซึ่งได้รับการปรับใช้และเรียบเรียง "ทันเวลา" ในขณะใช้งานจริงชนิดที่ล่ามทำ อย่างไรก็ตามมี decompilers ที่เรียกว่าสำหรับ MSIL และ Java Bytecode ซึ่งสามารถสร้างซอร์สโค้ดต้นฉบับใหม่ด้วยความแม่นยำที่ค่อนข้างดีและเช่นเดียวกันกับวิศวกรรมย้อนกลับผลิตภัณฑ์ดังกล่าวมีความสำคัญมากกว่าผลิตภัณฑ์วิศวกรรมย้อนกลับซึ่งติดตั้งในเครื่องรหัสดั้งเดิม

ฉันนึกถึงสถานการณ์ต่อไปนี้เมื่อคุณใช้ภาษาที่ตีความ :

• ที่ไหนที่ไม่มีคอมไพเลอร์ที่มีอยู่เช่น Linux / Unix เชลล์สคริปต์
• สคริปต์ที่รวดเร็วและสกปรกที่แก้ปัญหาเล็กน้อย
• ภาษาที่ทำให้ง่ายต่อการเขียนหน้า HTML แบบไดนามิกและถูกตีความทั่วไปเช่น JSP (Tomcat รวบรวมไว้ในเซิร์ฟเวอร์ที่ทำงานบนเซิร์ฟเวอร์), PHP, ASP และอื่น ๆ

ฉันสามารถคิดถึงสถานการณ์ต่อไปนี้เมื่อคุณต้องการรวบรวมรหัสของคุณ:

• คุณต้องแจกจ่ายไบนารีเนื่องจากแอปของคุณเป็นแหล่งข้อมูลปิดและคุณไม่ต้องการให้รหัสต้นฉบับของคุณ
• ความเร็วเช่นระบบฝังตัวและอื่น ๆ
• คุณต้องการระดับความปลอดภัยของรหัสประเภทที่มีเพียงคอมไพเลอร์ที่มีภาษาที่พิมพ์อย่างเคร่งครัดเท่านั้นที่สามารถให้คุณได้ คอมไพเลอร์จะเปิดเผยความผิดพลาดในทุกซอกทุกมุมของซอร์สโค้ดของคุณในขณะที่การตีความของโปรแกรมที่ผิดเพี้ยนไปนั้นยังไม่ได้ค้นพบในรหัสการผลิต
• ระบบที่มีขนาดใหญ่และซับซ้อน: ไม่สามารถจินตนาการถึงระบบปฏิบัติการหรือชุดสำนักงานเป็นอะไรก็ได้นอกจากไบนารีที่คอมไพล์แล้ว
• คุณต้องการกำจัดค่าใช้จ่ายเล็ก ๆ น้อย ๆ ให้หมดและต้องการการสื่อสารที่ดีกับ Snippet ของ Assembler (ยากต่อการใช้งานทุกประเภทโดยเฉพาะกับล่าม) (จุดนี้นำมาซึ่งความคิดเห็น @delnam)

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

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

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

เมื่อรู้อย่างนี้แล้วภาษาที่ตีความจะเหมาะกับ:

1. การพัฒนาที่มีประสิทธิผล: การพัฒนาเว็บที่รวดเร็ว (PHP, Javascript) หรือการสร้างต้นแบบ
2. ข้ามแพลตฟอร์ม; ตัวอย่างเช่น JavaScript ได้รับการสนับสนุนในทุกเบราว์เซอร์ (รวมถึงเบราว์เซอร์มือถือ)

และภาษาที่คอมไพล์มีความเหมาะสมเมื่อ:

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

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

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

สิ่งนี้ใช้กับภาษาของเอเจนต์ตัวอย่างเช่นหรือสำหรับวิธีการพูด Tcl / Tk โดยปกติจะใช้

อีกเหตุผลที่เป็นไปได้สำหรับการผสานกับการตีความคือเมื่อมีการใช้ตัวแปลภาษาสำหรับการบู๊ตตัวเองหรือภาษาที่ซับซ้อนกว่าระดับสูงกว่าและความเรียบง่ายนั้นสำคัญกว่าประสิทธิภาพของกระบวนการบูทสแตรป

สำหรับเกือบทุกกรณีที่เป็นไปได้อื่น ๆ การรวบรวม (หรือวิธีไฮบริด) เป็นแบบที่ดีกว่า