Ada: उसका डिज़ाइन और वह भाषा जिसने भाषाएँ बनाईं

 (iqiipi.com)
4 पॉइंट द्वारा GN⁺ 2026-04-18 | 1 टिप्पणियां | WhatsApp पर शेयर करें
  • 1970 के दशक में अमेरिकी रक्षा विभाग के सॉफ़्टवेयर अव्यवस्था के बीच जन्मी Ada एक ऐसी भाषा है जिसकी मुख्य विशेषताएँ strong static typing और specification-implementation separation हैं
  • package संरचना और representational invisibility के जरिए यह पूर्ण encapsulation लागू करती है, और बाद में Java·C#·Go जैसी आधुनिक भाषाओं के module systems को प्रभावित करती है
  • semantic constraint types, generic, concurrency(task), contract-based design जैसी अवधारणाएँ Ada ने कई दशक पहले पेश की थीं, जिन्हें बाद में Haskell·Rust·Swift आदि ने आगे बढ़ाया
  • SPARK Ada formal verification के जरिए data race और logical errors तक को हटाता है, और aviation·railway·defense systems जैसे high-reliability क्षेत्रों में इस्तेमाल होता है
  • Ada भले ही जनप्रिय भाषा न हो, लेकिन “चुपचाप सही ढंग से काम करने वाली भाषा” के रूप में यह आधुनिक programming language design के मूल सिद्धांतों की आधारशिला है

Ada की उत्पत्ति की पृष्ठभूमि और डिज़ाइन दर्शन

  • 1970 के दशक की शुरुआत में अमेरिकी रक्षा विभाग(DoD) ने हथियार, logistics और communication systems में 450 से अधिक भाषाओं और dialects के मिश्रण वाली स्थिति का अध्ययन किया
    • हर system में interoperability की कमी, maintenance की असंभवता, और मूल लेखक के अनुपस्थित होने जैसी समस्याएँ थीं
    • इससे software procurement crisis पैदा हुआ
  • DoD ने मौजूदा भाषाएँ (COBOL, Fortran, PL/1 आदि) अपनाने के बजाय, 5 साल तक requirements definition की प्रक्रिया चलाई
    • Strawman → Woodenman → Tinman → Ironman → Steelman दस्तावेज़ों तक विकास हुआ
    • Steelman(1978) ने explicit interface separation, strong static typing, built-in concurrency, consistent exception handling, machine independence, readability और verifiability की मांग की
  • 1979 में 4 टीमों (Green, Red, Blue, Yellow) के बीच प्रतिस्पर्धा में Jean Ichbiah के नेतृत्व वाली Green टीम चुनी गई और उसका नाम Ada रखा गया
    • यह नाम Ada Lovelace के सम्मान में रखा गया था और भाषा के उद्देश्य का प्रतीक था

package संरचना और encapsulation

  • Ada की केंद्रीय संरचना package है, जिसमें specification और body भौतिक रूप से अलग होते हैं
    • specification बाहरी रूप से दिखाई देने वाला contract है, जबकि body implementation है, और compiler दोनों के संबंध को enforce करता है
    • client code specification में न होने वाले तत्वों तक पहुँच नहीं सकता
  • यह संरचना module system के prototype जैसी है, जिसे बाद की भाषाओं ने आंशिक रूप से अपनाया
    • Java, Python, JavaScript, C, Go, Rust में भी Ada जैसी पूर्ण structural separation नहीं है
  • private type में केवल नाम दिखता है और उसका internal representation पूरी तरह opaque रहता है
    • client type की आंतरिक संरचना नहीं जान सकता और केवल अनुमति प्राप्त operations ही उपयोग कर सकता है
    • यह Java के private access control से भी अधिक शक्तिशाली representational invisibility है
  • Java और C# ने कई दशकों में धीरे-धीरे Ada-स्तर के encapsulation की दिशा में विकास किया

type system और semantic constraints

  • Ada type और subtype के अंतर को गणितीय अर्थ में परिभाषित करती है
    • उदाहरण: type Age is range 0 .. 150 range constraint के साथ एक अलग type बनाता है
    • गलत types के बीच passing को compile-time error के रूप में पकड़ा जाता है
  • 1983 के समय Ada का type system, C, Fortran और Pascal की तुलना में कहीं अधिक expressive था
    • semantic constraint types के जरिए domain errors को रोका जाता था
  • discriminated record ऐसी संरचना है जिसमें value के आधार पर fields बदलते हैं
    • यह आधुनिक भाषाओं के sum type या algebraic data type(ADT) के समान है
    • Haskell, Rust, Swift, Kotlin, TypeScript आदि ने कई दशक बाद यही अवधारणा अपनाई

generic और polymorphism

  • Ada के generic ऐसे units हैं जो type, value, subprogram और package को parameters के रूप में लेते हैं
    • यह compile time पर type checking करने वाला static polymorphism(parametric polymorphism) लागू करता है
  • C++(1990), Java(2004), C#(2005), Go(2022) आदि ने Ada के कई दशक बाद समान सुविधाएँ जोड़ीं
    • Java में type erasure के कारण runtime type information खो जाती है
    • Ada runtime type preservation और package parameterization तक को support करता है
  • Ada के generic higher-kinded polymorphism स्तर की expressive power देते हैं
    • Haskell के type classes, Rust के traits, और C++20 के concepts जैसी अवधारणाओं से मिलते-जुलते

concurrency model और safety

  • Ada में 1983 से ही language-level concurrency(task) built-in है
    • task declaration और rendezvous communication model के जरिए shared state के बिना message passing लागू किया जाता है
    • Go के channel इसी CSP(Communicating Sequential Processes) परिवार की अवधारणा हैं
  • Ada 95 ने protected object पेश किया
    • यह data access को सुरक्षित रखता है और procedure, function, entry में विभाजित होता है
    • automatic barrier conditions और lock-free synchronization देता है
  • SPARK Ada formal verification के जरिए यह गणितीय रूप से सिद्ध करता है कि data race, exceptions, range errors, और pre/postcondition violations नहीं होंगे
    • जहाँ Rust का borrow checker केवल memory safety सुनिश्चित करता है, SPARK logical consistency तक सिद्ध कर सकता है

contract-based design और null safety

  • Ada 2012 ने contracts को भाषा में एकीकृत किया
    • precondition, postcondition, और type invariant को स्पष्ट रूप से लिखा जा सकता है
    • SPARK toolchain इन्हें static proof में इस्तेमाल करती है
  • Eiffel(1986) की Design by Contract अवधारणा को भाषा-स्तर पर औपचारिक रूप दिया गया
    • C++, Java, Python, Rust आदि अभी भी आंशिक या library-level implementations तक सीमित हैं
  • Ada 2005 ने not null type पेश किया, जिससे compile-time null exclusion संभव हुआ
    • default रूप से runtime exception(Constraint_Error) के जरिए safe failure सुनिश्चित होती है
    • यह C# 8.0 के nullable reference जैसी पद्धति है

exception handling संरचना

  • Ada 83 ने सबसे पहले structured exception handling प्रस्तुत किया
    • exception को declare करने के बाद उपयोग किया जाता है, scope स्तर पर handle किया जाता है, और propagation rules स्पष्ट हैं
  • Java की checked exception Ada से अधिक विकसित रूप है, जहाँ caller को exception स्पष्ट करना होता है
    • Ada exception propagation को स्वतंत्र रूप से अनुमति देती है
  • Rust exceptions को हटाकर Result type आधारित error handling अपनाता है
    • Ada का योगदान यह था कि उसने exception propagation को structured और predictable बनाया

Annex और standardization संरचना

  • Ada standard में Annex नाम की optional extension संरचना है
    • Annex C~H system, real-time, distributed, numeric, और high-reliability क्षेत्रों की सुविधाएँ परिभाषित करते हैं
    • compiler को हर Annex के लिए independent certification लेना होता है
  • ACAA के ACATS tests के जरिए standard conformance की जाँच होती है
    • DO-178C aviation software certification में Ada की standard संरचना सीधे उपयोगी हो सकती है
    • C/C++ भी वही certification पा सकते हैं, लेकिन Ada संरचनात्मक रूप से अधिक उपयुक्त है

Ada का प्रभाव और पहचान का असंतुलन

  • Ada एक government-led language होने के कारण Silicon Valley की संस्कृति में खास ध्यान नहीं पा सकी
    • यह C-आधारित संक्षिप्त syntax को पसंद करने वाली संस्कृति से विपरीत थी
  • Ada की सफलताएँ (aviation, railway, defense systems) विफलता न होने के कारण कम दिखाई देती हैं
    • उच्च विश्वसनीयता वाले systems आम तौर पर चर्चा या घटनाएँ पैदा नहीं करते
  • आधुनिक भाषाओं की विकास दिशा उन सिद्धांतों की ओर जा रही है जिन्हें Ada पहले ही प्रस्तुत कर चुकी थी
    • specification-implementation separation, static type verification, language-level concurrency, contract-based safety आदि
  • Ada आज भी aircraft, railway, spacecraft जैसे high-reliability systems में संचालन में है, “चुपचाप सही ढंग से काम करने वाली भाषा” के रूप में बनी हुई है

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

1 टिप्पणियां

 
GN⁺ 2026-04-18
Hacker News की राय

  • मुझे Ada पसंद है। लेकिन type handling की बात करते हुए ML परिवार की भाषाओं (ML, SML, CML, Caml, OCaml आदि) को पूरी तरह छोड़ देना हैरान करने वाला था
    ये भाषाएँ compiler स्तर पर structural typing को support करती हैं। Ada की समस्या यह थी कि PL/I, PHP, Perl की तरह भाषा खुद ही बहुत बड़ी थी और उसका syntax जटिल था। लेख में इसे उसकी ताकत बताया गया है, लेकिन मेरी नज़र में Annex के रूप में अलग किए गए standard extensions ज़्यादा बेहतर थे। अगर core language को छोटा रखा जाता और Annex-केंद्रित दिशा अपनाई जाती, तो शायद इसका इस्तेमाल अधिक व्यापक होता

    • ML भाषाओं में user सीधे bounded Integer/Floating point types define नहीं कर सकता। Ada की core capabilities में से एक यही type system है। Ada का type system इस्तेमाल करके देखें तो हैरानी होती है कि code quality और reliability कितनी बढ़ जाती है

  • Ada के नज़रअंदाज़ किए जाने का एक कारण compiler की कीमत भी थी, जो कई दसियों हज़ार डॉलर तक होती थी। जब free या open source compiler नहीं थे, तब दूसरी भाषाएँ मुफ़्त में इस्तेमाल की जा सकती थीं। वही निर्णायक कारक था

    • Ada niche से बाहर नहीं आ पाया, इसके पीछे कई वजहें थीं। भाषा की जटिलता और उस समय की compiler technology के कारण यह 1980s के microcomputers पर ठीक से चल नहीं पाता था। Intel ने Ada के concepts को hardware में उतारकर i432 बनाया, लेकिन उसकी performance बहुत खराब थी। बाद में microcomputers ने दुनिया पर कब्ज़ा कर लिया और C व assembly की विरासत 20 साल से भी ज़्यादा चली
    • मैंने Ada कुछ साल इस्तेमाल किया, लेकिन सहकर्मियों का शौकिया तौर पर दूसरी भाषाएँ इस्तेमाल करना Ada के फैलाव में मददगार नहीं था। string processing भी कमजोर थी, और गति भी धीमी थी। खासकर concurrency handling असुविधाजनक था क्योंकि वह OS threads का उपयोग नहीं करता था। आख़िर में HPUX के real-time extension का उपयोग करके उसे कई processes में चलाना पड़ा
    • 90s के मध्य से GNAT मौजूद था, और उस समय commercial compilers भी आम थे। Ada के अटक जाने की वजह यह धारणा थी कि इसमें ‘अनावश्यक overhead’ है। यानी military या safety systems के अलावा इसे इस्तेमाल करने का कारण नहीं है, ऐसी reputation बन गई थी
    • GNU Ada Compiler(GNAT) पहली बार 1995 में जारी हुआ
    • सच कहें तो 80s में किसी भी भाषा के compiler बहुत अच्छे नहीं थे। GCC भी बाद के दौर में जाकर ही उपयोगी बना। नई भाषा अपनाने पर immature compiler मिलना स्वाभाविक था। C++ भी उस समय Ada से काफी पीछे था, और ‘C++ की killer feature’ दरअसल यही थी कि उसे C की तरह इस्तेमाल किया जा सकता था। अगर Ada ने Pascal compatibility mode दिया होता, तो शायद इतिहास अलग होता

  • लेख पढ़ते हुए Ada और खुद लेख दोनों दिलचस्प लगे, लेकिन कुछ तथ्यात्मक त्रुटियाँ नज़र आईं। उदाहरण के लिए, यह कहा गया कि implementation और specification को पूरी तरह अलग करने वाली केवल Ada है, जबकि JavaScript में भी ES6 modules के भीतर private elements define किए जा सकते हैं। Java के private visibility के बारे में भी विवरण गलत था। ऐसी गलतियों से लेख की विश्वसनीयता कम हो जाती है

    • Ada में private type define करने पर बाहरी code उसके internal fields तक पहुँच नहीं सकता। इसके उलट JavaScript में किसी भी object में मनचाहे properties जोड़ी या हटाई जा सकती हैं। यानी Ada की compile-time protection का स्तर JS से तुलना योग्य नहीं है
    • Java में reflection के ज़रिए private members तक पहुँचा जा सकता है। setAccessible(true) से String के भीतर की चीज़ें भी बदली जा सकती हैं
    • यह बात प्रभावशाली लगी कि जब LLM इंसानी पाठकों के लिए लिखता है, तो वह Gell-Mann amnesia की तरह काम करता है

  • लेख कुल मिलाकर अच्छा था, लेकिन बार-बार दोहराया गया “भाषा X में यह feature Ada के बाद आया” वाला वाक्य उबाऊ लगने लगा। अगर code examples होते, तो बात कहीं अधिक प्रभावशाली होती

    • दरअसल Ada की बहुत-सी खूबियाँ पहले की भाषाओं (PASCAL, CLU, MODULA, CSP आदि) से उधार ली गई थीं। यह पूरी तरह नए concepts का आविष्कार नहीं था, बल्कि परखी हुई ideas का एकीकरण था
    • जिन concepts के बारे में दावा किया गया कि Ada ने उन्हें पहले पेश किया, उनमें से कई वास्तव में अलग तरीके से implement किए गए थे। इसलिए तुलना वाले examples की ज़रूरत थी
    • यह लेख “Ada सबसे श्रेष्ठ है” कहने के लिए नहीं, बल्कि यह दिखाने के लिए है कि Ada ने safety और reliability के लिए किस तरह की design choices कीं। वर्षों की तुलना उसी संदर्भ में मायने रखती है
    • मैंने Claude से Ada demo code माँगा था, और वह काफ़ी अच्छा निकला। मैं Ada को लंबे समय से जानता था, लेकिन उसे खुद आज़माने के बाद FOMO महसूस हुआ
    • Ada developer के नज़रिए से देखें, तो इस तरह की comparison pattern दशकों से दोहराई जाती रही है, इसलिए यह थकाने वाली लग सकती है

  • यह Twitter अकाउंट अप्रैल 2026 में बनाया गया था, और लेखक का नाम साफ़ तौर पर नहीं दिया गया है। कम समय में बहुत ज़्यादा उत्पादकता दिखाई गई, इसलिए नाम छिपा होना दिलचस्प लगा

    • कुछ लोगों की राय है कि लेखक का नाम नहीं है क्योंकि यह एक bot है

  • “पिछले 20 सालों में हर भाषा ने sum type जोड़ा, लेकिन Ada में वह शुरू से था” — यह दावा सही है, लेकिन इसकी उत्पत्ति Ada नहीं है। Hope भाषा या NPL उससे पहले थे

    • वास्तव में sum type की उत्पत्ति 1964 में John McCarthy के पेपर “Definition of new data types in ALGOL X” से जुड़ी है। उन्होंने UNION keyword प्रस्तावित किया था, और बाद में ALGOL 68, Hope, Miranda आदि में यह विकसित हुआ। C का union इस concept से अलग है

  • यह लेख इतना पसंद आया कि मन किया काश यह AI द्वारा लिखा हुआ न हो, लेकिन Twitter पर पोस्ट की गति इतनी तेज़ थी कि शक होना स्वाभाविक था

    • लेख थोड़ा लंबा-खिंचा और दोहराव वाला लगा, इसलिए AI जैसा एहसास हुआ
    • आजकल blog posts को अपने-आप rewrite करने वाले AI tools बहुत हैं, इसलिए शक पैदा होता है
    • मैंने भी लेख मज़े से पढ़ा, लेकिन 110 em dash देखने के बाद ही दिमाग़ में आया, “कहीं यह AI तो नहीं?” अब blog posts को भी media literacy के साथ पढ़ना पड़ता है, यह दुखद है
    • मैंने भी 3 साल में 50 लेख लिखे हैं, लेकिन उनमें से ज़्यादातर अब तक प्रकाशित नहीं हुए। शायद इस लेखक के साथ भी ऐसा ही रहा हो और उसने हाल ही में हिम्मत जुटाई हो। AI समझ लिया जाना कितना निराशाजनक हो सकता है, यह मैं समझ सकता हूँ
    • अगर AI इस स्तर का लेख लिख सकता है, तो समय लगने की कीमत पर भी वह मूल्यवान है

  • अमेरिकी वायुसेना मूल रूप से Ada इस्तेमाल करना चाहती थी, लेकिन development में देरी हुई, इसलिए JOVIAL का उपयोग किया गया। मैंने 1981 में JOVIAL पर अपना पहला project किया था, और उस समय Ada अभी specification चरण में था

    • JOVIAL, ALGOL 60 के पूर्वरूप IAL से निकली भाषा थी, और उसने Ada के शुरुआती requirements (STRAWMAN~STEELMAN) को प्रभावित किया। बाद में Ada ने JOVIAL की खूबियों को बेहतर बनाते हुए in/out parameter annotation जैसी innovations पेश कीं। इसी वजह से C++ जैसी जटिल copy constructors या move semantics की ज़रूरत नहीं पड़ी

  • साइट के मुख्य पृष्ठ पर “यह कोई stand नहीं, बल्कि एक proposal है” जैसी पंक्ति है, और उसी के आधार पर दावा किया गया कि यह AI से लिखा गया साइट है

    • लेकिन वह वाक्य AI-लेखन का प्रमाण नहीं है

  • लेख में कहा गया कि “JavaScript का module system, Ada की तरह type की internal representation नहीं छिपा सकता”, लेकिन वास्तव में JS modules में अगर export न किया जाए तो चीज़ें पर्याप्त रूप से छिपाई जा सकती हैं। इसलिए यह सवाल उठा कि Ada सच में किस तरह बेहतर है

    • TypeScript के नज़रिए से देखें तो भी, JS objects में बाहर से properties जोड़ी या बदली जा सकती हैं। Ada में private type instances पर defined API के बाहर कोई manipulation संभव नहीं है
    • एक ठोस उदाहरण के लिए यह टिप्पणी देखी जा सकती है