การพัฒนาภาษาแบบไดนามิก

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

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

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

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

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

ก่อนอื่นเรียนรู้เกี่ยวกับการใช้ล่าม ผมขอแนะนำให้PLAI (Programming ภาษา: การประยุกต์ใช้และการตีความ) มันเป็นเนื้อของการตีความอย่างรวดเร็วโดยที่ไม่ต้องอาศัยไวยากรณ์มากเกินไป

สำหรับภาษาของคุณคุณจะสามารถใช้ front-end (parser, ส่วนใหญ่) และไลบรารีรันไทม์ (GC, โครงสร้างข้อมูล, การดำเนินการดั้งเดิมเป็นต้น)

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

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

ในกระดาษ 1960ฉบับดั้งเดิมของเขาจอห์นแม็กคาร์ธีได้กำหนดหน้าที่ดั้งเดิม 5 ประการที่จำเป็นต่อเสียงกระเพื่อม แน่นอนว่าแม็คคาร์ธีตั้งใจจะทำบทความใน Lisp ว่าเป็นแบบฝึกหัดทางวิชาการเท่านั้น มันเป็นนักศึกษาระดับบัณฑิตศึกษาที่มีส่วนร่วมevalในการชุมนุมและสร้างล่ามเสียงกระเพื่อมครั้งแรก พอลเกรแฮมระบุเจ็ดดั้งเดิม : quote, atom, eq, cons, car, cdr และ cond

สิ่งนี้คือคุณสามารถนำ Lisp ไปใช้ในภาษาใดก็ได้ เมื่อคุณติดตั้งevalแล้วมันง่ายในการตั้งค่า REPL และคุณมีล่ามแบบโต้ตอบ ผู้คนรู้สึกเบื่อหรืออยากรู้อยากเห็นพอที่จะใช้ Lisps ใน C, Java, Ruby, Python และภาษาอื่น ๆ อีกมากมาย และไม่ได้ตั้งใจเสมอ เป็นสิ่งสำคัญที่ต้องจำกฎข้อที่สิบของ Greenspun :

โปรแกรม C หรือ Fortran ที่ซับซ้อนเพียงพอใด ๆ ที่มี ad hoc ที่ระบุอย่างไม่เป็นทางการระบุข้อผิดพลาดการดำเนินการช้าครึ่งของ Common Lisp

ฉันไม่ได้บอกว่าเป้าหมายสุดท้ายของคุณควรเป็นการใช้งานแบบกระเพื่อม แต่ homoiconicity มีประโยชน์เมื่อเรียนรู้ที่จะใช้ภาษาแบบไดนามิก ทำไมจัดการกับปัญหาไวยากรณ์เมื่อคุณสามารถเรียนรู้เกี่ยวกับภาษาที่ไวยากรณ์สำนวนเหมือน TOT เหมือนกันของภาษาที่ใช้ lexer / parser?

อย่างไรก็ตาม ... แค่ข้อเสนอแนะ แต่ด้วยเหตุผลที่ดีว่าภาษาการเขียนโปรแกรมที่ยอดเยี่ยมส่วนใหญ่ตั้งแต่ C มีอย่างน้อยก็เสียงกระเพื่อมเล็กน้อย

ฉันได้ใส่นี่ (~ 600 บรรทัดของ C #) ในโดเมนสาธารณะซึ่งสนับสนุน quote / list / Apply / eval / test / etc และช่วยให้ปรับแต่งไวยากรณ์เหมือนเสียงกระเพื่อมและ / หรือ builtin ความหมายได้อย่างง่ายดาย:

https://repl.it/CdjV/3

เช่น:

        var factorial = (Lambda)language.
            Evaluate
            (@"
                ( => ( n ) (
                        ? ( != n 0 )
                        ( * n ( this ( - n 1 ) ) )
                        1
                    )
                )
            ");

        var sw = new System.Diagnostics.Stopwatch();
        var n = 12;
        var r = 0;
        int k;
        sw.Start();
        for (k = 0; k < 10000; k++)
        {
            r = (int)factorial.Invoke(null, n);
        }
        sw.Stop();
        Console.WriteLine("{0}! = {1}", n, r);
        Console.WriteLine();
        Console.WriteLine("in {0} ms (for {1} times)", sw.ElapsedMilliseconds, k.ToString("0,0"));

'HTH,

สมมติว่าคุณรู้บิตของโครงการ (เช่นได้อ่านSICP ) หรือเสียงกระเพื่อมผมขอแนะนำให้ Queinnec ของเสียงกระเพื่อมในชิ้นเล็ก ๆหนังสือ มันอธิบายหลายตัวแปรของล่ามเหมือนเสียงกระเพื่อม & คอมไพเลอร์ (รวมถึง bytecode หรือ C)

นอกจากนี้สกอตต์อ่านการเขียนโปรแกรมภาษาเน้นล่าสุดหนังสือมังกรที่คู่มือ GC , เพียร์ซของประเภทและการเขียนโปรแกรมภาษา

ฉันกำลังหาข้อมูลเกี่ยวกับวิธีการเปลี่ยนจากคอมไพเลอร์เป็นล่าม

จากนั้นการประเมินบางส่วน (& การคาดการณ์ Futamura) และรูปแบบการส่งต่ออาจมีความเกี่ยวข้อง