एडा (प्रोग्रामिंग भाषा)

Ada

Paradigm	Multi-paradigm: structured, imperative, object-oriented, aspect-oriented, concurrent, array, distributed, generic, procedural, meta
परिवार	Pascal
द्वारा डिज़ाइन किया गया	MIL-STD-1815, Ada 83: Jean Ichbiah Ada 95: Tucker Taft Ada 2005: Tucker Taft Ada 2012: Tucker Taft
पहली प्रस्तुति	February 1980 (1980-02)
Stable release	Ada 2012 TC1
टाइपिंग अनुशासन	static, strong, safe, nominative
ओएस	Multi- or cross-platform
फ़ाइल नाम एक्सटेंशनएस	.adb, .ads
वेबसाइट	www.adaic.org
Major implementations
AdaCore GNAT, Green Hills Software Optimising Ada 95 compiler, PTC ApexAda and ObjectAda, MapuSoft Ada-C/C++ changer, formerly known as "AdaMagic with C Intermediate", DDC-I Score
Dialects
SPARK, Ravenscar profile
Influenced by
ALGOL 68, Pascal, Simula 67, C++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influenced
C++, Chapel, Drago, D, Eiffel, Griffin, Java, Nim, ParaSail, PL/SQL, PL/pgSQL, Python, Ruby, Seed7, SPARforte, Sparkel, SQL/PSM, VHDL
Ada Programming at Wikibooks

एडा पास्कल और अन्य भाषाओं से विस्तारित एक संरचित, सांख्यिकीय रूप से टाइप की गई, अनिवार्य और वस्तु-उन्मुख उच्च-स्तरीय प्रोग्रामिंग भाषा है। इसमें अनुबंध द्वारा डिज़ाइन(DbC) के लिए अंतर्निहित भाषा समर्थन, अत्यंत मजबूत टाइपिंग, स्पष्ट संगामिति, कार्य, तुल्यकालिक संदेश पासिंग, संरक्षित वस्तुएँ और अनियतता है। एडा रनटाइम (प्रोग्राम जीवनचक्र चरण) त्रुटियों के पक्ष में त्रुटियों को खोजने के लिए संकलक का उपयोग करके कोड सुरक्षा और रखरखाव में सुधार करता है। एडा एक अंतर्राष्ट्रीय तकनीकी मानक है, जिसे अंतर्राष्ट्रीय मानकीकरण संगठन (ISO) और अंतर्राष्ट्रीय विद्युत तकनीकी आयोग (IEC) द्वारा संयुक्त रूप से परिभाषित किया गया है। 2020 तक, मानक, जिसे एडा 2012 अनौपचारिक रूप से कहा जाता है, ISO/IEC 8652:2012 है।

एडा को मूल रूप से 1977 से 1983 तक संयुक्त राज्य अमेरिका के रक्षा विभाग (DoD) के अनुबंध के तहत CII हनीवेल बुल के फ्रांसीसी कंप्यूटर वैज्ञानिक जीन इचबियाह के नेतृत्व में एक समूह द्वारा डिज़ाइन किया गया था, जो उस समय DoD द्वारा उपयोग की जाने वाली 450 से अधिक प्रोग्रामिंग भाषाओं को अधिक्रमण करता था।

एडा का नाम लवलेस है (1815-1852) के नाम पर रखा गया था, जिन्हें पहले कंप्यूटर प्रोग्रामर के रूप में श्रेय दिया जाता है। रेफरी>Fuegi, J; Francis, J (2003). "लवलेस और बैबेज और 1843 'नोट्स' का निर्माण". IEEE Annals of the History of Computing. 25 (4): 16–26. doi:10.1109/MAHC.2003.1253887. S2CID 40077111.</रेफरी>

सुविधाएँ

एडा मूल रूप से एम्बेडेड और रीयल-टाइम सिस्टम के लिए डिज़ाइन किया गया था। 1992 और 1995 के बीच इंटरमेट्रिक्स के एस. टकर टैफ़्ट द्वारा डिज़ाइन किया गया एडीए 95 संशोधन, सिस्टम, संख्यात्मक, वित्तीय और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (ओओपी) के लिए बेहतर समर्थन करता है।

एडीए की विशेषताओं में सम्मिलित हैं: मजबूत और कमजोर प्ररूपण, मॉड्यूलर प्रोग्रामिंग मैकेनिज्म (पैकेज), रन-टाइम जाँच, समानांतर कंप्यूटिंग (टास्क (कंप्यूटिंग), सिंक्रोनस संदेश देना, प्रोटेक्टेड ऑब्जेक्ट्स और नॉनडेटर्मिनिस्टिक स्विच स्टेटमेंट), एक्सेप्शन हेंडलिंग और सामान्य प्रोग्रामिंग। Ada 95 ने गतिशील प्रेषण सहित ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के लिए समर्थन जोड़ा।

Ada का सिंटैक्स बुनियादी संचालन करने के तरीकों के विकल्पों को कम करता है, और अंग्रेजी कीवर्ड (जैसे या और और फिर) को प्रतीकों (जैसे || और &&) के लिए पसंद करता है। एडा बुनियादी अंकगणितीय ऑपरेटरों का उपयोग करता है + , - , * , और / , लेकिन अन्य प्रतीकों का उपयोग करने से बचता है। कोड ब्लॉक को डिक्लेयर, स्टार्ट और एंड जैसे शब्दों द्वारा सीमांकित किया जाता है, जहां अंत (ज्यादातर मामलों में) ब्लॉक के पहचानकर्ता के बाद बंद हो जाता है (जैसे, अगर ... अंत अगर, लूप ... एंड लूप) . सशर्त ब्लॉक के मामले में यह एक और झूलने से बचता है जो सी या जावा जैसी अन्य भाषाओं में गलत नेस्टेड इफ-एक्सप्रेशन के साथ जुड़ सकता है।

Ada को बहुत बड़े सॉफ्टवेयर सिस्टम विकसित करने के लिए डिज़ाइन किया गया है। Ada संकुल को अलग से संकलित किया जा सकता है। एडीए पैकेज विनिर्देशों (पैकेज इंटरफ़ेस) को भी कार्यान्वयन के बिना स्थिरता की जांच के लिए अलग से संकलित किया जा सकता है। इससे कार्यान्वयन प्रारंभ होने से पहले, डिजाइन चरण के समय समस्याओं का जल्द पता लगाना संभव हो जाता है।

कुछ अन्य भाषाओं में रन-टाइम तक पता लगाने योग्य नहीं होने वाली बग से बचने में सहायता के लिए बड़ी संख्या में संकलन-समय की जांच का समर्थन किया जाता है या स्रोत कोड में स्पष्ट जांच की आवश्यकता होती है। उदाहरण के लिए, बेमेल अंत टोकन के कारण त्रुटियों को रोकने के लिए सिंटैक्स को स्पष्ट रूप से ब्लॉक के नाम की आवश्यकता होती है। मजबूत प्ररूपण का पालन या तो संकलन-समय के समय, या अन्यथा रन-टाइम के समय कई सामान्य सॉफ़्टवेयर त्रुटियों (गलत पैरामीटर, सीमा उल्लंघन, अमान्य संदर्भ, बेमेल प्रकार, आदि) का पता लगाने की अनुमति देता है। जैसा कि संगामिति भाषा विनिर्देश का हिस्सा है, संकलक कुछ मामलों में संभावित गतिरोधों का पता लगा सकता है। कंपाइलर आमतौर पर गलत वर्तनी वाले पहचानकर्ताओं, पैकेजों की दृश्यता, निरर्थक घोषणाओं आदि की जांच करते हैं और त्रुटि को ठीक करने के तरीके पर चेतावनी और उपयोगी सुझाव प्रदान कर सकते हैं।

Ada बिना आवंटित मेमोरी, बफ़र अधिकता एरर, रेंज उल्लंघन, ऑफ-बाय-वन एरर, एरे एक्सेस एरर और अन्य डिटेक्टेबल बग्स तक पहुंच से बचाने के लिए रन-टाइम चेक का भी समर्थन करता है। रनटाइम दक्षता के हित में इन चेकों को अक्षम किया जा सकता है, लेकिन प्रायः इन्हें कुशलतापूर्वक संकलित किया जा सकता है। इसमें सॉफ्टवेयर सत्यापन में सहायता के लिए सुविधाएं भी सम्मिलित हैं। इन कारणों से, Ada का व्यापक रूप से महत्वपूर्ण प्रणालियों में उपयोग किया जाता है, जहां सॉफ़्टवेयर में कोई भी विसंगति बहुत गंभीर परिणाम दे सकती है, जैसे, आकस्मिक मृत्यु, चोट या गंभीर वित्तीय हानि। सिस्टम के उदाहरण जहां एडीए का उपयोग किया जाता है उनमें हवाई जहाज, हवाई यातायात नियंत्रण, रेलवे, बैंकिंग, सैन्य और अंतरिक्ष प्रौद्योगिकी सम्मिलित हैं। हालांकि भाषा के सिमेंटिक्स दुर्गम वस्तुओं के स्वत: कचरा संग्रह (कंप्यूटर विज्ञान) की अनुमति देते हैं, अधिकांश कार्यान्वयन डिफ़ॉल्ट रूप से इसका समर्थन नहीं करते हैं, क्योंकि यह रीयल-टाइम सिस्टम में अप्रत्याशित व्यवहार का कारण होगा। Ada क्षेत्र-आधारित स्मृति प्रबंधन के सीमित रूप का समर्थन करता है; इसके अलावा, भंडारण पूल का रचनात्मक उपयोग स्वत: कचरा संग्रह का एक सीमित रूप प्रदान कर सकता है, क्योंकि भंडारण पूल को नष्ट करने से पूल में सभी वस्तुओं को भी नष्ट कर दिया जाता है।

एक डबल-डैश (--), एक एम डैश जैसा दिखता है, टिप्पणी पाठ को दर्शाता है। स्रोत कोड के पूरे अनुभागों को गलती से शून्य करने से अनजान टिप्पणियों को रोकने के लिए टिप्पणियां पंक्ति के अंत में रुकती हैं। कोड के एक पूरे ब्लॉक को अक्षम करने के लिए अब प्रत्येक पंक्ति (या कॉलम) को व्यक्तिगत रूप से - के साथ उपसर्ग करने की आवश्यकता है। पृष्ठ के नीचे बार-बार कॉलम के साथ अक्षम कोड को स्पष्ट रूप से इंगित करते हुए यह बड़े ब्लॉकों के प्रयोगात्मक अक्षम/पुनः सक्षम करने को एक अधिक खींची गई प्रक्रिया प्रदान करता है।

अर्धविराम ( ; ) एक बयान टर्मिनेटर है, और अशक्त या नो-ऑपरेशन स्टेटमेंट है null;. एक भी ; एक बयान के बिना समाप्त करने की अनुमति नहीं है।

मानकीकरण मानकों के लिए अधिकांश अंतर्राष्ट्रीय संगठन के विपरीत, एडीए भाषा परिभाषा (एडीए संदर्भ मैनुअल या एआरएम, या कभी-कभी भाषा संदर्भ मैनुअल या एलआरएम के रूप में जाना जाता है) मुफ्त सामग्री है। इस प्रकार, यह Ada प्रोग्रामर के लिए एक सामान्य संदर्भ है, न कि केवल Ada कंपाइलर को लागू करने वाले प्रोग्रामर। संदर्भ पुस्तिका के अलावा, एक व्यापक औचित्य दस्तावेज भी है जो भाषा के डिजाइन और विभिन्न भाषा निर्माणों के उपयोग की व्याख्या करता है। यह दस्तावेज़ प्रोग्रामर द्वारा भी व्यापक रूप से उपयोग किया जाता है। जब भाषा को संशोधित किया गया, तो एक नया औचित्य दस्तावेज़ लिखा गया।

[[GNAT प्रोग्रामिंग स्टूडियो]] और GNAT GNU कम्पाइलर संग्रह का एक भाग है, GNAT प्रोग्रामिंग स्टूडियो और GNAT एक उल्लेखनीय मुफ्त सॉफ्टवेयर टूल है जिसका उपयोग कई Ada प्रोग्रामर उन्हें Ada स्रोत कोड लिखने में सहायता करने के लिए करते हैं।

इतिहास

1970 के दशक में यूनाइटेड स्टेट्स डिपार्टमेंट ऑफ डिफेंस (DoD) अपने एम्बेडेड कंप्यूटर सिस्टम प्रोजेक्ट्स के लिए उपयोग की जा रही विभिन्न प्रोग्रामिंग भाषाओं की संख्या से चिंतित हो गया, जिनमें से कई अप्रचलित या हार्डवेयर-निर्भर थे, और इनमें से कोई भी सुरक्षित मॉड्यूलर प्रोग्रामिंग का समर्थन नहीं करता था। 1975 में, एक कार्यकारी समूह, हाई ऑर्डर लैंग्वेज वर्किंग ग्रुप (HOLWG) का गठन किया गया था, जो इस संख्या को कम करने के इरादे से विभाग और रक्षा मंत्रालय (यूनाइटेड किंगडम) की आवश्यकताओं के लिए आमतौर पर उपयुक्त प्रोग्रामिंग भाषा खोज या बना रहा था। . मूल स्ट्रॉ मैन प्रस्ताव से प्रारंभ होने वाले कई पुनरावृत्तियों के बाद अंतिम प्रोग्रामिंग भाषा का नाम एडा रखा गया। ऐसी परियोजनाओं के लिए उपयोग की जाने वाली उच्च-स्तरीय प्रोग्रामिंग भाषाओं की कुल संख्या 1983 में 450 से गिरकर 1996 तक 37 हो गई।

HOLWG ने स्टीलमैन भाषा की आवश्यकताओं को तैयार किया, दस्तावेजों की एक श्रृंखला जिसमें उन आवश्यकताओं को बताया गया है जो उन्हें लगा कि एक प्रोग्रामिंग भाषा को संतुष्ट करना चाहिए। कई मौजूदा भाषाओं की औपचारिक रूप से समीक्षा की गई, लेकिन टीम ने 1977 में निष्कर्ष निकाला कि कोई भी मौजूदा भाषा विनिर्देशों को पूरा नहीं करती है।

एक नई प्रोग्रामिंग भाषा के प्रस्तावों के लिए अनुरोध जारी किए गए थे और रेड (बेंजामिन ब्रोसगोल के नेतृत्व में इंटरमेट्रिक्स), ग्रीन (जीन इचिबिया के नेतृत्व में सीआईआई हनीवेल बुल), ब्लू (सोफटेक, इंक। , जॉन गुडइनफ के नेतृत्व में) और येलो (श्री इंटरनेशनल, जे स्पिट्जन के नेतृत्व में)। अप्रैल 1978 में, सार्वजनिक जांच के बाद, लाल और हरे रंग के प्रस्ताव अगले चरण में पारित हो गए। मई 1979 में, CII हनीवेल बुल में जीन इचिबियाह द्वारा डिजाइन किए गए ग्रीन प्रस्ताव को चुना गया और एडा लवलेस के बाद एडा नाम दिया गया। ऑगस्टा एडा, काउंटेस ऑफ लवलेस। यह प्रस्ताव उस भाषा LIS (प्रोग्रामिंग लैंग्वेज) से प्रभावित था जिसे इचबियाह और उनके समूह ने 1970 के दशक में विकसित किया था। प्रारंभिक एडीए संदर्भ मैनुअल जून 1979 में एसीएम सिगप्लान नोटिस में प्रकाशित हुआ था। सैन्य मानक संदर्भ मैनुअल को 10 दिसंबर, 1980 (एडा लवलेस का जन्मदिन) पर अनुमोदित किया गया था, और एडा लवलेस के जन्म वर्ष के सम्मान में नंबर एमआईएल-एसटीडी-1815 दिया गया था। 1981 में, C. A. R. होरे ने अपने ट्यूरिंग अवार्ड भाषण का लाभ उठाते हुए एडा की अत्यधिक जटिल होने और इसलिए अविश्वसनीय होने की आलोचना की, लेकिन बाद में ऐसा लगा जैसे उसने एक ऐडा पाठ्यपुस्तक के लिए लिखी गई प्रस्तावना में फिर से लिखा हो।

एडा ने अपने प्रारम्भिक दिनों में प्रोग्रामिंग समुदाय का बहुत ध्यान आकर्षित किया। इसके समर्थकों और अन्य लोगों ने भविष्यवाणी की कि यह सामान्य प्रयोजन प्रोग्रामिंग के लिए एक प्रमुख भाषा बन सकती है, न कि केवल रक्षा संबंधी कार्य।इचबिया ने सार्वजनिक रूप से कहा कि दस वर्षों के भीतर, केवल दो प्रोग्रामिंग भाषाएं रह जाएंगी: एडा और लिस्प (प्रोग्रामिंग भाषा)। प्रारंभिक एडीए संकलक बड़ी, जटिल भाषा को लागू करने के लिए संघर्ष करते थे, और संकलन-समय और रन-टाइम प्रदर्शन दोनों ही धीमे और उपकरण आदिम थे। कंपाइलर विक्रेताओं ने अपने अधिकांश प्रयासों को बड़े पैमाने पर, भाषा-अनुरूपता-परीक्षण, सरकार द्वारा आवश्यक ACVC सत्यापन सूट को पारित करने में खर्च किया, जो कि Ada भाषा के प्रयास की एक और उपन्यास सुविधा में आवश्यक था।1975-1983 में प्रारंभ हुई कंप्यूटर हैकर स्लैंग की डिक्शनरी, जारगॉन फाइल, on Ada में नोट करती है कि यह ठीक वही है जिसकी कोई उम्मीद कर सकता है। फिएट द्वारा उस तरह का समर्थन; समिति द्वारा डिज़ाइन किया गया ... उपयोग करने में मुश्किल, और कुल मिलाकर एक विनाशकारी, बहु-अरब-डॉलर का वरदान ... एडा लवलेस ... लगभग निश्चित रूप से उसके नाम का उपयोग करने पर ब्लैंक हो जाएगा; इसके बारे में जो सबसे अच्छी बात कही गई है, वह यह है कि इसके विशाल, हाथी के झुंड के अंदर से बाहर निकलने के लिए शायद एक अच्छी छोटी भाषा चिल्ला रही है।

पहला मान्य Ada कार्यान्वयन NYU Ada/Ed अनुवादक था, 11 अप्रैल, 1983 को प्रमाणित। NYU Ada/Ed उच्च-स्तरीय सेट भाषा SETL में लागू किया गया है। कई वाणिज्यिक कंपनियों ने एडा कम्पाइलर और संबद्ध विकास उपकरणों की पेशकश प्रारंभ की, जिसमें अलसिस, टेलीसॉफ्ट, डीडीसी-I, उन्नत कंप्यूटर तकनीक, टार्टन प्रयोगशालाएं, इरविन संकलक, टीएलडी सिस्टम्स और वेदिक्स सम्मिलित हैं। कंप्यूटर निर्माता जिनका रक्षा, एयरोस्पेस, या संबंधित उद्योगों में महत्वपूर्ण व्यवसाय था, उन्होंने भी अपने प्लेटफॉर्म पर एडा कंपाइलर और टूल्स की पेशकश की; इनमें समवर्ती कंप्यूटर कॉर्पोरेशन, क्रे रिसर्च, इंक., हैरिस कंप्यूटर सिस्टम्स, और सीमेंस निक्सडॉर्फ सूचना प्रणाली एजी सम्मिलित हैं।

1991 में, अमेरिकी रक्षा विभाग ने सभी सॉफ्टवेयर के लिए एडीए (एडीए मैंडेट) के उपयोग की आवश्यकता प्रारंभ की, हालांकि इस नियम के अपवाद प्रायः दिए गए थे। 1997 में डिपार्टमेंट ऑफ डिफेन्स ऐडा मैंडेट को प्रभावी ढंग से हटा दिया गया था, क्योंकि DoD ने व्यावसायिक बिकने वाला (वाणिज्यिक ऑफ-द-शेल्फ) तकनीक को अपनाना प्रारंभ कर दिया था। अन्य उत्तरी अटलांटिक संधि संगठन देशों में भी इसी तरह की आवश्यकताएं मौजूद थीं: नाटो प्रणालियों के लिए एडीए की आवश्यकता थी जिसमें कमांड और नियंत्रण और अन्य कार्य सम्मिलित थे, और एडीए स्वीडन, जर्मनी और कनाडा जैसे देशों में रक्षा संबंधी अनुप्रयोगों के लिए अनिवार्य या पसंदीदा भाषा थी। 1980 के दशक के अंत और 1990 के दशक के प्रारंभ तक, एडा कंपाइलर्स के प्रदर्शन में सुधार हुआ था, लेकिन एडा की क्षमताओं का पूरी तरह से दोहन करने में अभी भी बाधाएं थीं, जिसमें एक टास्किंग मॉडल भी सम्मिलित था, जो कि वास्तविक समय के प्रोग्रामरों के लिए उपयोग किए जाने वाले मॉडल से अलग था।

एडा के सुरक्षा-महत्वपूर्ण प्रणाली|सेफ्टी-क्रिटिकल सपोर्ट फीचर्स के कारण, अब इसका उपयोग न केवल सैन्य अनुप्रयोगों के लिए किया जाता है, बल्कि व्यावसायिक परियोजनाओं में भी किया जाता है, जहां एक सॉफ्टवेयर बग के गंभीर परिणाम हो सकते हैं, जैसे, एवियोनिक्स और हवाई यातायात नियंत्रण, वाणिज्यिक रॉकेट जैसे एरियन (रॉकेट परिवार), उपग्रह और अन्य अंतरिक्ष प्रणालियाँ, रेलवे परिवहन और बैंकिंग।उदाहरण के लिए, हवाई जहाज सूचना प्रबंधन प्रणाली, विमान उड़ान नियंत्रण प्रणाली|बोइंग 777 में फ्लाई-बाय-वायर सिस्टम सॉफ्टवेयर, एडा में लिखा गया था। डीडीसी-I के सलाहकारों के सहयोग से हनीवेल एयरोस्पेस द्वारा विकसित, यह यकीनन किसी भी एडीए परियोजना, नागरिक या सेना के लिए सबसे प्रसिद्ध बन गया। कैनेडियन ऑटोमेटेड एयर ट्रैफिक सिस्टम को एडा (कोड काउंट की सोर्स लाइन) की 1 मिलियन लाइनों में लिखा गया था। इसमें उन्नत वितरित प्रसंस्करण, एक वितरित एडीए डेटाबेस और ऑब्जेक्ट-ओरिएंटेड डिज़ाइन सम्मिलित हैं। Ada का उपयोग अन्य हवाई यातायात प्रणालियों में भी किया जाता है, उदाहरण के लिए, यूके की अगली पीढ़ी के अंतरिम भविष्य क्षेत्र नियंत्रण उपकरण समर्थन (iFACTS) हवाई यातायात नियंत्रण प्रणाली को स्पार्क (प्रोग्रामिंग भाषा) एडा का उपयोग करके डिजाइन और कार्यान्वित किया गया है। इसका उपयोग TGV हाई-स्पीड रेल सिस्टम पर फ्रांस ट्रैक-मशीन ट्रांसमिशन इन-कैब सिग्नलिंग सिस्टम और पेरिस, लंदन, हांगकांग और न्यूयॉर्क शहर में मेट्रो उपनगरीय ट्रेनों में भी किया जाता है।

मानकीकरण

प्रारंभिक अदायगी ACM Sigplan Notes Vol 14, No 6, June 1979 में देखी जा सकती है।

Ada को पहली बार 1980 में एक अमेरिकी राष्ट्रीय मानक संस्थान मानक ANSI/MIL-STD 1815 के रूप में प्रकाशित किया गया था। चूंकि इस पहले संस्करण में कई त्रुटियां और विसंगतियां थीं (देखें Ada Language Changes का सारांश), संशोधित संस्करण 1983 में ANSI/MIL-STD 1815A के रूप में प्रकाशित हुआ था। बिना किसी और बदलाव के, यह 1987 में एक ISO मानक बन गया, ISO 8652:1987। भाषा के इस संस्करण को आमतौर पर एएनएसआई द्वारा अपनाए जाने की तारीख से एडीए 83 के रूप में जाना जाता है, लेकिन कभी-कभी आईएसओ द्वारा इसे अपनाने की तारीख से इसे एडीए 87 भी कहा जाता है। यह Ada 83 संदर्भ मैनुअल है। एक फ्रेंच अनुवाद भी है; DIN ने 1988 में DIN 66268 के रूप में इसका जर्मन में अनुवाद किया।

Ada 95, संयुक्त ISO/IEC/ANSI मानक ISO/IEC 8652:1995 (देखें /मानक/ADA-95-दस्तावेज़/lrm-मूल/Ada 95 RM) फरवरी 1995 में प्रकाशित हुआ था, जिससे यह पहली ISO मानक वस्तु-उन्मुख प्रोग्रामिंग भाषा बन गई। मानक संशोधन और भविष्य की स्वीकृति में मदद करने के लिए, अमेरिकी वायु सेना ने जीएनएटी कंपाइलर के विकास को वित्त पोषित किया। वर्तमान में, जीएनएटी कंपाइलर जीएनयू कंपाइलर संग्रह का हिस्सा है।

एडा भाषा की तकनीकी सामग्री में सुधार और अद्यतन करने पर काम जारी है। Ada 95 के लिए एक तकनीकी शुद्धिपत्र अक्टूबर 2001 में प्रकाशित हुआ था, ISO/IEC 8652:1995/Corr 1:2001 (देखें .org/standards/95lrm/html/RM-TTL.html Ada 95 RM with TC 1), और एक प्रमुख संशोधन, ISO/IEC 8652:1995 /अमद 1:2007 (देखें Ada 2005 RM) 9 मार्च, 2007 को प्रकाशित हुआ था, जिसे आमतौर पर इस रूप में जाना जाता है Ada 2005 क्योंकि उस साल नए मानक पर काम पूरा हो गया था।

स्टॉकहोम में एडा-यूरोप 2012 सम्मेलन में, एडा रिसोर्स एसोसिएशन (एआरए) और एडा-यूरोप ने एडा भाषा के नवीनतम संस्करण के डिजाइन को पूरा करने और आईएसओ/आईईसी जेटीसी 1/ को संदर्भ मैनुअल जमा करने की घोषणा की। मानकीकरण के लिए अंतर्राष्ट्रीय संगठन (आईएसओ) के एससी 22/डब्ल्यूजी 9 और अनुमोदन के लिए अंतर्राष्ट्रीय इलेक्ट्रोटेक्निकल कमीशन (आईईसी)। ISO/IEC 8652:2012 (देखें html Ada 2012 RM) दिसंबर 2012 में प्रकाशित हुआ था, जिसे Ada 2012 के नाम से जाना जाता है। एक तकनीकी शुद्धिपत्र प्रकाशित किया गया था ISO/IEC 8652:2012/COR 1:2016 (देखें TC 1 के साथ RM 2012)।

Ada 83, 95 आदि नामों के बावजूद, कानूनी रूप से केवल एक Ada मानक है, अंतिम ISO/IEC मानक में से एक: एक नए मानक संस्करण की स्वीकृति के साथ, पिछला वाला वापस ले लिया जाता है। अन्य नाम केवल एक निश्चित संस्करण को संदर्भित करने वाले अनौपचारिक हैं।

अन्य संबंधित मानकों में ISO 8651|ISO/IEC 8651-3:1988 इन्फॉर्मेशन प्रोसेसिंग सिस्टम-कंप्यूटर ग्राफिक्स-ग्राफिकल कर्नेल सिस्टम (GKS) लैंग्वेज बाइंडिंग-पार्ट 3: Ada सम्मिलित हैं।

भाषा निर्माण

Ada एक ALGOL जैसी प्रोग्रामिंग भाषा है, जिसमें आरक्षित शब्दों के साथ नियंत्रण संरचना होती है, जैसे कि if, then, else, while, for, इत्यादि। हालाँकि, Ada के पास कई डेटा संरचना सुविधाएँ और अन्य सार हैं जो मूल ALGOL 60 में सम्मिलित नहीं थे, जैसे कि प्रकार प्रणाली, रिकॉर्ड (कंप्यूटर साइंस), पॉइंटर (कंप्यूटर प्रोग्रामिंग), प्रगणित प्रकार इस तरह के निर्माण आंशिक रूप से पास्कल (प्रोग्रामिंग भाषा) से विरासत में मिले या उससे प्रेरित थे।

=== हैलो, दुनिया! अदा === में किसी भाषा के सिंटैक्स (प्रोग्रामिंग भाषा) का एक सामान्य उदाहरण हैलो वर्ल्ड प्रोग्राम है: (हैलो। एडीबी) <वाक्यविन्यास लैंग = एडीए लाइन> Ada.Text_IO के साथ; प्रक्रिया हैलो है प्रारंभ करना

  Ada.Text_IO.Put_Line (हैलो, दुनिया!);with Ada.Text_IO;

procedure Hello is
begin
   Ada.Text_IO.Put_Line ("Hello, world!");
end Hello;

अंत हैलो; </वाक्यविन्यास हाइलाइट> इस प्रोग्राम को निष्पादित करके मुक्त रूप से उपलब्ध ओपन सोर्स कंपाइलर GNAT का उपयोग करके संकलित किया जा सकता है

gnatmake hello.adb

डेटा प्रकार

एडा की प्रकार प्रणाली पूर्वनिर्धारित आदिम प्रकारों के एक सेट पर आधारित नहीं है, लेकिन उपयोगकर्ताओं को अपने स्वयं के प्रकार घोषित करने की अनुमति देती है। बदले में यह घोषणा प्रकार के आंतरिक प्रतिनिधित्व पर आधारित नहीं है बल्कि उस लक्ष्य का वर्णन करने पर आधारित है जिसे हासिल किया जाना चाहिए। यह संकलक को प्रकार के लिए उपयुक्त मेमोरी आकार निर्धारित करने की अनुमति देता है, और संकलन समय और रन टाइम (यानी, सीमा उल्लंघन, बफर ओवररन, टाइप स्थिरता इत्यादि) पर प्रकार परिभाषा के उल्लंघन की जांच करने की अनुमति देता है। Ada एक श्रेणी, सापेक्ष प्रकार, समग्र प्रकार (रिकॉर्ड और सरणियाँ), और गणना प्रकार द्वारा परिभाषित संख्यात्मक प्रकारों का समर्थन करता है। एक्सेस प्रकार निर्दिष्ट प्रकार के उदाहरण के संदर्भ को परिभाषित करते हैं; अनटाइप्ड पॉइंटर्स की अनुमति नहीं है। भाषा द्वारा प्रदान किए गए विशेष प्रकार कार्य प्रकार और संरक्षित प्रकार हैं।

उदाहरण के लिए, दिनांक को इस प्रकार दर्शाया जा सकता है:

type Day_type is range 1 .. 31;

type Month_type is range 1 .. 12;

type Year_type is range 1800 .. 2100;

type Hours is mod 24;

type Weekday is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

type Date is

record

Day  : Day_type;

Month : Month_type;

Year  : Year_type;

end record;

नोट करने के लिए महत्वपूर्ण: Day_type, Month_type, Year_type, घंटे असंगत प्रकार हैं, जिसका अर्थ है कि उदाहरण के लिए निम्न अभिव्यक्ति अवैध है:

Today: Day_type := 4;

Current_Month: Month_type := 10;

... Today + Current_Month ... -- illegal

पूर्वनिर्धारित जोड़-संक्रियक केवल उसी प्रकार के मान जोड़ सकता है, इसलिए अभिव्यक्ति अवैध है।

उपप्रकार घोषित करके प्रकारों को परिष्कृत किया जा सकता है:

subtype Working_Hours is Hours range 0 .. 12; -- at most 12 Hours to work a day

subtype Working_Day is Weekday range Monday .. Friday; -- Days to work

Work_Load: constant array(Working_Day) of Working_Hours -- implicit type declaration

:= (Friday => 6, Monday => 4, others => 10); -- lookup table for working hours with initialization

प्रकारों में संशोधक हो सकते हैं जैसे सीमित, सार, निजी आदि। निजी प्रकार अपनी आंतरिक संरचना नहीं दिखाते हैं; सीमित प्रकार की वस्तुओं की नकल नहीं की जा सकती। Ada 95 प्रकार के वस्तु-उन्मुख एक्सटेंशन वृद्धि के लिए और सुविधाएँ जोड़ता है।

नियंत्रण संरचना

एडा एक संरचित प्रोग्रामिंग भाषा है, जिसका अर्थ है कि नियंत्रण का प्रवाह मानक बयानों में संरचित है। सभी मानक निर्माण और डीप-लेवल अर्ली एग्जिट समर्थित हैं, इसलिए समर्थित गोटो (कमांड) कमांड के उपयोग की शायद ही कभी आवश्यकता होती है।

-- while a is not equal to b, loop.

while a /= b loop

Ada.Text_IO.Put_Line ("Waiting");

end loop;

if a > b then

  Ada.Text_IO.Put_Line ("Condition met");
else
  Ada.Text_IO.Put_Line ("Condition not met");
end if;

for i in 1 .. 10 loop

Ada.Text_IO.Put ("Iteration: ");

Ada.Text_IO.Put (i);

Ada.Text_IO.Put_Line;

end loop;

loop

  a := a + 1;
  exit when a = 10;
end loop;

 case i is

  when 0 => Ada.Text_IO.Put ("zero");
  when 1 => Ada.Text_IO.Put ("one");
  when 2 => Ada.Text_IO.Put ("two");
  -- case statements have to cover all possible cases:
  when others => Ada.Text_IO.Put ("none of the above");
end case;

for aWeekday in Weekday'Range loop -- loop over an enumeration

Put_Line ( Weekday'Image(aWeekday) ); -- output string representation of an enumeration

if aWeekday in Working_Day then -- check of a subtype of an enumeration

Put_Line ( " to work for " &

Working_Hours'Image (Work_Load(aWeekday)) ); -- access into a lookup table

end if;

end loop;

पैकेज, प्रक्रियाएं और कार्य

Ada प्रोग्राम के कुछ हिस्सों में पैकेज, प्रक्रियाएँ और कार्य सम्मिलित हैं।

उदाहरण: पैकेज विनिर्देश (example.ads) <वाक्यविन्यास लैंग = एडीए लाइन> पैकेज उदाहरण है

    package Example is

     type Number is range 1 .. 11;
     procedure Print_and_Increment (j: in out Number);
end Example;

with Ada.Text_IO; package body Example is

i : Number := Number'First;

  procedure Print_and_Increment (j: in out Number) is

    function Next (k: in Number) return Number is
    begin
      return k + 1;
    end Next;

   begin

    Ada.Text_IO.Put_Line ( "The total is: " & Number'Image(j) );
    j := Next (j);
  end Print_and_Increment;

  begin

    Ada.Text_IO.Put_Line ( "The total is: " & Number'Image(j) );
    j := Next (j);
  end Print_and_Increment;

-- package initialization executed when the package is elaborated

begin

while i < Number'Last loop

Print_and_Increment (i);

end loop;

end Example;

इस प्रोग्राम को संकलित किया जा सकता है, उदाहरण के लिए, स्वतंत्र रूप से उपलब्ध मुक्त स्रोत संकलक GNAT का उपयोग करके, निष्पादित करके

gnatmake -z example.adb

संकुल, प्रक्रियाएं और कार्य किसी भी गहराई तक घोंसला बना सकते हैं, और प्रत्येक तार्किक बाहरीतम ब्लॉक भी हो सकता है।

प्रत्येक पैकेज, प्रक्रिया या प्रकार्य में स्थिरांक, प्रकार, चर और अन्य प्रक्रियाओं, कार्यों और पैकेजों की अपनी घोषणाएँ हो सकती हैं, जिन्हें किसी भी रन-टाइम में घोषित किया जा सकता है।

समवर्ती

Ada के पास कार्य-आधारित संगामिति के लिए भाषा समर्थन है। एडा में मौलिक समवर्ती इकाई एक कार्य है, जो एक अंतर्निहित सीमित प्रकार है। कार्य दो भागों में निर्दिष्ट हैं - कार्य घोषणा कार्य इंटरफ़ेस को परिभाषित करती है (एक प्रकार की घोषणा के समान), कार्य निकाय कार्य के कार्यान्वयन को निर्दिष्ट करता है। कार्यान्वयन के आधार पर, Ada कार्यों को या तो ऑपरेटिंग सिस्टम थ्रेड्स या प्रक्रियाओं में मैप किया जाता है, या Ada रनटाइम द्वारा आंतरिक रूप से शेड्यूल किया जाता है।

कार्य में तुल्यकालन के लिए प्रविष्टियाँ हो सकती हैं (संदेश पास करने का एक रूप)। टास्क प्रविष्टियों को टास्क स्पेसिफिकेशन में घोषित किया जाता है। प्रत्येक कार्य प्रविष्टि में कार्य निकाय के भीतर एक या अधिक स्वीकृत कथन हो सकते हैं। यदि कार्य का नियंत्रण प्रवाह एक स्वीकार कथन तक पहुँच जाता है, तो कार्य को तब तक अवरुद्ध कर दिया जाता है जब तक कि संबंधित प्रविष्टि को किसी अन्य कार्य द्वारा नहीं कहा जाता है (इसी तरह, एक कॉलिंग कार्य तब तक अवरुद्ध रहता है जब तक कि कार्य को संबंधित स्वीकृति कथन तक नहीं पहुँच जाता)। कार्य प्रविष्टियों में प्रक्रियाओं के समान पैरामीटर हो सकते हैं, जिससे कार्यों को समकालिक रूप से डेटा का आदान-प्रदान करने की अनुमति मिलती है। चुनिंदा बयानों के संयोजन के साथ स्वीकार्य बयानों पर गार्ड को परिभाषित करना संभव है (दिज्क्स्ट्रा के संरक्षित आदेशों के समान)।

Ada पारस्परिक बहिष्करण के लिए संरक्षित वस्तुएँ भी प्रदान करता है। संरक्षित वस्तुएं एक मॉनिटर (सिंक्रनाइज़ेशन) | मॉनिटर जैसी संरचना हैं, लेकिन सिग्नलिंग के लिए सशर्त चर के अतिरिक्त गार्ड का उपयोग करें (सशर्त महत्वपूर्ण क्षेत्रों के समान)। संरक्षित वस्तुएं डेटा एनकैप्सुलेशन और मॉनिटर से सुरक्षित पारस्परिक बहिष्करण और सशर्त महत्वपूर्ण क्षेत्रों से प्रवेश गार्ड को जोड़ती हैं। शास्त्रीय मॉनिटरों पर मुख्य लाभ यह है कि संकेतन के लिए सशर्त चर की आवश्यकता नहीं होती है, गलत लॉकिंग शब्दार्थ के कारण संभावित गतिरोध से बचा जाता है। कार्यों की तरह, संरक्षित वस्तु एक अंतर्निहित सीमित प्रकार है, और इसमें एक घोषणा भाग और एक निकाय भी है।

एक संरक्षित वस्तु में एनकैप्सुलेटेड निजी डेटा (जिसे केवल संरक्षित वस्तु के भीतर से ही एक्सेस किया जा सकता है), और प्रक्रियाएं, कार्य और प्रविष्टियां होती हैं, जो पारस्परिक रूप से अनन्य होने की गारंटी होती हैं (केवल कार्यों के अपवाद के साथ, जिन्हें साइड इफेक्ट मुक्त होना आवश्यक है) और इसलिए अन्य कार्यों के साथ समवर्ती रूप से चल सकता है)। संरक्षित वस्तु को कॉल करने वाला कार्य अवरुद्ध हो जाता है यदि कोई अन्य कार्य वर्तमान में उसी संरक्षित वस्तु के अंदर निष्पादित हो रहा है, और जब यह अन्य कार्य संरक्षित वस्तु को छोड़ देता है तो उसे छोड़ दिया जाता है। आगमन के समय आदेशित संरक्षित वस्तु पर अवरुद्ध कार्य कतारबद्ध हैं।

संरक्षित वस्तु प्रविष्टियाँ प्रक्रियाओं के समान हैं, लेकिन अतिरिक्त रूप से गार्ड हैं। यदि कोई गार्ड असत्य का मूल्यांकन करता है, तो एक कॉलिंग कार्य अवरुद्ध हो जाता है और उस प्रविष्टि की कतार में जुड़ जाता है; अब किसी अन्य कार्य को संरक्षित वस्तु में प्रवेश दिया जा सकता है, क्योंकि वर्तमान में संरक्षित वस्तु के अंदर कोई कार्य निष्पादित नहीं हो रहा है। जब भी कोई कार्य संरक्षित वस्तु को छोड़ता है तो गार्ड का पुनर्मूल्यांकन किया जाता है, क्योंकि यह एकमात्र समय है जब गार्ड का मूल्यांकन बदल सकता है।

प्रविष्टियों के लिए कॉल को उसी हस्ताक्षर के साथ अन्य प्रविष्टियों के लिए आवश्यक किया जा सकता है। जिस कार्य की आवश्यकता होती है उसे अवरुद्ध कर दिया जाता है और लक्ष्य प्रविष्टि की कतार में जोड़ दिया जाता है; इसका मतलब है कि संरक्षित वस्तु जारी की जाती है और किसी अन्य कार्य के प्रवेश की अनुमति देती है।

एडीए में चयन कथन का उपयोग गैर-अवरुद्ध प्रविष्टि कॉलों को लागू करने के लिए किया जा सकता है और प्रविष्टियों के गैर-नियतात्मक चयन (गार्ड के साथ भी), टाइम-आउट और गर्भपात को स्वीकार करता है।

निम्नलिखित उदाहरण एडा में समवर्ती प्रोग्रामिंग की कुछ अवधारणाओं को दिखाता है।

with Ada.Text_IO; use Ada.Text_IO;

procedure Traffic is

 type Airplane_ID is range 1..10;             -- 10 airplanes

  task type Airplane (ID: Airplane_ID);        -- task representing airplanes, with ID as initialisation parameter

   type Airplane_Access is access Airplane;     -- reference type to Airplane

  protected type Runway is                     -- the shared runway (protected to allow concurrent access)

      entry Assign_Aircraft (ID: Airplane_ID);  -- all entries are guaranteed mutually exclusive
      entry Cleared_Runway (ID: Airplane_ID);
      entry Wait_For_Clear;
   private
      Clear: Boolean := True;                   -- protected private data - generally more than only a flag...
   end Runway;
   type Runway_Access is access all Runway;

   -- the air traffic controller task takes requests for takeoff and landing

   task type Controller (My_Runway: Runway_Access) is
      -- task entries for synchronous message passing
      entry Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access);
      entry Request_Approach(ID: in Airplane_ID; Approach: out Runway_Access);
   end Controller;

  --  allocation of instances

   Runway1    : aliased Runway;              -- instantiate a runway
   Controller1: Controller (Runway1'Access); -- and a controller to manage it

  ------ the implementations of the above types ------

   protected body Runway is
      entry Assign_Aircraft (ID: Airplane_ID)
 when Clear is   -- the entry guard - calling tasks are blocked until the condition is true
      begin
       Clear := False;
       Put_Line (Airplane_ID'Image (ID) & " on runway ");
      end;

      entry Cleared_Runway (ID: Airplane_ID)

 when not Clear is
      begin
         Clear := True;
         Put_Line (Airplane_ID'Image (ID) & " cleared runway ");
      end;

      entry Wait_For_Clear
 when Clear is
      begin
         null;      -- no need to do anything here - a task can only enter if "Clear" is true
      end;
   end Runway;

    entry Wait_For_Clear

 when Clear is
      begin
         null;      -- no need to do anything here - a task can only enter if "Clear" is true
      end;
   end Runway;

  task body Controller is

   begin
      loop
         My_Runway.Wait_For_Clear;   -- wait until runway is available (blocking call)
         select                      -- wait for two types of requests (whichever is runnable first)
            when Request_Approach'count = 0 =>  -- guard statement - only accept if there are no tasks queuing on Request_Approach
             accept Request_Takeoff (ID: in Airplane_ID; Takeoff: out Runway_Access)
             do                                 -- start of synchronized part
               My_Runway.Assign_Aircraft (ID);  -- reserve runway (potentially blocking call if protected object busy or entry guard false)
               Takeoff := My_Runway;            -- assign "out" parameter value to tell airplane which runway
             end Request_Takeoff;               -- end of the synchronised part
         or
            accept Request_Approach (ID: in Airplane_ID; Approach: out Runway_Access) do
               My_Runway.Assign_Aircraft (ID);
               Approach := My_Runway;
            end Request_Approach;
         or                          -- terminate if no tasks left who could call
            terminate;
         end select;
      end loop;
   end;

   task body Airplane is

      Rwy : Runway_Access;
   begin
      Controller1.Request_Takeoff (ID, Rwy); -- This call blocks until Controller task accepts and completes the accept block
      Put_Line (Airplane_ID'Image (ID) & "  taking off...");
      delay 2.0;
      Rwy.Cleared_Runway (ID);               -- call will not block as "Clear" in Rwy is now false and no other tasks should be inside protected object
      delay 5.0; -- fly around a bit...
      loop
         select   -- try to request a runway
            Controller1.Request_Approach (ID, Rwy); -- this is a blocking call - will run on controller reaching accept block and return on completion
            exit; -- if call returned we're clear for landing - leave select block and proceed...
         or
            delay 3.0;  -- timeout - if no answer in 3 seconds, do something else (everything in following block)
            Put_Line (Airplane_ID'Image (ID) & "   in holding pattern");  -- simply print a message
         end select;
      end loop;
      delay 4.0;  -- do landing approach...
      Put_Line (Airplane_ID'Image (ID) & "            touched down!");
      Rwy.Cleared_Runway (ID);  -- notify runway that we're done here.
   end;

   task body Airplane is

   New_Airplane: Airplane_Access;

begin

for I in Airplane_ID'Range loop -- create a few airplane tasks

      New_Airplane := new Airplane (I); -- will start running directly after creation
      delay 4.0;
   end loop;
end Traffic;

प्रागमा

एक प्रागमा एक संकलक निर्देश है जो संकलित आउटपुट के विशिष्ट परिवर्तन की अनुमति देने के लिए संकलक को जानकारी देता है। कुछ प्रागमा भाषा में निर्मित हैं, जबकि अन्य कार्यान्वयन-विशिष्ट हैं।

संकलक प्रागमा के सामान्य उपयोग के उदाहरण कुछ सुविधाओं को अक्षम करना होगा, जैसे रन-टाइम प्रकार जांच या सरणी अधोलिखित सीमा जांच, या संकलक को प्रकार्य निर्देश के अतिरिक्त वस्तु कोड डालने का निर्देश देना (जैसा कि C/C ++ पंक्‍तिबद्धता फ़ंक्शन के साथ करता है) )

जेनरिक

यह अनुभाग एडा में जेनेरिक प्रोग्रामिंग § जेनरिक का एक अंश है।

1977-1980 में पहली बार डिजाइन किए जाने के बाद से एडा के पास जेनरिक हैं। मानक पुस्तकालय कई सेवाएं प्रदान करने के लिए जेनरिक का उपयोग करता है। Ada 2005 मानक पुस्तकालय में एक व्यापक जेनेरिक कंटेनर पुस्तकालय जोड़ता है, जो C++ के मानक आदर्श पुस्तकालय से प्रेरित था। एक जेनरिक इकाई एक पैकेज या उपप्रोग्राम है जो एक या अधिक जेनरिक रूपात्मक पैरामीटर लेता है।

एक जेनरिक रूपात्मक पैरामीटर एक मूल्य, एक चर, एक स्थिरांक, एक प्रकार, एक उपप्रोग्राम, या यहां तक कि किसी अन्य, नामित, जेनरिक इकाई का एक उदाहरण है। सामान्य औपचारिक प्रकारों के लिए, सिंटैक्स असतत, फ्लोटिंग-पॉइंट, फिक्स्ड-पॉइंट, एक्सेस (पॉइंटर) प्रकारों आदि के बीच अंतर करता है। कुछ औपचारिक मापदंडों में व्यतिक्रम मान हो सकते हैं।

एक जेनरिक इकाई को दृष्टांत करने के लिए, प्रोग्रामर प्रत्येक औपचारिक के लिए वास्तविक पैरामीटर पास करता है। जेनरिक दृष्टांत तब किसी अन्य इकाई की तरह ही व्यवहार करता है। रन-टाइम पर जेनेरिक इकाइयों को दृष्टांत करना संभव है, उदाहरण के लिए लूप के अंदर।

यह भी देखें

• APSE - एडा में सॉफ्टवेयर विकास का समर्थन करने के लिए एक प्रोग्रामिंग वातावरण के लिए एक विनिर्देश
• रेवेन्सकर प्रोफ़ाइल - सुरक्षा-महत्वपूर्ण कठिन वास्तविक समय कंप्यूटिंग के लिए डिज़ाइन की गई एडा टास्किंग विशेषताओ का एक उपसमूह
• स्पार्क (प्रोग्रामिंग लैंग्वेज) - एक प्रोग्रामिंग लैंग्वेज जिसमें एडा का एक अत्यधिक प्रतिबंधित उपसमुच्चय सम्मिलित है, जिसे वांछित घटक व्यवहार और व्यक्तिगत रन-टाइम आवश्यकताओं का वर्णन करने वाली मेटा-सूचना के साथ टिप्पणी किया गया है।

संदर्भ

अंतर्राष्ट्रीय मानक

• ISO 8652|ISO/IEC 8652: सूचना प्रौद्योगिकी—प्रोग्रामिंग भाषाएं—एडा
• ISO 15291|ISO/IEC 15291: सूचना प्रौद्योगिकी—प्रोग्रामिंग भाषाएँ—Ada सिमेंटिक इंटरफ़ेस विशिष्टता (विकट:ASIS)
• ISO 18009|ISO/IEC 18009: सूचना प्रौद्योगिकी—प्रोग्रामिंग भाषाएं—एडीए: एक भाषा संसाधक का अनुरूपता आकलन (विकट:एसीएटीएस)
• IEEE 1003|IEEE मानक 1003.5b-1996, POSIX Ada बाइंडिंग
• Ada Language Mapping विशिष्टता, CORBA इंटरफ़ेस विवरण भाषा (IDL) से एडा मैपिंग

औचित्य

इन दस्तावेजों को प्रिंट सहित विभिन्न रूपों में प्रकाशित किया गया है।

• Ichbiah, Jean D.; Barnes, John G. P.; Firth, Robert J.; Woodger, Mike (1986), Rationale for the Design of the Ada Programming Language, archived from the original on 2007-02-02 apps.dtic.mil, pdf भी उपलब्ध है
• Barnes, John G. P. (1995), Ada 95 rationale: the language: the standard libraries
• Barnes, John (2006) [2005], Rationale for Ada 2005

किताबें

• Booch, Grady (1987). एडा के साथ सॉफ्टवेयर इंजीनियरिंग. California: The Benjamin/Cummings Publishing Company. ISBN 0-8053-0604-8.
• Skansholm, Jan (1996). एडा 95 शुरुआत से. Addison-Wesley. ISBN 0-201-40376-5.
• Gilpin, Geoff (1985). एडा: ए गाइडेड टूर एंड ट्यूटोरियल. Prentice hall. ISBN 978-0-13-004045-9.
• Barnes, John (2006). एडा 2005 में प्रोग्रामिंग. Addison-Wesley. ISBN 0-321-34078-7.
• Barnes, John (1991). एडा प्लस लैंग्वेज रेफरेंस मैनुअल में प्रोग्रामिंग. Addison-Wesley. ISBN 0-201-56539-0.
• Barnes, John (1998). एडा 95 में प्रोग्रामिंग. Addison-Wesley. ISBN 0-201-34293-6.
• Barnes, John (1997). उच्च अखंडता एडीए: स्पार्क दृष्टिकोण. Addison-Wesley. ISBN 0-201-17517-7.
• Barnes, John (2003). उच्च अखंडता सॉफ्टवेयर: सुरक्षा और सुरक्षा के लिए स्पार्क दृष्टिकोण. Addison-Wesley. ISBN 0-321-13616-0.
• Beidler, John (1997). डेटा संरचनाएं और एल्गोरिदम: Ada 95 का उपयोग करके एक वस्तु-उन्मुख दृष्टिकोण. Springer-Verlag. ISBN 0-387-94834-1.
• Gonzalez, Dean W. (1991). एडा प्रोग्रामर की हैंडबुक. Benjamin-Cummings Publishing Company. ISBN 0-8053-2529-8.
• Ben-Ari, M. (1998). सॉफ्टवेयर इंजीनियरों के लिए एडीए. John Wiley & Sons. ISBN 0-471-97912-0.
• Cohen, Norman (1996). दूसरी भाषा के रूप में अदा. McGraw-Hill Science/Engineering/Math. ISBN 0-07-011607-5.
• Burns, Alan; Wellings, Andy (2001). रीयल-टाइम सिस्टम और प्रोग्रामिंग भाषाएं। एडीए 95, रीयल-टाइम जावा और रीयल-टाइम पॉज़िक्स।. Addison-Wesley. ISBN 0-201-72988-1.
• Burns, Alan; Wellings, Andy (1995). एडा में संगामिति. Cambridge University Press. ISBN 0-521-62911-X.
• Atkinson, Colin (1991). वस्तु-उन्मुख पुन: उपयोग, समरूपता और वितरण: एक एडा-आधारित दृष्टिकोण. Addison-Wesley. ISBN 0-201-56527-7.
• Booch, Grady; Bryan, Doug (1994). एडा के साथ सॉफ्टवेयर इंजीनियरिंग. Addison-Wesley. ISBN 0-8053-0608-0.
• Jones, Do-While (1989). एडीए इन एक्शन: व्यावहारिक प्रोग्रामिंग उदाहरणों के साथ. John Wiley & Sons. ISBN 0-471-60708-8.
• Stubbs, Daniel; Webre, Neil W. (1993). सार डेटा प्रकार और एडीए के साथ डेटा संरचनाएं. Brooks Cole. ISBN 0-534-14448-9.
• Ledru, Pascal (December 1998). संरक्षित वस्तुओं के साथ एडीए में वितरित प्रोग्रामिंग. Dissertation.com. ISBN 1-58112-034-6.
• Culwin, Fintan (1997). एडा, एक विकासात्मक दृष्टिकोण. Prentice Hall. ISBN 0-13-264680-3.
• English, John; Culwin, Fintan (January 1997). Ada 95 द क्राफ्ट ऑफ़ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग. Prentice Hall. ISBN 0-13-230350-7.
• Musser, David R.; Stepanov, Alexander (24 October 1989). एडा जेनेरिक लाइब्रेरी: लीनियर लिस्ट प्रोसेसिंग पैकेज. Springer-Verlag. ISBN 0-387-97133-5.
• Feldman, Michael B. (1997). एडा 95 के साथ सॉफ्टवेयर निर्माण और डेटा संरचनाएं. Addison-Wesley. ISBN 0-201-88795-9.
• Johnston, Simon (1997). C और C++ प्रोग्रामर्स के लिए Ada 95. Addison-Wesley. ISBN 0-201-40363-3.
• Feldman, Michael B.; Koffman, Elliot B. (1992–1993). एडीए: प्रॉब्लम सॉल्विंग एंड प्रोग्राम डिजाइन. Addison-Wesley. ISBN 0-201-52279-9. 795 पृष्ठ।
• Feldman, Michael B.; Koffman, Elliot B. (1999). 95 हैं. Addison-Wesley. ISBN 0-201-36123-X.
• Dale, Nell B.; Weems, Chip; McCormick, John (August 1996). एडा 95 के साथ प्रोग्रामिंग और समस्या समाधान. Jones & Bartlett Publishers. ISBN 0-7637-0293-5.
• Dale, Nell B.; McCormick, John (2007). एडा प्लस डेटा स्ट्रक्चर्स: एन ऑब्जेक्ट-ओरिएंटेड एप्रोच, दूसरा संस्करण. Jones & Bartlett Publishers. ISBN 978-0-7637-3794-8.
• Krell, Bruce C. (1992). एडा के साथ विकास: जीवन-चक्र के तरीके. Bantam Dell Pub Group. ISBN 0-553-09102-6.
• Bishop, Judy (10 May 1990). वितरित एडीए: विकास और अनुभव. Cambridge University Press. ISBN 0-521-39251-9.
• Sanden, Bo (1994). एडीए में उदाहरणों के साथ सॉफ्टवेयर सिस्टम निर्माण. Prentice Hall. ISBN 0-13-030834-X.
• Hillam, Bruce (1994). एडा का उपयोग कर सार डेटा प्रकार का परिचय. Prentice Hall. ISBN 0-13-045949-6.
• Rudd, David (1994). एडा के साथ सॉफ्टवेयर डिजाइन और विकास का परिचय. Brooks Cole. ISBN 0-314-02829-3.
• Pyle, Ian C. (1991). विकासशील सुरक्षा प्रणालियाँ: एडा का उपयोग करने वाली एक मार्गदर्शिका. Prentice Hall. ISBN 0-13-204298-3.
• Baker, Louis (1989). एडा के साथ आर्टिफिशियल इंटेलिजेंस. McGraw-Hill. ISBN 0-07-003350-1.
• Burns, Alan; Wellings, Andy (1995). HRT-HOOD: हार्ड रियल-टाइम Ada सिस्टम्स के लिए एक संरचित डिज़ाइन विधि. North-Holland. ISBN 0-444-82164-3.
• Savitch, Walter; Peterson, Charles (1992). एडा: प्रोग्रामिंग की कला और विज्ञान का एक परिचय. Benjamin-Cummings Publishing Company. ISBN 0-8053-7070-6.
• Weiss, Mark Allen (1993). एडीए में डेटा संरचनाएं और एल्गोरिथम विश्लेषण. Benjamin-Cummings Publishing Company. ISBN 0-8053-9055-3.
• Ledgard, Henry (1983). अदा: एक परिचय (second ed.). Springer-Verlag. ISBN 0-387-90814-5.
• Bjørner, Dines; Oest, Ole N., eds. (1980). एडा के एक औपचारिक विवरण की ओर. London: Springer-Verlag. ISBN 3-540-10283-3.

अभिलेखागार

• एडीए प्रोग्रामिंग भाषा सामग्री, 1981-1990। चार्ल्स बैबेज संस्थान, मिनेसोटा विश्वविद्यालय। Ada भाषा के लिए डिज़ाइन किए गए सॉफ़्टवेयर उत्पादों पर साहित्य सम्मिलित है; Ada 9X प्रोजेक्ट रिपोर्ट, तकनीकी रिपोर्ट, वर्किंग पेपर, न्यूज़लेटर सहित अमेरिकी सरकार के प्रकाशन; और उपयोगकर्ता समूह की जानकारी।