ทำไมคอมไพเลอร์โฮสติ้งด้วยตนเองจึงถือว่าเป็นข้อพระคัมภีร์สำหรับภาษาใหม่?

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

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

การใช้ความพยายามในสิ่งที่จะให้ผลลัพธ์ที่ดีกว่านั้นจะไม่เหมาะสมหรือไม่

เช่นอะไร?

สิ่งที่ดีเกี่ยวกับคอมไพเลอร์คือพวกเขาไม่มีการพึ่งพามากนัก สิ่งนี้ทำให้ผู้สมัครที่ดีสำหรับภาษาใหม่ที่น่าจะยังไม่มีห้องสมุดมาตรฐานขนาดใหญ่หรือมีความหลากหลาย

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

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

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

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

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

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

แต่นั่นไม่ได้หมายความว่ามันเป็นเพียงมูลค่า noting ก้าว มีฟังก์ชั่นที่คอมไพเลอร์ไม่ได้ใช้เช่นการรวมฐานข้อมูลอินเตอร์เฟสแบบกราฟิกเครือข่าย ฯลฯ

สตีฟ Yegge เขียนโพสต์บล็อกที่ดีที่ค่อนข้างอ้อมอยู่นี้

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

มีเหตุผลหลายอย่างที่ Knuth ได้ทำงานเกี่ยวกับ "Art of Computer Programming" (และไม่มีที่สิ้นสุด) เป็นเวลาหลายสิบปีแม้ว่ามันจะเริ่มเป็นตำราเรียนภาษาคอมไพเลอร์ก็ตาม ในทำนองเดียวกับที่ Carl Sagan กล่าวว่า "หากคุณต้องการสร้างแอปเปิ้ลพายจากศูนย์คุณต้องประดิษฐ์เอกภพก่อน" ถ้าคุณต้องการเขียนคอมไพเลอร์คุณต้องจัดการกับวิทยาศาสตร์คอมพิวเตอร์เกือบทุกด้าน

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

จุดใหญ่อันดับที่ 2:จาก 30,000 ฟุตปัญหาที่น่าประหลาดใจดูเหมือนว่าคอมไพเลอร์

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

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

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

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

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

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

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

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

แต่คุณไม่ต้องการเขียนคอมไพเลอร์ในภาษา Y เกินความจำเป็นดังนั้นในการเริ่มต้นคุณจะใช้เพียงบางส่วนของภาษา - กำจัดการสร้างซ้ำซ้อน ในกรณีของภาษาประเภท 'C' ที่ในขณะที่แต่ไม่มีสำหรับหรือทำในขณะที่ หากแต่ไม่มีกรณีใดหรือสหกรณ์ระดับอุดมศึกษา ไม่มีโครงสร้างหรือสหภาพหรือการแจกแจง เป็นต้นสิ่งที่คุณเหลือไว้มีเพียงภาษาที่เพียงพอในการเขียนตัวแยกวิเคราะห์และตัวสร้างโค้ดพื้นฐานสำหรับภาษา X จากนั้นตรวจสอบผลลัพธ์ อีกครั้ง

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

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

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

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

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

ดูภาษาอย่าง SQL ฉันคิดว่าคำตอบคือใช่ แต่ภาษาในลักษณะนั้นไม่ได้มีวัตถุประสงค์ทั่วไป

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

อย่างไรก็ตามฉันคิดว่ามันเป็นแบบฝึกหัดที่ดี / พิสูจน์ความคิดหากภาษาสามารถ "รวบรวมตัวเอง" ... มันเป็น ... ดี ... และมันนำเสนอภาษาที่เหมาะที่จะทำสิ่งที่ซับซ้อนบางอย่าง

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

เสียงดังกราวเขียนด้วยภาษา C ++ มันจะไม่ยากเกินไปที่จะเขียนคอมไพเลอร์ Clang Objective-C ใน Objective-C แต่ถ้าอย่างนั้นมันก็ไร้ประโยชน์ การเปลี่ยนแปลงใด ๆ ในคอมไพเลอร์ C ++ จะต้องทำซ้ำใน Objective-C และในทางกลับกัน แล้วทำไมล่ะ

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

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

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

มันแสดงให้เห็นว่าภาษามีความสามารถในการประมวลผลการประมวลผลสตริงที่ซับซ้อนและการแปลเป็นภาษาอื่น / การตีความตัวเอง

ในกระบวนการสร้างคอมไพเลอร์ (โครงการใหญ่ครั้งแรก) จะมีปัญหาที่เกิดขึ้นก่อน