प्रोग्रामिंग की सात आदिरूप भाषाएँ (2022)

 (madhadron.com)
49 पॉइंट द्वारा GN⁺ 2026-04-20 | 5 टिप्पणियां | WhatsApp पर शेयर करें
  • अलग-अलग syntax से ज़्यादा बेसिक pattern के समूहों का अंतर महत्वपूर्ण है, और programming languages को iteration, recursion, और composition के तरीकों के आधार पर सात आदिरूप भाषाओं में बाँटा जा सकता है
  • ALGOL, Lisp, ML, Self, Forth, APL, Prolog मुख्य वर्ग हैं, और हर परिवार में एक प्रतिनिधि भाषा को मानक नमूने की तरह लेकर दूसरी भाषाओं की वंशरेखा समझी जाती है
  • किसी परिचित आदिरूप भाषा को साझा करने वाली नई भाषा सीखना आसान होता है, लेकिन किसी अपरिचित आदिरूप में जाने पर नई सोच की दिशा और काफ़ी सीखने का समय चाहिए
  • ALGOL में assignment, conditional, और loop-केंद्रित function organization है; Lisp में macro और list code; ML में first-class functions और recursion; Self में message-passing objects; Forth में stack-based syntax; APL में n-dimensional arrays; और Prolog में facts तथा search structure मुख्य विशेषताएँ हैं
  • हर programmer के लिए ALGOL परिवार की भाषा में दक्षता पहली प्राथमिकता है, उसके बाद SQL सीखना, और फिर आगे चलकर अपरिचित आदिरूप भाषाओं को लगातार सीखते रहना दीर्घकाल में फ़ायदेमंद है

प्रोग्रामिंग की सात आदिरूप भाषाएँ

  • programming language चुनते समय अलग-अलग syntax के अंतर से ज़्यादा बुनियादी pattern सीखना महत्वपूर्ण है, और एक जैसे परिवारों की भाषाओं में array traversal या combination traversal जैसी मूल संरचनाएँ लगभग एक जैसी होती हैं
  • अलग-अलग language groups में iteration, recursion, और program composition के तरीके काफ़ी अलग होते हैं, और ऐसे बुनियादी pattern के समूह मिलकर अलग आदिरूप भाषाएँ बनाते हैं
  • किसी परिचित आदिरूप भाषा को साझा करने वाली नई भाषा सीखना अपेक्षाकृत आसान बदलाव है, लेकिन अपरिचित आदिरूप भाषा की ओर जाने पर काफ़ी समय और नई सोच की दिशा चाहिए
  • software क्षेत्र में पहचानी जाने वाली आदिरूप भाषाएँ सात हैं: ALGOL, Lisp, ML, Self, Forth, APL, Prolog
  • हर आदिरूप भाषा को एक खास प्रतिनिधि भाषा के मानक नमूने की तरह लेकर वर्गीकृत किया जाता है, और दूसरी भाषाओं की वंशरेखा उस नमूने से तुलना करके समझी जाती है

  • ALGOL

    • program assignment, conditional, और loop की क्रमिक शृंखला से बनता है, और functions के आधार पर संगठित होता है
    • कई भाषाएँ इसमें module system, नए data type को define करने के तरीके, polymorphism, और exception या coroutine जैसे वैकल्पिक control flow structures जोड़ती हैं
    • आज व्यापक रूप से इस्तेमाल होने वाली अधिकांश programming languages इसी आदिरूप भाषा परिवार में आती हैं
    • खुद ALGOL में ALGOL 58, ALGOL 60, ALGOL W, ALGOL 68 शामिल हैं
    • Assembly language, Fortran, C, C++, Python, Java, C#, Ruby, Pascal, JavaScript, Ada इसी वंश से जुड़े हैं
    • यह सबसे पुरानी आदिरूप भाषा है, जिसकी परंपरा Ada Lovelace द्वारा Babbage की analytical engine के लिए program formalization तक जाती है
    • EDVAC और शुरुआती Univac तक जाने वाले Eckert-Mauchly architecture कंप्यूटरों की machine language और assembly language, और Grace Hopper की A-0 से Fortran और COBOL तक की शुरुआती high-level language कोशिशें सब इसी रूप में थीं
    • 1960 के दशक में अकादमिक जगत में structured programming विकसित हुई, जिससे ऐसी भाषाएँ अधिक manageable बनीं, और उसका परिणाम ALGOL 60 था; बाद में इस परिवार के अधिकतर सदस्य यहीं से निकले
    • समय के साथ इसमें दूसरी आदिरूप भाषाओं की सुविधाएँ समाहित करने की प्रवृत्ति रही
      • 1980 के दशक में Self परिवार की अवधारणाएँ classes के रूप में जोड़ी गईं और data type definition तथा polymorphism लागू करने के साधन के रूप में इस्तेमाल हुईं
      • 2010 के बाद ML परिवार की अवधारणाएँ भी सामने आईं

  • Lisp

    • कोष्ठकों में घिरे prefix expressions और list representation का मिला-जुला syntax
      • (+ 2 3)
      • (defun square (x) (* x x))
      • (* (square 3) 3)
    • space से अलग किए गए items को parentheses में घेरने वाली list representation भाषा में built-in होती है, इसलिए code खुद list के रूप में होता है
    • macro list को लेकर उसे बदल सकते हैं और बदला हुआ code compiler को दे सकते हैं, इसलिए programmer भाषा के अर्थ को फिर से परिभाषित कर सकता है
    • ज़्यादातर code लिखने में यह दूसरी आदिरूप भाषाओं, आम तौर पर ALGOL या ML, जैसा व्यवहार करती है, लेकिन macro system इसकी अलग पहचान है
    • Common Lisp का loop syntax भी भाषा की built-in सुविधा नहीं बल्कि macro के रूप में परिभाषित है
    • शुरुआती दौर में Lisp के कई variants थे, लेकिन community ने Common Lisp पर सहमति बनाई
    • Sussman और Steele ने यह खोजते हुए कि functions से कितना कुछ किया जा सकता है, Scheme बनाया
    • numerical computation के लिए Lush, AutoCAD scripting language AutoLISP, और Emacs editor behavior लागू करने वाली Emacs Lisp जैसी special-purpose Lisp भी इस्तेमाल हुई
    • हाल के वर्षों में Clojure Lisp परिवार की तीसरी बड़ी शाखा के रूप में उभरी है
    • Fortran के लगभग एक साल बाद आई यह आज भी उपयोग में रहने वाली दूसरी सबसे पुरानी language family है
    • इसकी शुरुआत इस गणितीय प्रश्न से हुई कि ऐसी mathematical structure को कैसे लिखा जाए जो अपने ही expressions का मूल्यांकन कर सके
    • John McCarthy ने 1958 में इसका उत्तर दिया, और बाद में इसे कंप्यूटर पर लागू किया गया
    • शुरुआती Lisp अपने mathematical background के कारण उस समय की मशीनों के साथ ठीक से नहीं बैठती थी; memory और CPU cycle की समस्या गणित में नहीं थी, इसलिए garbage collection जैसी तकनीकों की ज़रूरत पड़ी
    • 1970 के दशक के उत्तरार्ध और 1980 के शुरुआती वर्षों में ऐसी मशीनें भी थीं जो सिर्फ Lisp चलाने के लिए नीचे से ऊपर तक डिज़ाइन की गई थीं
    • आज के integrated development environment के कई तत्व उन्हीं मशीनों पर आविष्कृत हुए
    • उसी समय AI research का मुख्य साधन Lisp था, और 1980 के दशक की AI hype जब नतीजे नहीं दे सकी, तो क्षेत्र के साथ Lisp भी AI Winter में गिरा
    • इसके बाद भी यह बची रही, और कंप्यूटर प्रदर्शन में सुधार तथा दूसरी भाषाओं द्वारा इसकी सुविधाएँ अपनाने से implementation की कठिनाइयाँ कम हुईं

  • ML

    • functions first-class values हैं, और इसमें अलग-अलग functions तथा tagged unions को व्यक्त करने वाला Hindley-Milner family type system होता है
    • हर iteration recursion के रूप में की जाती है
      • sum [] = 0
      • sum (x:xs) = x + sum xs
    • iteration patterns को encapsulate करने वाले functions define करके, और दूसरे functions को लेकर behavior लागू करने का तरीका भी इस्तेमाल होता है
      • map _ [] = []
      • map f (x:xs) = (f x) : (map f xs)
    • कुछ भाषाएँ, जैसे Miranda और Haskell, मूल रूप से lazy evaluation का उपयोग करती हैं
    • दूसरी भाषाएँ type system को कई दिशाओं में बढ़ाती हैं
      • OCaml ने Self आदिरूप भाषा की अवधारणाओं के साथ संयोजन की कोशिश की
      • Agda और Idris ने dependent type systems अपनाए जो values और types को मिलाते हैं
      • 1ML modules और types को जोड़ता है
    • ML से CaML, Standard ML, OCaml निकले
    • Miranda, Haskell, Agda, Idris जैसे संबंधित परिवार भी आगे बढ़े
    • ML, Cambridge, England में विकसित theorem-proving program की meta-language थी, और इसका नाम भी वहीं से आया
    • बाद में यह उस संदर्भ से बाहर निकलकर स्वतंत्र भाषा के रूप में फैली, और खासकर Britain तथा France को केंद्र बनाकर यूरोप में लोकप्रिय हुई

  • Self

    • program एक-दूसरे को message भेजने वाले objects के समूह से बना होता है, और हर behavior इसी तरीके से लागू होता है
    • नए objects, मौजूदा objects को message भेजकर बनाए जाते हैं
    • conditional भी true object और false object में से किसी एक को संदर्भित करने वाले variable के माध्यम से चलाया जाता है
      • दोनों objects ऐसे message लेते हैं जिनमें true होने पर चलने वाला function और false होने पर चलने वाला function parameter के रूप में दिया जाता है
      • true object पहला function चलाता है, false object दूसरा
      • calling code को यह नहीं पता होता कि object कौन-सा है; वह बस message भेजता है
    • loop भी इसी तरह काम करते हैं, और उपयुक्त object बनाकर सही जगह रख दिया जाए तो भाषा के पूरे अर्थ को फिर से परिभाषित किया जा सकता है
    • ऐसी भाषाओं में source आम तौर पर text file में नहीं बल्कि live environment में रखा जाता है
    • programmer live system को बदलता है, और files compile करके system बनाने के बजाय उसकी state save करता है
    • महत्वपूर्ण उदाहरण Smalltalk और Self हैं
    • कई भाषाएँ इस language group की message-passing शैली को आंशिक रूप से अपनाती हैं; ऐसे आंशिक अपनाने को आम तौर पर object-oriented programming कहा जाता है
    • इनमें से अधिकतर Smalltalk पर आधारित हैं, और JavaScript अपवाद है क्योंकि वह Self के classless object system से निकला है
    • Common Lisp का object system इसे इस तरह generalize करता है कि runtime सिर्फ एक message-receiving object नहीं, बल्कि सभी parameters के आधार पर चलने वाला code चुनता है
    • Erlang में execution flow objects के बीच घूमने के बजाय, parallel execution threads स्पष्ट रूप से messages सुनते और भेजते हैं
    • मूल भाषा Smalltalk थी, जिसे 1970 के दशक के उत्तरार्ध और 1980 के दशक में Xerox Parc में विकसित किया गया
    • 1980 के दशक में कई commercial Smalltalk systems थे, और IBM ने दूसरी भाषाओं के programming tools, यानी VisualAge collection, के विकास में Smalltalk का उपयोग किया
    • आज Smalltalk मुख्य रूप से open source Pharo Smalltalk के रूप में जीवित है
    • Smalltalk को तेज़ और कुशलता से चलाने पर बहुत शोध हुआ, और उसका शिखर Strongtalk project था
    • Strongtalk की खोजों का ऐतिहासिक महत्व यह है कि वे Java के HotSpot JIT compiler की नींव बनीं
    • Smalltalk ने पहले की भाषाओं के value और type concepts को आगे बढ़ाकर classes लागू कीं; हर object की एक class होती थी जो उसे type देती थी, और class वही type object बनाती थी
    • Self ने class की अवधारणा हटाकर सिर्फ objects को रखा
    • अधिक शुद्ध रूप होने के कारण इस आदिरूप भाषा का नमूना Self को चुना गया

  • Forth

    • stack languages को Lisp का उल्टा प्रतिबिंब कहा जा सकता है, और वे Hewlett Packard के reverse Polish notation calculators के syntax से मेल खाते हैं
    • इनमें data stack होता है; 42 जैसे literal लिखने पर वह stack पर push होता है, और function names बिना explicit parameters के stack पर काम करते हैं
    • साधारण arithmetic भी 2 3 + 5 * जैसे उल्टे रूप में लिखी जाती है
    • function definition भी बहुत संक्षिप्त होती है
      • अधिकतर Forth variants में : नया word define करता है
      • square, dup और * को call करने के बराबर है
      • dup stack के सबसे ऊपर के item की copy बनाता है, * ऊपर के दो items को गुणा करता है
    • parser को intercept करके अपने code से बदला जा सकता है, इसलिए पूरा syntax बदला जा सकता है
    • Forth programs में Fortran subset, packet layout, या state machine transitions दिखाने वाले ASCII diagrams को सीधे parse करने वाले छोटे-छोटे languages define करना आम बात है
    • Forth के कई variants, PostScript, Factor, Joy इसमें शामिल हैं
    • Joy, stack के बजाय composition की mathematical formalism इस्तेमाल करने वाली pure functional language है
    • Forth पहली बार 1970 में radio telescope control के लिए लिखा गया था
    • बाद में यह embedded systems में व्यापक रूप से फैल गया
    • Forth systems को bootstrap करना इतना आसान है कि कई programmers ने अपने-अपने उद्देश्यों के लिए इसके दर्जनों variants बना लिए
    • PostScript 1980 के दशक में printers पर documents को describe करने के लचीले साधन के रूप में आया
    • PostScript कई मायनों में Forth से अधिक सीमित है, लेकिन graphics layout से जुड़े बुनियादी operations भाषा में परिभाषित करता है

  • APL

    • भाषा की हर चीज़ n-dimensional array है
    • operators एक या दो symbols से बनते हैं, और पूरे arrays पर high-level operations करते हैं
    • इसकी अभिव्यक्ति बहुत compressed होती है, इसलिए symbol sequence खुद ही बिना अलग नाम दिए operation की पहचान बन जाती है
    • उदाहरण के तौर पर variable x का average निकालना (+⌿÷≢) x के रूप में लिखा जाता है
    • APL, J, K इसके प्रमुख उदाहरण हैं
    • arrays पर higher-order operations को MATLAB, NumPy, R जैसे कई environments में आंशिक रूप से अपनाया गया है
    • APL की शुरुआत 1960 के दशक में Kenneth Iverson द्वारा बनाई गई mathematical notation से हुई, जिसे बाद में कंप्यूटर पर लागू किया गया
    • भारी computation करने वालों के बीच इसके बाद भी इसका niche support बना रहा
    • इसकी descendant language K वित्तीय वातावरण में बहुत लोकप्रिय रही

  • Prolog

    • program facts के समूह से बना होता है
      • father(bob, ed).
      • father(bob, jane).
    • variables के सहारे दूसरे facts से facts निकालने वाले ungrounded facts भी उपयोग किए जाते हैं
      • grandfather(X, Y) :- father(X, Z), father(Z, Y).
    • Prolog runtime इन facts और queries को लेकर परिणाम ढूँढने के लिए search करता है
    • facts की definition structure सही चुन ली जाए तो Turing completeness हासिल होती है
    • Prolog में facts बनाने वाले terms अपने आप में एक विशिष्ट data type होते हैं, जिन्हें बनाकर runtime को दिया जा सकता है
    • यह Lisp के macros और Forth के parser replacement के समान स्थिति रखता है
    • Prolog programs मूल रूप से search हैं, इसलिए database query की तरह इन्हें search order के समायोजन और बेनतीजा रास्तों को जल्दी रोकने पर केंद्रित करके tune किया जाता है
    • Prolog, Mercury, Kanren इसमें शामिल हैं
    • इस आदिरूप भाषा परिवार में वास्तविक programming का अधिकांश काम खुद Prolog में ही होता है, और community में काफ़ी मज़बूत एकरूपता है
    • 1970 के दशक में France के logicians ने यह समझा कि programs को first-order logic के रूप में व्यक्त किया जा सकता है, और वहीं से implementation की कोशिशें शुरू हुईं
    • 1980 के दशक में Japan के fifth-generation computer project ने Prolog पर बड़ा दाँव लगाया, लेकिन project के विफल होने के साथ Prolog की प्रतिष्ठा भी गिरी
    • इसके बावजूद दशकों तक Prolog runtime को ज़्यादातर मामलों में कुशल बनाने और नई सुविधाएँ जोड़ने पर शोध जारी रहा
    • numerical constraints जैसी सुविधाएँ जुड़ने से constraint logic programming की दिशा बनी
    • Prolog niche क्षेत्रों में लगातार दिखाई देता रहा है
      • कई वर्षों तक Java की type checking Prolog में लागू की गई थी
      • Facebook का शुरुआती source code search tool भी Prolog-आधारित था

इसका उपयोग कैसे करें

  • ज़्यादातर programmers को इस language family का कुछ हिस्सा या पूरा ढाँचा बहुत अपरिचित लग सकता है, लेकिन हर परिवार जो सोच की दिशा और नई संभावनाएँ देता है, उसके लिए कुछ समय लगाना सार्थक है
  • ALGOL के नज़रिए से दो चीज़ें पूरी तरह अलग लग सकती हैं, जबकि किसी दूसरे नज़रिए से उनका अंतर मामूली हो सकता है; ऐसा बहुत बार होता है

  • प्राथमिकता

    • हर programmer को ALGOL परिवार की एक भाषा अच्छी तरह जाननी चाहिए
    • उसके बाद Prolog परिवार की भाषा SQL सीखने की सलाह दी गई है
      • करियर में ALGOL के बाद यह सबसे ज़्यादा उपयोगी साबित होती है

  • आगे का विस्तार

    • ऊपर की इन दो families को सीख लेने के बाद, हर साल किसी अपरिचित आदिरूप भाषा परिवार की एक नई भाषा सीखना लंबे समय में लाभदायक है
    • हर family के लिए सुझाई गई भाषाएँ और क्रम इस प्रकार हैं
      • Lisp: PLT Racket
      • ML: Haskell
      • Self: Self
      • Prolog: Prolog
      • Forth: gForth
      • APL: K, ok के माध्यम से उपयोग

  • क्रम में बदलाव

    • यदि आप बहुत numerical computation करते हैं, तो K को पहले सीखना अधिक उपयुक्त है
    • यदि आप embedded programming ज़्यादा करते हैं, तो gForth को पहले सीखना अधिक उपयुक्त है
    • लेकिन क्रम स्वयं या बिल्कुल कौन-सी भाषा चुनी जाए, यह बहुत महत्वपूर्ण नहीं है
    • Haskell की जगह Standard ML या OCaml, PLT Racket की जगह Common Lisp, और gForth की जगह Factor सीखना भी ठीक है

  • फ़ुटनोट में शामिल पूरक बातें

    • SQL सीखने के बाद भी Prolog खुद सीखने की ज़रूरत बनी रहती है
      • क्योंकि इसका वास्तविक उपयोग SQL से काफ़ी अलग है
    • Forth को गहराई से समझने के लिए Forth implementation खुद बनाना एक आम तरीका माना जाता है, ऐसा एक पाठक की राय में कहा गया
      • Forth इतना छोटा है कि एक व्यक्ति इसे अपेक्षाकृत कम समय में नीचे से ऊपर तक लागू कर सकता है
      • gForth ANS Forth सीखने के लिए अच्छा implementation है
      • अध्ययन सामग्री के रूप में McCabe की FORTH Fundamentals, Volume 1 का उल्लेख है
      • साथ में देखने योग्य Forth के रूप में PygmyForth, eForth, colorForth का भी उल्लेख है

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

5 टिप्पणियां

 
zkj9404 2026-04-21

दिलचस्प है।
 
tazuya 2026-04-20

कॉलेज के समय मैंने ALGOL परिवार, Lisp और Prolog से अपने मेजर के विषय पढ़े थे और असाइनमेंट किए थे, तो यह यादें फिर से ताज़ा हो गईं।
 
mhcoma 2026-04-20

उन भाषाओं ने आधुनिक मुख्यधारा की programming languages पर बहुत असर छोड़ा है,
लेकिन उनमें से सिर्फ Forth का प्रभाव अपेक्षाकृत कम दिखता है।
 
click 2026-04-21

prefix notation तक तो फिर भी ठीक है, लेकिन postfix notation में coding करना सच में बहुत असुविधाजनक है।
 
GN⁺ 2026-04-20
Hacker News की राय

  • Tufts की PL क्लास में imperative, Lisp, ML, Smalltalk से पहले की 4 भाषा-परिवारों के mini versions खुद बनाकर देखे थे, और यह देखकर अच्छा लगा कि वह प्रक्रिया अब पाठ्यपुस्तक के रूप में भी उपलब्ध है। पहले इसमें Prolog वाला हिस्सा भी था, जो अब नहीं है, यह थोड़ा अफसोसजनक है

    • अगर वह छूटा हुआ Prolog section Internet Archive जैसी किसी जगह पर भी मिल जाए तो सच में बहुत अच्छा होगा

  • इस लेख की classification में अगर एक ही चीज़ बदलनी हो, तो Ruby को Algol परिवार से ज़्यादा साफ़ तौर पर object-oriented भाषा मानूंगा। उस पर Smalltalk का असर बड़ा है, और standard library में map की जगह collect जैसे नामों में भी उसका निशान बचा है। Ruby में शुरू से अंत तक सब कुछ object है, और method call को object को message भेजने की तरह समझना ज़्यादा स्वाभाविक लगता है। इसकी तुलना Python से अक्सर होती है, लेकिन इसका evolution path काफ़ी अलग रहा, और अब जाकर दोनों कुछ मिलते-जुलते ecosystem points पर converge हुए लगते हैं। मुझे Ruby, Python से ज़्यादा गरमाहट भरी alpaca जैसी लगती है

    • Python भी new style classes के बाद से व्यावहारिक रूप से pure OOP भाषा मानी जा सकती है। Hello World स्तर पर यह कम दिखता है, लेकिन primitive types तक सब object बन चुके हैं। OOP से चिढ़ने वालों को type(42) और dir(42) दिखाना इस बात पर ज़ोर देने का अच्छा तरीका है कि integer भी object है
    • किसी एक prototypical भाषा को object-oriented language कहकर तय कर देना उल्टा लोगों को भ्रमित करता है, ऐसा लगता है। OO, procedural की तरह, एक programming style के ज़्यादा क़रीब है; सिर्फ़ multiple inheritance होने के कारण Python और C++ को एक ही तरह की भाषा कहकर बाँधना मुझे ठीक नहीं लगता
    • ऊँट वाली उपमा देखकर लगा, camel तो मूल रूप से Perl का symbol नहीं था क्या

  • मुझे लगता है कि language genealogy में proof expression languages नाम की एक और category जोड़नी चाहिए। यह Curry-Howard correspondence वाला परिवार है, जहाँ program ही proof होता है, और Lean इसका एक प्रतिनिधि उदाहरण है। इसे functional की subcategory माना जा सकता है, लेकिन इसका मुख्य उद्देश्य execution से ज़्यादा verification है, इसलिए इसे अलग axis पर देखना सही लगता है

    • मुझे theorem proving और complex types, मौजूदा भाषाओं पर चढ़ाए गए extensions जैसे लगते हैं। Agda, Idris complex types जोड़ी हुई functional languages हैं, और Isabelle·Lean उनमें interactive proof भी जोड़ते हैं। Dafny, imperative शैली पर theorem और hints चढ़ाने वाली दिशा में है, और ACL2 को theorem/hint जुड़े Lisp की तरह देखना आसान है। और Rust traits में जैसा दिखता है, typeclasses functional और imperative भाषाओं के ऊपर चलने वाली एक तरह की logic programming जैसी लगती हैं
    • परिभाषा के हिसाब से इस परिवार में Turing completeness नहीं होती, इसलिए इन्हें असली programming language मानना मुश्किल है। अगर ये Turing-complete होतीं, तो non-terminating programs से झूठे proofs भी बनाए जा सकते थे
    • मुझे यह धारा आखिरकार ML से सीधे निकली हुई लगती है
    • Lean साफ़ तौर पर Agda, Idris के क़रीब की dependently typed ML-family भाषा है, इसलिए बड़े ढाँचे में इसे ML classification के भीतर रखा जा सकता है। और Lean का long-term goal execution को secondary मानना भी नहीं लगता। Microsoft वास्तविक software लिखने में दिलचस्पी रखता है। दूसरी ओर, अगर “proof व्यक्त करने वाली language” वाले पहलू पर ज़ोर दें, तो Prolog को भी बाहर नहीं रखा जा सकता, इसलिए Lean को आधा ML, आधा Prolog जैसा भी देखा जा सकता है। इस नज़रिए से Curry-Howard correspondence, computational logic लागू करने का एक तरीका भर लगता है

  • हाल ही में मैंने language comparison project फिर से देखा; यह 10 अक्षरों के लिए 3,715,891,200 signed permutations का parallel cycle decomposition benchmark था। “prototypical languages” से ज़्यादा, मैं हर paradigm के आधुनिक implementations में से ऐसी भाषाएँ ढूँढना चाहता था जिन्हें research programming के लिए सच में चुना जा सके। सिर्फ़ performance नहीं, बल्कि AI की मदद लेना कितना आसान है और मेरे लिए code पढ़ना-समझना कितना सहज है, यह भी देखा। AI की वजह से हर भाषा को काफ़ी गहराई तक optimize करके देखने जैसा एक तरह का पर्यटन भी संभव हुआ। नतीजे यहाँ हैं, और खासकर F# का सबसे ऊपर आना काफ़ी चौंकाने वाला था

    • ऊपर-ऊपर से यह surprising लगता है, लेकिन details ही असली बात हैं। Lean को छोड़ दें तो कुल मिलाकर अंतर बहुत नाटकीय नहीं हैं, और Chez का C++ से 2.5 गुना धीमा होना भी dynamic typing JIT भाषा के हिसाब से काफ़ी सम्मानजनक है। F# के ऐसे काम में मज़बूत होने की बड़ी वजह शायद .NET Core पर parallel processing का mature और संतुलित अनुभव है। अगर यह संख्या elapsed time है, तो CPU time breakdown भी साथ देखना और दिलचस्प होगा। फिर हर भाषा की parallelization strategy भी थोड़ी अलग है, इसलिए यह पूरी तरह same-condition comparison नहीं है। जैसे F# का सीधा thread branching और Rust का Rayon parallel iterator, दोनों का overhead structure अलग हो सकता है। अंततः Rust और C++ low-level OS concurrency primitives को बहुत सावधानी से संभालें तो और तेज़ हो सकते हैं, लेकिन वह फिर एक अलग तरह की तुलना होगी। C या Haskell में C FFI के उपयोग की अनुमति देनी चाहिए या नहीं, यह भी अस्पष्ट है, इसलिए ऐसी तुलना में मूल रूप से काफ़ी qualitative judgment मिला होता है। संदर्भ के लिए, Chez code में permutation को fxvector में रखकर और fixnum-only operations इस्तेमाल करके boxing/unboxing और allocation घटाकर उसे और तेज़ करने की गुंजाइश दिखती है। संबंधित दस्तावेज़ Chez Scheme objects documentation में है

  • मैंने भी ऐसा ही एक लेख यहाँ लिखा था। Algol, Lisp, Forth, APL, Prolog से तो सहमत हूँ, लेकिन innovative functional language के रूप में ML से थोड़ा पहले की SASL को रखा था, और object-oriented प्रतिनिधि के रूप में Self की बजाय उससे पहले आई Smalltalk को चुना था। साथ ही Fortran, COBOL, SNOBOL, Prograph को भी शामिल किया, क्योंकि मुझे वे भी अपने-अपने ढंग से खेल बदल देने वाली भाषाएँ लगती हैं

    • मुझे यह सूची ज़्यादा पसंद है। खासकर SNOBOL का शामिल होना देखकर अच्छा लगा। मैंने इसे कभी इस्तेमाल नहीं किया, लेकिन बचपन में public library की किताबों की सेल में इसका मज़ेदार नाम देखकर इससे जुड़ी किताब उठाई थी, और वहीं पहली बार इसका पता चला। उससे पहले मुझे BASIC, Logo, और Atari BASIC manual के उदाहरणों की मदद से BASIC से call करके देखी हुई थोड़ी-सी 6502 assembly ही आती थी। और innovative language की सूची में Fortran और COBOL, या उनके पूर्वज FLOW-MATIC का न होना, कल्पना करना मुश्किल है। संदर्भ वाली किताब Atari BASIC manual थी
    • समझ नहीं आता कि Self की जगह Smalltalk सूची में क्यों नहीं होना चाहिए। Smalltalk पहले आई थी, और Alan Kay वही व्यक्ति हैं जिन्होंने “OOP” नाम ही गढ़ा था। ML को भी genealogy के हिसाब से Lisp की संतान मानता हूँ

  • मैं इस चर्चा में semantic families भी जोड़ना चाहूंगा। जैसे Verilog, Petri nets, Kahn process networks, dataflow machines, process calculi, reactive, term rewriting, constraint solver/theorem prover परिवार, probabilistic programming वगैरह। और कुछ भाषाएँ जो मौजूदा 7 categories में ठीक से फिट नहीं बैठतीं, लेकिन व्यवहार में production stage के क़रीब हैं, जैसे Unison, Darklang, temporal dataflow, DBSP। थोड़ा cheating जैसा लग सकता है, लेकिन ये ज़्यादातर von Neumann शैली के machine model के समांतर computation models हैं। मैं काफ़ी समय से “हम जिन सभी computing तरीकों को जानते हैं, von Neumann के परे” जैसी कोई चीज़ लिखना चाहता था

    • ऐसा लेख आए तो मैं सच में बहुत खुशी से पढ़ूँगा। तब तक यह Steve Yegge की कुछ लिखी बातें याद दिलाता है। मुख्य बात यह थी कि आधुनिक CS education का बड़ा हिस्सा असल में von Neumann द्वारा बनाए गए ढाँचे के ऊपर खड़ा है, और sequential device को चुनना भी उस समय की manufacturing cost और speed realities का नतीजा था। मशीन संरचना, branching, loops, subroutines, debugging, number system conversion, problem modeling जैसी कई चीज़ें जो हम सीखते हैं, वे पहले ही उनके काम में मौजूद थीं—यह बात प्रभावशाली लगी। संबंधित उद्धरण archive में है
    • term rewriting की बात से कॉलेज का एक अनुभव याद आ गया, जब spreadsheet software बनाते समय मैं formula parser का ज़िम्मेदार था। शुरुआत में मैं पूरा एक हफ्ता अटका रहा, लेकिन आखिर समझ आया कि 1+1 को ADD(1,1) जैसे रूप में rewrite कर दूँ तो मैं उसे अपने परिचित तरीके से parse कर सकता हूँ। ऊपर से regex सीखने से बेवजह बचता रहा, तो code काफ़ी अजीब बन गया, और एक सहकर्मी की बात आज भी याद है: “Andy काम करवा रहा है, तो इसे मत छेड़ो।” दूसरी टीम के एक व्यक्ति ने regex से वही काम मेरे code से लगभग 20 गुना छोटे code में कर दिया
    • “production के लिए तैयार उभरती भाषाएँ” वाली बात पर जोड़ूँ तो, मेरे हिसाब से अभी पूरी तरह production-ready न होने पर भी वास्तविक कामकाज में उपयोग होने वाले ChatGPT जैसे systems भी कुछ हद तक इसी category में आते हैं। इन्हें programming language कहना बहस का विषय हो सकता है, लेकिन इस अर्थ में कि वे इंसान और कंप्यूटर के बीच निर्देश देने का माध्यम हैं, मैं इन्हें वैसा मानने को तैयार हूँ। Non-determinism भी मुझे programming language की अनिवार्य शर्त नहीं लगती
    • Sussman के propagators पर लेख भी मज़ेदार पढ़ाई हो सकती है
    • S9 Scheme में logic programming के उदाहरण के लिए यह सामग्री अच्छी लगी। किताब खरीदे बिना भी code सीधे मिल जाता है, और Simply Scheme जैसी शुरुआती किताब से बुनियाद समझ लेने के बाद solver की संरचना काफ़ी आसानी से पढ़ी जा सकती है

  • TU Delft में लिया गया “Concepts of programming languages” मेरे पूरे CS पाठ्यक्रम का सबसे पसंदीदा course था। उसमें C, functional पक्ष के लिए Scala, और prototype concept के लिए JavaScript पढ़ी थी; उसी की वजह से कुछ साल बाद Elixir सीखना मेरे लिए कहीं आसान हो गया। Unreal Tournament agents को GOAL नाम की Prolog-आधारित भाषा में लिखने वाली class भी थी। लंबे समय तक मुझे समझ नहीं आया कि Prolog का उपयोग कहाँ करूँ, लेकिन अंत में मैंने इसका इस्तेमाल ऐसे spellcheck में किया जो LLM द्वारा बनाई गई खराब Papiamentu sentences को बार-बार सुधारने के लिए मजबूर करता था

    • मैंने भी ऐसा ही एक course लिया था, और प्रोफेसर बहुत अच्छे न होने के बावजूद इसे पढ़ना मेरे लिए बहुत फ़ायदेमंद रहा। दूसरे prototypical languages की बहुत सतही समझ भी नज़रिया चौड़ा कर देती है, और अगर assembly भी जोड़ दें तो यह असर और बढ़ जाता है। भले ही उनसे सीधे कुछ productive न बना पाओ, लेकिन कम-से-कम हर समस्या को कील समझकर सिर्फ़ हथौड़ा चलाने वाली भूल से बचते हो
    • मैं भी उस class में था। Unreal Tournament वाला हिस्सा मैंने देखी हुई सबसे शानदार classes में से एक था, और याद पड़ता है कि मेरे अगले साल उसे हटा दिया गया था। अब शायद वह सबकी तरह साधारण AI class बन गई है, जो थोड़ा अफसोसजनक है। मुझे अभी भी Prolog के बहुत अच्छे practical uses नहीं मिले, लेकिन GOAL ने कहीं ज़्यादा गहरा असर छोड़ा। और हाल में जाकर एहसास हुआ कि उसकी संरचना को ज़्यादा “सामान्य” भाषाओं में भी दोहराया जा सकता है, और ऐसा करने के अपने काफ़ी फायदे हैं—यह जानकर थोड़ा अजीब लगा
    • क्या यहाँ GOAL से मतलब Game Oriented Assembly Lisp है?

  • मैं इस बात से सहमत हूँ कि “अलग-अलग तरह की भाषाएँ सीखनी चाहिए।” OCaml सीखने के बाद ही functions सच में गणितीय functions जैसे लगे, Mathematica ने expressions को अपने-आप में input की तरह देखना सिखाया, और PostScript की reverse Polish notation ने साधारण arithmetic से आगे बढ़कर सोचने का तरीका ही फिर से तारबद्ध कर दिया। लेकिन मैं इस बात से सहमत नहीं कि Java, C#, C++, Python, Ruby में से कोई भी चुन लो, कोई फर्क नहीं पड़ता। अगर लक्ष्य सिर्फ़ quicksort implement करना है, तो शायद वे काफ़ी समान लगें; लेकिन जो लोग सच में कुछ बनाना चाहते हैं, उनके लिए भाषा का चुनाव रात और दिन जितना बड़ा अंतर पैदा करता है। जो 3D game बनाना चाहता हो उसे Ruby, या exploratory data science और deep learning करना चाहने वाले को Java पहले पकड़ा देने से उसका उत्साह टूट सकता है

    • शायद मैं Rust से कभी पैसे न कमाऊँ, लेकिन उसे सीखने का मुझे बिल्कुल पछतावा नहीं है। Rust ने program के भीतर data ownership के बारे में बहुत गहराई से सोचने पर मजबूर किया

  • यह पढ़कर Bruce Tate की 7 languages in 7 weeks याद आ गई। उसी किताब से मैंने पहली बार Erlang देखा था। हालांकि ऐतिहासिक रूप से COBOL और Fortran को Algol परिवार में रखना थोड़ा ज़ोर-जबर्दस्ती जैसा लगता है, लेकिन इससे यह याद ज़रूर आता है कि इतिहास स्वभाव से कुछ हद तक reductionist summary होता ही है

    • और पीछे जाकर कोई आदिम classification तय करना भी मुझे उतना ही कठिन लगता है। शुरुआती assembly languages भी imperative थीं, लेकिन Algol, Fortran, Cobol को दिलचस्प बनाने वाली बात यह थी कि उन्होंने functions और दूसरे high-level features के ज़रिए complex programming को संभव बनाया। वंशज सबसे ज़्यादा Algol के हैं, लेकिन पहली imperative programming language मैं Fortran को मानता हूँ
    • Wikipedia देखें तो Fortran और Algol दोनों ही 1957 के आसपास विकसित हुई लगती हैं, लेकिन असल में कौन पहले आई, और design process में आपसी प्रभाव या overlap था या नहीं, यह जानने की जिज्ञासा है
    • बल्कि COBOL को जीवित fossil की तरह देखना ज़्यादा ठीक नहीं होगा क्या। और आज का Fortran मुझे FORTRAN परिवार पर आधारित, लेकिन Algol lineage की विशेषताएँ horizontal transfer से ले चुका language जैसा लगता है

  • इससे जुड़ी पुरानी HN चर्चा भी थी। पिछली चर्चा साथ में देखें तो संदर्भ समझने में मदद मिलती है

    • ठीक-ठीक कहें तो वह 4 मई 2023 की चर्चा थी और उसमें 323 comments थे। इससे पुरानी एक यह thread भी 30 सितंबर 2021 की थी, और उसमें 29 comments थे