कंपाइलर बनाना चाहते हैं? बस ये दो पेपर पढ़िए (2008)

 (prog21.dadgum.com)
17 पॉइंट द्वारा GN⁺ 2026-04-16 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • ज़्यादातर compiler textbooks थ्योरी-केंद्रित और बहुत विशाल होते हैं, इसलिए शुरुआती लोगों के लिए वास्तव में काम करने वाला compiler implement करना कठिन हो जाता है
  • इस समस्या के व्यावहारिक समाधान के रूप में Jack Crenshaw की “Let’s Build a Compiler!” सीरीज़ का परिचय दिया गया है, जो single-pass संरचना वाले सरल Pascal compiler को कवर करती है
  • यह tutorial parsing और code generation के संयोजन, न्यूनतम optimization, और C·Forth versions के माध्यम से प्रयोग-आधारित सीखने का समर्थन करता है
  • दूसरा स्रोत, “A Nanopass Framework for Compiler Education” पेपर, कई सरल transformations(pass) से बने modular compiler architecture का प्रस्ताव रखता है
  • इन दोनों स्रोतों के माध्यम से वास्तविक implementation अनुभव हासिल करने के बाद, ज़रूरत हो तो पारंपरिक textbook (Dragon Book) देखकर आगे गहराई से पढ़ाई की जा सकती है

कंपाइलर सीखने की हक़ीक़त और दो प्रमुख पेपर

  • मौजूदा compiler books अक्सर ज़रूरत से ज़्यादा विशाल और कठिन होती हैं, इसलिए शुरुआती लोग वास्तव में काम करने वाला compiler लिखना मुश्किल पाते हैं
    • अधिकांश किताबें regular expression transformation, grammar theory जैसे बड़े विषयों को कवर करती हैं, लेकिन कोई व्यावहारिक शुरुआती बिंदु नहीं देतीं
    • इसके कारण “compiler बनाना बहुत कठिन है” जैसी गलतफहमियाँ और मिथक बन जाते हैं
  • इस सोच को तोड़ने वाले प्रतिनिधि स्रोत के रूप में Jack Crenshaw की “Let’s Build a Compiler!” सीरीज़ का परिचय दिया जाता है
    • 1988 में शुरू हुई यह tutorial Turbo Pascal स्तर के single-pass compiler को कवर करती है
    • इसकी संरचना parsing और code generation को जोड़ती है, और केवल न्यूनतम optimization करती है
    • यह मूल रूप से Pascal में लिखी गई थी, और बाद में C version तथा Forth translation भी आए
    • Forth version में भाषा की interactive विशेषताओं के कारण प्रयोग करना और समझना आसान है
  • Crenshaw सीरीज़ की एक सीमा यह है कि इसमें program की internal representation (abstract syntax tree, AST) नहीं है
    • Pascal में tree manipulation जटिल होने के कारण इसे छोड़ा गया, लेकिन Python, Ruby, Erlang, Haskell, Lisp जैसी high-level भाषाओं में इसे आसानी से implement किया जा सकता है
    • ये भाषाएँ मूल रूप से tree-structured data manipulation के लिए डिज़ाइन की गई हैं
  • दूसरे अनुशंसित स्रोत के रूप में Sarkar, Waddell, Dybvig का पेपर “A Nanopass Framework for Compiler Education”
    • इसका मुख्य विचार यह है कि “compiler, program की internal representation को चरणबद्ध तरीके से transform करने वाली प्रक्रियाओं की एक श्रृंखला है”
    • यह दर्जनों से सैकड़ों सरल transformations(pass) से बनी संरचना का प्रस्ताव रखता है
    • हर transformation को यथासंभव सरल रखा जाता है, और transformations के बीच coupling से बचा जाता है
    • framework हर pass के input और output को स्पष्ट रूप से परिभाषित करता है
    • implementation language Scheme है, और dynamic typing के आधार पर runtime validation किया जाता है
  • इन दो स्रोतों के ज़रिए वास्तविक compiler लिखने का अनुभव लेने के बाद, ज़रूरत पड़ने पर Dragon Book जैसी पारंपरिक textbook से आगे की पढ़ाई की जा सकती है
    • फिर भी, केवल इन दो स्रोतों से ही पर्याप्त व्यावहारिक compiler development experience प्राप्त किया जा सकता है

संबंधित पढ़ाई

1 टिप्पणियां

 
GN⁺ 2026-04-16
Hacker News प्रतिक्रियाएँ

  • Donald Knuth की 『The Art of Computer Programming』 अभी भी लिखी जा रही है, और अब संभवतः इसमें compiler विषय शामिल न हो
    मैं लेखक की इस बात से सहमत नहीं हूँ। 『Dragon Book』 (Aho आदि द्वारा) का अध्याय 2 अपने आप में एक पूरा compiler परिचय है, जिसे अलग से पढ़ा जा सकता है
    एक और शानदार शुरुआती किताब Niklaus Wirth की 『Compilers』 है, जो 100 पन्नों से भी कम में पूरे compiler का source code और साफ़ व्याख्या देती है
    इन दो किताबों से मैंने हाई स्कूल के समय इतना सीखा कि खुद compiler बना सका

    • 『Dragon Book』 शानदार है, लेकिन शुरुआती किताब के तौर पर उपयुक्त नहीं। मैं भी इस किताब की वजह से लगभग compilers छोड़ ही चुका था
      मेरा मानना है कि ऐसी किताबें बेहतर हैं जो practical तरीके से वास्तविक compiler बनाने की प्रक्रिया के साथ चलती हैं
      संदर्भ सामग्री इस लिंक में संकलित है
    • 『Dragon Book』 parsing-केंद्रित है, इसलिए अगर आपकी रुचि backend या optimization में है तो मैं इसे recommend नहीं करूँगा
      दूसरे edition में data-flow analysis जोड़ा गया था, लेकिन आधुनिक compilers (GCC, LLVM आदि) के केंद्र में मौजूद SSA(Static Single Assignment) form पर सिर्फ़ एक पन्ना है
      आधुनिक backend बनाने के लिए SSA theory अलग से पढ़नी होगी
    • Niklaus Wirth की 『Compilers』 यहाँ देखी जा सकती है
    • Knuth की साइट के अनुसार, Volume 7 में compiler तकनीक को शामिल करने की योजना अब भी है
      TAOCP आधिकारिक पेज देखें
    • आज पता चला कि Knuth का middle name भी है, लेकिन लेख में उसे ज़रूरी नहीं जोड़ना चाहिए

  • Abdulaziz Ghuloum का पेपर An Incremental Approach to Compiler Construction
    इस धारणा को तोड़ता है कि “compiler कोई जादुई चीज़ है”, और दिखाता है कि interpreter की तरह compiler भी आसानी से बनाया जा सकता है
    यह विस्तार से बताता है कि Scheme भाषा के बड़े हिस्से को support करने वाला और Intel x86 के लिए assembly generate करने वाला compiler चरण-दर-चरण कैसे बनाया जाए

    • इस पेपर से प्रेरित Nora Sandler की 『Writing a C Compiler』 भी बहुत अच्छी किताब है
    • Nada Amin द्वारा Aziz के approach का implementation किया गया tests सहित version भी है

  • हाल के वर्षों में meta-compiler, adaptive compilation, और JIT compiler जैसी चीज़ों से compiler तकनीक काफ़ी आगे बढ़ी है
    Alan Kay का research group VPRI complexity की समस्या पर काम करता है
    संबंधित सामग्री: Ometa पेपर, Adaptive Compilation वीडियो, Alan Kay व्याख्यान

  • किताबें पढ़ने पर मैंने एक अच्छी सलाह सुनी थी — किताबें RAM की तरह random access वाली होती हैं
    ज़रूरत के हिस्से चुनकर पढ़ो, तो मोटी किताबें भी कम बोझिल लगती हैं
    लेकिन जब यह ही न पता हो कि आपको क्या नहीं पता, तब यह तरीका काम नहीं करता। इसलिए हल्की शुरुआती किताबों की अहमियत बहुत ज़्यादा है

    • ज़्यादातर किताबों में इतने अनावश्यक details होते हैं कि उन्हें छोड़ना पड़ता है। दूसरी ओर technical किताबें इतनी कठिन होती हैं कि एक हिस्सा समझने में कई घंटे लग जाते हैं
    • मुझे लगता है कि अगर किताब पूरी न पढ़ी जाए तो उससे सार्थक लाभ निकालना मुश्किल होता है। आजकल अच्छी reference book जैसी सामग्री इंटरनेट पर चली गई है
    • मेरी technical किताबों का बड़ा हिस्सा खास सवालों के reference के लिए इस्तेमाल होता है

  • आजकल 『Crafting Interpreters』 की बहुत सिफ़ारिश की जाती है
    Nanopass पेपर का लिंक टूटा हुआ है

    • “compiler किताब” कहने पर भी हर किताब का दायरा अलग-अलग होता है, और कई बार वह मेरे काम की चीज़ से मेल नहीं खाता
      इसलिए मैंने 『Crafting Interpreters』 के मुख्य बिंदुओं का cheat sheet बनाया
      यह किताब सिर्फ़ manual नहीं है, बल्कि अनुभव-केंद्रित सीखने की किताब है, जिसमें visitor pattern जैसी चीज़ों के ज़रिए लेखक की रुचि साफ़ झलकती है
    • 『Crafting Interpreters』 शानदार है, लेकिन अगर type system, optimization, और linking को कवर करने वाली companion book भी होती, तो यह और भी बेहतर होती
    • अकेले पढ़ने-सीखने के लिए यह सचमुच बहुत अच्छी किताब है
    • मैंने कॉलेज के दिनों में क्लास का इंतज़ार करते हुए इसे पूरा पढ़ लिया था। Nanopass अभी तक नहीं आज़माया, लेकिन किसी दूसरे लिंक से कोशिश करूँगा
    • Nanopass पेपर इस GitHub repository में सुरक्षित है

  • हाल में मैं मज़े के लिए एक toy compiler बना रहा हूँ
    जटिल parsing theory या DSL की जगह Megaparsec parser combinator का इस्तेमाल कर रहा हूँ
    parsing logic साफ़ रहता है, reuse करना आसान होता है, और पारंपरिक lexer/parser separation की झंझट नहीं रहती

    • मेरे हिसाब से LL/LR parser generator से recursive descent parser ज़्यादा practical है
      इसमें bugs कम होते हैं, error diagnosis बेहतर होता है, और ज़्यादातर भाषाएँ (C#, Rust आदि) भी यही तरीका अपनाती हैं
      tree-sitter भी शानदार है, लेकिन उसकी dependencies बहुत हैं। इसके उलट recursive descent से बिना dependencies के compact implementation संभव है
    • फिर भी मुझे लगता है कि lexer/parser separation बनाए रखना बेहतर है
      parser combinator approach की खासियत यह है कि lexer और parser दोनों को एक ही parser type के रूप में संभाला जा सकता है
      इससे whitespace handling और tokenization की समस्याएँ साफ़-सुथरे तरीके से हल हो जाती हैं

  • जो Nanopass पेपर dead link बन गया था, वह यहाँ देखा जा सकता है

  • मुझे compiler सिखाने वाली चीज़ 1978 की BYTE magazine का Tiny Pascal compiler लेख था
    optimization मैंने Stanford में Ullman और Hennessy द्वारा चलाए गए summer course से सीखी थी
    code generator मेरा खुद बनाया हुआ मौलिक तरीका था
    『Dragon Book』 मेरे पास है, लेकिन मैंने उसे वास्तव में कभी पढ़ा नहीं

    • संबंधित BYTE magazine archive.org पर देखी जा सकती है

  • Nanopass approach का मूल बिंदु passes की संख्या नहीं, बल्कि हर pass के लिए स्पष्ट input/output language को परिभाषित करना है
    इस structured सोच की वजह से execution से पहले ही बहुत सारे bugs पकड़े जा सकते हैं
    Crenshaw का tutorial भी शानदार है, लेकिन ऐसी language invariants की देखभाल ही सच में scalable compiler बनाने का फर्क पैदा करती है

  • UC Irvine के समय, Niklaus Wirth के शिष्य Professor Michael Franz की CS241 class में optimizing compiler implement करने की याद है
    वह DLX नाम की virtual machine के लिए bytecode generate करने वाला assignment था
    संबंधित सामग्री DLX architecture विवरण और
    register allocation algorithm के संदर्भ चित्र में देखी जा सकती है