स्वयं (प्रोग्रामिंग भाषा)

Self

Paradigm	object-oriented (prototype-based)
द्वारा डिज़ाइन किया गया	David Ungar, Randall Smith
Developer	David Ungar, Randall Smith, Stanford University, Sun Microsystems
पहली प्रस्तुति	1987 (1987)
Stable release	Mandarin 2017.1 / May 24, 2017 (2017-05-24)
टाइपिंग अनुशासन	dynamic, strong
लाइसेंस	BSD-like license
वेबसाइट	www.selflanguage.org
Major implementations
Self
Influenced by
Smalltalk, APL
Influenced
NewtonScript, JavaScript, Io, Agora, Squeak, Lua, Factor, REBOL

Self एक वस्तु-उन्मुख प्रोग्रामिंग प्रोग्रामिंग भाषा है जो प्रोटोटाइप-आधारित प्रोग्रामिंग की अवधारणा पर आधारित है। स्वयं की शुरुआत स्मॉलटाक की एक बोली के रूप में हुई, जिसे गतिशील रूप से टाइप किया गया और समय-समय पर संकलन (JIT) के साथ-साथ वस्तुओं के लिए प्रोटोटाइप-आधारित दृष्टिकोण का उपयोग किया गया: यह पहली बार 1980 और 1990 के दशक में भाषा डिजाइन के लिए एक प्रायोगिक परीक्षण प्रणाली के रूप में उपयोग किया गया था। . 2006 में, सेल्फ अभी भी क्लेन प्रोजेक्ट के हिस्से के रूप में विकसित किया जा रहा था, जो सेल्फ वर्चुअल मशीन थी जो पूरी तरह से सेल्फ में लिखी गई थी। नवीनतम संस्करण 2017.1 मई 2017 में जारी किया गया है। स्व-अनुसंधान में कई जस्ट-इन-टाइम संकलन तकनीकों का बीड़ा उठाया गया और उनमें सुधार किया गया क्योंकि उन्हें एक उच्च स्तरीय वस्तु उन्मुख भाषा को अनुकूलित सी की आधी गति तक प्रदर्शन करने की अनुमति देने की आवश्यकता थी। स्व का अधिकांश विकास सूर्य में सन माइक्रोसिस्टम्स, और उनके द्वारा विकसित तकनीकों को बाद में जावा (प्रोग्रामिंग भाषा) के [[हॉटस्पॉट (आभासी मशीन )]] वर्चुअल मशीन के लिए तैनात किया गया था।

एक बिंदु पर स्मालटाक का एक संस्करण स्वयं में लागू किया गया था। क्योंकि यह JIT का उपयोग करने में सक्षम था, इसने भी बहुत अच्छा प्रदर्शन दिया।

इतिहास

स्वयं को 1986 में PARC (कंपनी) में काम करते हुए ज्यादातर डेविड अनगर और रान्डेल स्मिथ द्वारा डिजाइन किया गया था। उनका उद्देश्य ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज रिसर्च में कला की स्थिति को आगे बढ़ाना था, जब स्मॉलटॉक | स्मॉलटाक -80 प्रयोगशालाओं द्वारा जारी किया गया था और उद्योग द्वारा इसे गंभीरता से लिया जाने लगा। वे स्टैनफोर्ड विश्वविद्यालय चले गए और 1987 में पहले वर्किंग सेल्फ कंपाइलर का निर्माण करते हुए भाषा पर काम करना जारी रखा।

पहली सार्वजनिक रिलीज़ 1990 में हुई थी, और अगले साल टीम सन माइक्रोसिस्टम्स में चली गई जहाँ उन्होंने भाषा पर काम जारी रखा। 1995 में 4.0 संस्करण के साथ बड़े पैमाने पर निष्क्रिय होने तक कई नए रिलीज़ हुए। 4.3 संस्करण 2006 में जारी किया गया था और macOS और Solaris (ऑपरेटिंग सिस्टम) पर चलता था। 2010 में एक नई रिलीज, संस्करण 4.4, एक समूह द्वारा विकसित किया गया है जिसमें कुछ मूल टीम और स्वतंत्र प्रोग्रामर शामिल हैं और यह मैक ओएस एक्स और लिनक्स के लिए उपलब्ध है, जैसा कि निम्नलिखित सभी संस्करण हैं। अनुवर्ती 4.5 जनवरी 2014 में जारी किया गया था, और तीन साल बाद, संस्करण 2017.1 मई 2017 में जारी किया गया था।

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

स्वयं ने भी अपनी अवधारणाओं के आधार पर कई भाषाओं को प्रेरित किया। सबसे उल्लेखनीय, शायद, सेब न्यूटन के लिए न्यूटनस्क्रिप्ट और सभी आधुनिक ब्राउज़रों में उपयोग किए जाने वाले जावास्क्रिप्ट थे। अन्य उदाहरणों में Io प्रोग्रामिंग लैंग्वेज, लिसाक और अब प्रोग्रामिंग भाषा शामिल हैं। 1990 में विकसित आईबीएम टिवोली फ्रेमवर्क की वितरित वस्तु प्रणाली, निम्नतम स्तर पर, स्वयं से प्रेरित एक प्रोटोटाइप आधारित वस्तु प्रणाली थी।

प्रोटोटाइप-आधारित प्रोग्रामिंग लैंग्वेज

Main article: Prototype-based programming

पारंपरिक वर्ग-आधारित OO भाषाएँ एक गहरी जड़ वाले द्वैत पर आधारित हैं:

1. क्लास (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) वस्तुओं के मूल गुणों और व्यवहारों को परिभाषित करता है।
2. वस्तु (कंप्यूटर विज्ञान) एक वर्ग की विशेष अभिव्यक्तियाँ हैं।

उदाहरण के लिए, वस्तुओं की कल्पना करें Vehicle वर्ग का एक नाम और विभिन्न क्रियाएं करने की क्षमता होती है, जैसे काम करने के लिए ड्राइव करना और निर्माण सामग्री वितरित करना। Bob's car वर्ग की एक विशेष वस्तु (उदाहरण) है Vehicle, बॉब की कार के नाम से। सिद्धांत रूप में कोई तब संदेश भेज सकता है Bob's carनिर्माण सामग्री देने की बात कह रहा है।

यह उदाहरण इस दृष्टिकोण के साथ समस्याओं में से एक को दिखाता है: बॉब की कार, जो एक स्पोर्ट्स कार होती है, निर्माण सामग्री (किसी भी सार्थक अर्थ में) ले जाने और वितरित करने में सक्षम नहीं है, लेकिन यह एक क्षमता है Vehicles के लिए मॉडलिंग की जाती है। विशेषज्ञता बनाने के लिए उपवर्ग (सेट थ्योरी) आईएनजी के उपयोग से एक अधिक उपयोगी मॉडल उत्पन्न होता है Vehicle; उदाहरण के लिए Sports Car और Flatbed Truck. केवल वर्ग की वस्तुएं Flatbed Truck निर्माण सामग्री वितरित करने के लिए एक तंत्र प्रदान करने की आवश्यकता है; स्पोर्ट्स कार, जो उस तरह के काम के लिए अनुपयुक्त हैं, केवल तेजी से ड्राइव करने की जरूरत है। हालांकि, इस गहरे मॉडल को डिजाइन के दौरान अधिक अंतर्दृष्टि की आवश्यकता होती है, अंतर्दृष्टि जो समस्या उत्पन्न होने पर ही प्रकाश में आ सकती है।

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

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

स्व और अन्य प्रोटोटाइप-आधारित भाषाओं में, कक्षाओं और वस्तु उदाहरणों के बीच द्वंद्व समाप्त हो जाता है।

किसी वर्ग पर आधारित किसी वस्तु का उदाहरण होने के बजाय, स्वयं में एक मौजूदा वस्तु की एक प्रति बनाता है, और उसे बदलता है। इसलिए Bob's car मौजूदा वेहिकल ऑब्जेक्ट की एक कॉपी बनाकर बनाया जाएगा, और फिर ड्राइव फास्ट मेथड को जोड़कर, इस तथ्य को मॉडलिंग करते हुए कि यह पोर्श 911 होता है। मुख्य रूप से कॉपी बनाने के लिए उपयोग की जाने वाली मूल वस्तुओं को प्रोटोटाइप के रूप में जाना जाता है। इस तकनीक को गतिशीलता को बहुत सरल बनाने का दावा किया जाता है। यदि कोई मौजूदा वस्तु (या वस्तुओं का सेट) एक अपर्याप्त मॉडल साबित होती है, तो एक प्रोग्रामर सही व्यवहार के साथ एक संशोधित वस्तु बना सकता है, और इसके बजाय उसका उपयोग कर सकता है। कोड जो मौजूदा वस्तुओं का उपयोग करता है, बदला नहीं जाता है।

विवरण

सेल्फ ऑब्जेक्ट स्लॉट्स का एक संग्रह है। स्लॉट एक्सेसर विधियाँ हैं जो मान लौटाती हैं, और स्लॉट के नाम के बाद एक कोलन रखने से मान सेट हो जाता है। उदाहरण के लिए, नाम नामक स्लॉट के लिए,

myPerson name

नाम में मान लौटाता है, और

myPerson name:'foo'

इसे सेट करता है।

स्व, स्मॉलटॉक की तरह, प्रवाह नियंत्रण और अन्य कर्तव्यों के लिए ब्लॉक का उपयोग करता है। विधियाँ ऐसी वस्तुएँ हैं जिनमें स्लॉट्स के अतिरिक्त कोड होता है (जो वे तर्कों और अस्थायी मानों के लिए उपयोग करते हैं), और किसी अन्य ऑब्जेक्ट की तरह ही सेल्फ स्लॉट में रखा जा सकता है: उदाहरण के लिए एक संख्या। सिंटैक्स दोनों ही मामलों में समान रहता है।

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

बेसिक सिंटैक्स

स्लॉट तक पहुँचने के लिए सिंटैक्स स्मॉलटाक के समान है। तीन प्रकार के संदेश उपलब्ध हैं: एकात्मक : receiver slot_name

बाइनरी

receiver + argument

कीवर्ड : receiver keyword: arg1 With: arg2 सभी संदेश परिणाम लौटाते हैं, इसलिए रिसीवर (यदि मौजूद है) और तर्क स्वयं अन्य संदेशों का परिणाम हो सकते हैं। एक अवधि के बाद एक संदेश का मतलब है कि स्वयं लौटाए गए मान को त्याग देगा। उदाहरण के लिए:

'Hello, World!' print.

यह हैलो वर्ल्ड प्रोग्राम का सेल्फ वर्जन है। ' ई> सिंटैक्स एक शाब्दिक स्ट्रिंग ऑब्जेक्ट को इंगित करता है। अन्य शाब्दिक में संख्याएँ, ब्लॉक और सामान्य वस्तुएँ शामिल हैं।

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

valid: base bottom
          between: ligature bottom + height
          And: base top / scale factor.

स्पष्ट रूप से पार्स किया जा सकता है, और इसका मतलब वही है:

valid: ((base bottom)
            between: ((ligature bottom) + height)
            And: ((base top) / (scale factor))).

स्मॉलटाक -80 में, समान अभिव्यक्ति को इस प्रकार लिखा जाएगा:

valid := self base bottom
             between: self ligature bottom + self height
             and: self base top / self scale factor.

मान लिया जाये base, ligature, height और scale के उदाहरण चर नहीं थे self लेकिन वास्तव में, तरीके थे।

नई वस्तुएं बनाना

थोड़ा और जटिल उदाहरण पर विचार करें:

labelWidget copy label: 'Hello, World!'.

कॉपी संदेश के साथ लेबलविजेट ऑब्जेक्ट की प्रतिलिपि बनाता है (इस बार कोई शॉर्टकट नहीं है), फिर इसे लेबल नामक स्लॉट में हैलो, वर्ल्ड डालने के लिए एक संदेश भेजता है। अब इसके साथ कुछ करना है:

(desktop activeWindow) draw: (labelWidget copy label: 'Hello, World!').

इस मामले में (desktop activeWindow) पहले किया जाता है, सक्रिय खिड़की को विंडोज़ की सूची से लौटाता है जिसके बारे में डेस्कटॉप ऑब्जेक्ट जानता है। अगला (आंतरिक से बाहरी, बाएं से दाएं पढ़ें) जिस कोड की हमने पहले जांच की थी वह लेबलविजेट लौटाता है। अंत में विजेट को सक्रिय विंडो के ड्रॉ स्लॉट में भेजा जाता है।

प्रतिनिधिमंडल

Main article: Delegation (object-oriented programming)

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

उदाहरण के लिए, मान लें कि किसी वस्तु को बैंक खाता कहा जाता है, जिसका उपयोग साधारण बहीखाता पद्धति में किया जाता है। आम तौर पर, यह ऑब्जेक्ट अंदर के तरीकों से बनाया जाएगा, शायद जमा करना और वापस लेना, और उनके द्वारा आवश्यक डेटा स्लॉट। यह एक प्रोटोटाइप है, जो इसका उपयोग करने के तरीके में ही विशेष है क्योंकि यह पूरी तरह कार्यात्मक बैंक खाता भी होता है।

लक्षण

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

इस उदाहरण में बैंक खाते की वस्तु में जमा और निकासी की विधि नहीं होगी, लेकिन माता-पिता के रूप में एक वस्तु होगी। इस तरह से बैंक अकाउंट ऑब्जेक्ट की कई प्रतियाँ बनाई जा सकती हैं, लेकिन फिर भी हम उस रूट ऑब्जेक्ट में स्लॉट्स को बदलकर उन सभी के व्यवहार को बदल सकते हैं।

यह पारंपरिक वर्ग से कैसे भिन्न है? अच्छी तरह से अर्थ पर विचार करें:

myObject parent: someOtherObject.

यह अंश 'पैरेंट *' स्लॉट से जुड़े मान को बदलकर myObject की कक्षा को रनटाइम पर बदलता है (तारांकन स्लॉट नाम का हिस्सा है, लेकिन संबंधित संदेश नहीं)। इनहेरिटेंस या लेक्सिकल स्कूपिंग के विपरीत, डेलिगेट ऑब्जेक्ट को रनटाइम पर संशोधित किया जा सकता है।

स्लॉट जोड़ना

अतिरिक्त स्लॉट शामिल करने के लिए स्वयं में वस्तुओं को संशोधित किया जा सकता है। यह ग्राफिकल प्रोग्रामिंग वातावरण का उपयोग करके या आदिम '_AddSlots:' के साथ किया जा सकता है। एक आदिम में एक सामान्य कीवर्ड संदेश के समान सिंटैक्स होता है, लेकिन इसका नाम अंडरस्कोर वर्ण से शुरू होता है। _AddSlots आदिम से बचा जाना चाहिए क्योंकि यह शुरुआती कार्यान्वयन से बचा हुआ है। हालाँकि, हम इसे नीचे दिए गए उदाहरण में दिखाएंगे क्योंकि यह कोड को छोटा बनाता है।

पहले का एक उदाहरण कारों और ट्रकों के बीच व्यवहार को अलग करने में सक्षम होने के लिए वाहन नामक एक साधारण वर्ग को फिर से बनाने के बारे में था। स्वयं में इसे कुछ इस तरह से पूरा किया जाएगा:

_AddSlots: (| vehicle <- (|parent* = traits clonable|) |).

चूंकि '_AddSlots:' प्रिमिटिव का रिसीवर इंगित नहीं किया गया है, यह स्वयं है। प्रांप्ट पर टाइप किए गए भावों के मामले में, वह एक वस्तु है जिसे लॉबी कहा जाता है। '_AddSlots:' के लिए तर्क वह वस्तु है जिसके स्लॉट रिसीवर को कॉपी किए जाएंगे। इस मामले में यह बिल्कुल एक स्लॉट के साथ एक शाब्दिक वस्तु है। स्लॉट का नाम 'वाहन' है और इसका मूल्य एक अन्य शाब्दिक वस्तु है। <- संकेतन का तात्पर्य 'वाहन:' नामक एक दूसरे स्लॉट से है, जिसका उपयोग पहले स्लॉट के मान को बदलने के लिए किया जा सकता है।

= एक स्थिर स्लॉट इंगित करता है, इसलिए कोई संबंधित 'पैरेंट:' नहीं है। शाब्दिक वस्तु जो 'वाहन' का प्रारंभिक मूल्य है, उसमें एक स्लॉट शामिल है ताकि यह क्लोनिंग से संबंधित संदेशों को समझ सके। वास्तव में खाली वस्तु, जिसे (| |) या अधिक सरल रूप से () के रूप में दर्शाया गया है, कोई भी संदेश प्राप्त नहीं कर सकता है।

vehicle _AddSlots: (| name <- 'automobile'|).

यहां रिसीवर पिछली वस्तु है, जिसमें अब 'पैरेंट*' के अलावा 'नाम' और 'नाम:' स्लॉट शामिल होंगे।

_AddSlots: (| sportsCar <- vehicle copy |).
sportsCar _AddSlots: (| driveToWork = (''some code, this is a method'') |).

हालांकि पहले 'वाहन' और 'स्पोर्ट्सकार' बिल्कुल एक जैसे थे, अब बाद वाले में एक नया स्लॉट शामिल है जिसमें एक विधि है जो मूल में नहीं है। विधियों को केवल निरंतर स्लॉट में शामिल किया जा सकता है।

_AddSlots: (| porsche911 <- sportsCar copy |).
porsche911 name:'Bobs Porsche'.

नई वस्तु 'पोर्शे911' बिल्कुल 'स्पोर्ट्सकार' की तरह शुरू हुई, लेकिन अंतिम संदेश ने इसके 'नाम' स्लॉट का मान बदल दिया। ध्यान दें कि दोनों में अभी भी समान स्लॉट हैं, भले ही उनमें से एक का मान भिन्न हो।

पर्यावरण

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

इसके अलावा, पर्यावरण सिस्टम में वस्तुओं के तेजी से और निरंतर परिवर्तन के अनुरूप है। क्लास डिज़ाइन को रिफैक्टर करना उतना ही सरल है जितना कि मौजूदा पूर्वजों से तरीकों को नए में खींचना। कॉपी बनाकर, विधि को कॉपी में खींचकर, फिर उसे बदलकर परीक्षण विधियों जैसे सरल कार्यों को संभाला जा सकता है। पारंपरिक प्रणालियों के विपरीत, केवल परिवर्तित वस्तु में नया कोड होता है, और इसका परीक्षण करने के लिए कुछ भी पुनर्निर्माण नहीं करना पड़ता है। यदि विधि काम करती है, तो इसे पूर्वज में वापस खींच लिया जा सकता है।

प्रदर्शन

सेल्फ वीएम ने कुछ बेंचमार्क पर अनुकूलित सी की लगभग आधी गति का प्रदर्शन हासिल किया। यह समय-समय पर संकलन तकनीकों द्वारा हासिल किया गया था जो एक उच्च स्तरीय भाषा को अच्छी तरह से प्रदर्शन करने के लिए स्व-अनुसंधान में अग्रणी और बेहतर थे।

कचरा संग्रह

स्वयं के उपयोग के लिए कचरा संग्रह (कंप्यूटर विज्ञान) ट्रेसिंग कचरा संग्रह # जनरेशनल जीसी (अल्पकालिक जीसी) जो उम्र के अनुसार वस्तुओं को अलग करता है। पृष्ठ लिखने के लिए स्मृति प्रबंधन प्रणाली का उपयोग करके एक राइट-बैरियर को बनाए रखा जा सकता है। यह तकनीक उत्कृष्ट प्रदर्शन देती है, हालाँकि कुछ समय चलने के बाद एक पूर्ण कचरा संग्रह हो सकता है, जिसमें काफी समय लगता है।

अनुकूलन

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

यह भी देखें

• मॉर्फिक (सॉफ्टवेयर)
• सेसिल (प्रोग्रामिंग भाषा)

अग्रिम पठन

• Published papers on Self
• Chambers, C. (1992), The Design and Implementation of the SELF Compiler, an Optimizing Compiler for Object-Oriented Programming Languages, Stanford University, CiteSeerX 10.1.1.30.1652
• Series of four articles "Environment and the programming language Self"

बाहरी संबंध

• Official website
• self on GitHub
• Former Self Home Page at Sun Microsystems