📻 👩🏼‍🤝‍👨🏻 🏥 LLST: लिटिल स्मालटाक का नया जीवन 👲🏽 💟 🤸🏽

सभी को नमस्कार! दुनिया के अंत और आगामी छुट्टियों के साथ :)
ओपन सोर्स समुदाय को उपहार के रूप में, साथ ही प्राचीन वस्तुओं के प्रेमियों के लिए, हमने (साथी के साथ मिलकर) अपने नए अनुसंधान विकास को पोस्ट करने का फैसला किया।

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

एक महीने का काम, 300+ कमिट करता है। और अंत में क्या हुआ, आप कट के नीचे पता लगा सकते हैं।

लेकिन क्यों?

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

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

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

हालांकि, मैंने बात करना शुरू कर दिया, और पोस्ट उस बारे में काफी नहीं है। आइए परियोजना और इसके लक्ष्यों के बारे में बेहतर बात करें। इस प्रकार,

लक्ष्य # 1 नया वीएम (प्राप्त)।

C ++ में थोड़ा स्मॉलटाक कोड फिर से लिखें, मूल के डिज़ाइन दोषों को समाप्त करें, कोड को टिप्पणी दें, इसे पठनीय और आसानी से संशोधित किया जा सके।

दुर्भाग्य से, मूल कोड या तो ~~भारतीय~~ छात्रों द्वारा लिखा गया था, या किसी और द्वारा। मेरे दृष्टिकोण से, शैक्षिक परियोजना के लिए इस तरह के स्रोत कोड होना अस्वीकार्य है (जो वास्तव में लघु स्मॉलटाक को लेखक द्वारा तैनात किया गया था)। गोटो और मैक्रोज़ के साथ छिड़के गए एक हजार लाइनों पर स्विच ब्लॉक, अलग-अलग उद्देश्यों के लिए पांच अलग-अलग स्थानों में एक ही चर का पुन: उपयोग ... अच्छी तरह से, मजेदार। साथ ही, पूरे कोड के लिए, डेढ़ टिप्पणियाँ लैंडशट्स शैली में हैं, इस रूप में: "यह स्पष्ट रूप से इस प्रकार है ..."।

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

एक उदाहरण के रूप में, मैं ओपकोड नंबर 12 "पुशब्लॉक" के लिए कार्यान्वयन कोड दूंगा।

तो यह था (स्वरूपण और लेखक टिप्पणियाँ सहेजी गई):

case PushBlock: DBG0("PushBlock"); /* create a block object */ /* low is arg location */ /* next byte is goto value */ high = VAL; bytePointer += VALSIZE; rootStack[rootTop++] = context; op = rootStack[rootTop++] = gcalloc(x = integerValue(method->data[stackSizeInMethod])); op->class = ArrayClass; memoryClear(bytePtr(op), x * BytesPerWord); returnedValue = gcalloc(blockSize); returnedValue->class = BlockClass; returnedValue->data[bytePointerInContext] = returnedValue->data[stackTopInBlock] = returnedValue->data[previousContextInBlock] = NULL; returnedValue->data[bytePointerInBlock] = newInteger(bytePointer); returnedValue->data[argumentLocationInBlock] = newInteger(low); returnedValue->data[stackInBlock] = rootStack[--rootTop]; context = rootStack[--rootTop]; if(CLASS(context) == BlockClass) { returnedValue->data[creatingContextInBlock] = context->data[creatingContextInBlock]; } else { returnedValue->data[creatingContextInBlock] = context; } method = returnedValue->data[methodInBlock] = context->data[methodInBlock]; arguments = returnedValue->data[argumentsInBlock] = context->data[argumentsInBlock]; temporaries = returnedValue->data[temporariesInBlock] = context->data[temporariesInBlock]; stack = context->data[stackInContext]; bp = bytePtr(method->data[byteCodesInMethod]); stack->data[stackTop++] = returnedValue; /* zero these out just in case GC occurred */ literals = instanceVariables = 0; bytePointer = high; break;

और इसलिए यह बन गया:

 void SmalltalkVM::doPushBlock(TVMExecutionContext& ec) { hptr<TByteObject> byteCodes = newPointer(ec.currentContext->method->byteCodes); hptr<TObjectArray> stack = newPointer(ec.currentContext->stack); // Block objects are usually inlined in the wrapping method code // pushBlock operation creates a block object initialized // with the proper bytecode, stack, arguments and the wrapping context. // Blocks are not executed directly. Instead they should be invoked // by sending them a 'value' method. Thus, all we need to do here is initialize // the block object and then skip the block body by incrementing the bytePointer // to the block's bytecode' size. After that bytePointer will point to the place // right after the block's body. There we'll probably find the actual invoking code // such as sendMessage to a receiver (with our block as a parameter) or something similar. // Reading new byte pointer that points to the code right after the inline block uint16_t newBytePointer = byteCodes[ec.bytePointer] | (byteCodes[ec.bytePointer+1] << 8); // Skipping the newBytePointer's data ec.bytePointer += 2; // Creating block object hptr<TBlock> newBlock = newObject<TBlock>(); // Allocating block's stack uint32_t stackSize = getIntegerValue(ec.currentContext->method->stackSize); newBlock->stack = newObject<TObjectArray>(stackSize, false); newBlock->argumentLocation = newInteger(ec.instruction.low); newBlock->blockBytePointer = newInteger(ec.bytePointer); // Assigning creatingContext depending on the hierarchy // Nested blocks inherit the outer creating context if (ec.currentContext->getClass() == globals.blockClass) newBlock->creatingContext = ec.currentContext.cast<TBlock>()->creatingContext; else newBlock->creatingContext = ec.currentContext; // Inheriting the context objects newBlock->method = ec.currentContext->method; newBlock->arguments = ec.currentContext->arguments; newBlock->temporaries = ec.currentContext->temporaries; // Setting the execution point to a place right after the inlined block, // leaving the block object on top of the stack: ec.bytePointer = newBytePointer; stack[ec.stackTop++] = newBlock; }

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

लक्ष्य संख्या २। एलएलवीएम के साथ एकीकरण।

कुछ डेवलपर्स का मानना है कि स्मॉलटाक के लिए जेआईटी अपने तरीकों की उच्च ग्रैन्युलैरिटी के कारण अनुत्पादक है। हालाँकि, यह आमतौर पर JIT कोड में वर्चुअल मशीन निर्देशों का "शाब्दिक" अनुवाद है।

एलएलवीएम, इसके विपरीत, जेआईटी के अलावा, कोड अनुकूलन के लिए पर्याप्त अवसर प्रदान करता है। इस प्रकार, मुख्य कार्य एलएलवीएम को "समझाना" है जिसे अनुकूलित किया जा सकता है और इसे कैसे करना सबसे अच्छा है।

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

लक्ष्य संख्या 3। एम्बेडेड उपकरणों में एक नियंत्रण प्रणाली के रूप में उपयोग करें।

जैसा कि मैंने ऊपर लिखा है, यह विकास पूरी तरह से शोध नहीं है। हमारे वीएम के आवेदन के वास्तविक स्थानों में से एक स्मार्ट होम सिस्टम कंट्रोल मॉड्यूल हो सकता है, जिसे मैं एक और हैबरमैन ( ड्रोन ) के साथ मिलकर विकसित कर रहा हूं।

एम्बेडेड सिस्टम में स्मॉलटाक का उपयोग करना सामान्य से बाहर नहीं है। इसके विपरीत, इतिहास इसके सफल अनुप्रयोग के उदाहरण जानता है। उदाहरण के लिए, टेक्ट्रोनिक्स TDS 500 श्रृंखला osprey ऑसीलोस्कोप ~~ग्राफ़~~ में स्मालटाक (चित्र क्लिक करने योग्य है) के आधार पर लागू एक ग्राफिकल इंटरफ़ेस है।

इस डिवाइस में बोर्ड पर MC68020 + DSP प्रोसेसर है। नियंत्रण कोड स्मॉलटाक में लिखा गया है, कोडांतरक में महत्वपूर्ण खंड। छवि में लगभग 250 वर्ग हैं और इसे पूरी तरह से ROM में होस्ट किया गया है। ऑपरेशन के लिए 64 KB से कम DRAM की आवश्यकता होती है।

सामान्य तौर पर, उपयोग की संभावनाओं के संदर्भ में, एक प्रस्तुति होती है जहां कई बिंदुओं का वर्णन किया जाता है। चेतावनी! ट्विस्टिंग डिज़ाइन और कॉमिक संस एम.एस.

लक्ष्य संख्या 4। कल्पना करने की कोशिश करें कि स्मॉलटॉक "मानव चेहरे के साथ" क्या हो सकता है।

80 के दशक में ज़ेरॉक्स PARC लैब में काम करने वाले एलन के ने स्मॉलटाक विकसित किया। उन्होंने इस बात की नींव रखी कि अब हम ग्राफिकल यूजर इंटरफेस को क्या कहते हैं। इसके अलावा, इस इंटरफ़ेस का पहला अनुप्रयोग केवल स्मॉलटाक आईडीई में था। वास्तव में उसके लिए इसे बनाया गया था। इसके बाद, इन विकासों का उपयोग लिसा और मकिंटोश की परियोजनाओं में एक और फुर्तीले साथी द्वारा किया गया था, जिन्हें अब कई लोग "जीयूआई के पिता" और पीसी के अलावा कहते हैं।

हर्ष विजुअलएज कठोर (क्लिक करने योग्य) है

क्लासिक स्मॉलटाक हमेशा उपस्थिति और तत्वों के वर्ग-नेस्टेड व्यवस्था की गंभीरता से प्रतिष्ठित किया गया है। मोटिफ लाइब्रेरी के साथ प्रतिस्पर्धा करने वाले इंटरफ़ेस की गंभीरता ने कभी अपील नहीं की।

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

डॉल्फिन

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

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

एलएलएसटी परियोजना के हिस्से के रूप में, मैं क्यूटी लाइब्रेरी का एकीकरण करना चाहता हूं, साथ ही उपयोगकर्ता इंटरफ़ेस के संदर्भ में भी प्रयोग करना चाहता हूं। इसके बाद, लाइब्रेरी को औद्योगिक स्मालटाक में पोर्ट किया जा सकता है।

स्रोत कहां से प्राप्त करें और उनके साथ क्या करना है?

चूंकि आपने इस जगह को पढ़ा है (जो अपने आप में अद्भुत है!), आप शायद स्रोत प्राप्त करना चाहते हैं। मेरे पास है! वर्तमान में मुख्य कामकाजी भंडार को ~~बिटबुकेट जीथूब~~ पर github.com/0x7CFE/llst ( llst.org डोमेन भी वहीं जाता है ) पर होस्ट किया गया है

नोट 1: इसकी विशिष्टता के कारण, कोड को 32-बिट मोड में एकत्र किया जाता है। इसलिए, x64 पर निर्माण और चलाने के लिए, आपको 32 बिट लाइब्रेरी ( ia32-libs के मामले में ia32-libs ) की आवश्यकता है, साथ ही साथ g++-multilib ।

 sudo apt-get install ia32-libs g++-multilib

नोट 2: जो कोई भी संकलन से ग्रस्त नहीं होना चाहता है वह रिलीज़ पेज पर तैयार-किए गए स्टैटिकली असेंबल पैकेज डाउनलोड कर सकता है।

UPD: रिपॉजिटरी के मुख्य पृष्ठ के उपयोग अनुभाग में नए बिल्ड नियमों को पढ़ना सबसे अच्छा है ( एलएलवीएम अनुभाग को पढ़ने के लिए याद रखें)।

इस तरह लीजिए:

 ~ $ git clone https://github.com/0x7CFE/llst.git ~ $ cd llst ~/llst $ mkdir build && cd build ~/llst/build $ cmake .. ~/llst/build $ make llst

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

उदाहरण के लिए, इस तरह:

 build$ ./llst

यदि सब कुछ ठीक है, तो आउटपुट कुछ इस तरह होना चाहिए:

कई बीचेस

  चित्र पूरा पढ़ा।  4678 ऑब्जेक्ट लोड किए गए

 तुलना करना
 बराबर (1) ठीक है
 बराबर (2) ठीक है
 अधिक (int int) ठीक है
 अधिक (int प्रतीक) ERROR

 सच (वर्ग सच): asmallInt को नहीं समझता है
 वीएम: संदर्भ 0xf728d8a4 पर त्रुटि जाल

 पश्व-अनुरेखन:
 त्रुटि: (सच, स्ट्रिंग)
 doNotUnderstand: (सच, प्रतीक)
 = (स्मॉलआईंट, ट्रू)
 assertEq: withComment: (ब्लॉक, ट्रू, स्ट्रिंग)
 दावा: (ब्लॉक, स्ट्रिंग)
 अधिक से अधिक (तुलना)

 कम (int int) ठीक है
 कम (प्रतीक int) ठीक है
 nilEqNil ठीक है
 nilIsNil ठीक है

 रनिंग स्मालइंटटेस्ट
 ठीक जोड़ें
 ठीक है
 mul ठीक है
 उपेक्षित (1) ठीक है
 उपेक्षित (2) ठीक है
 नकारात्मक (1) ठीक है
 नकारात्मक (2) ठीक है
 quo (1) ठीक है
 quo (2) ठीक है
 सब ठीक है

 लूपस्टेस्ट चल रहा है
 लूपकाउंट ठीक है
 योग ठीक है
 ठीक है

 रनिंग क्लासटेस्ट
 className (1) ठीक है
 className (2) ठीक है
 SendSuper ठीक है

 चल रहा है MethodLookupTest
 newline (चार) ठीक है
 newline (स्ट्रिंग) ठीक है
 parentModods (1) ठीक है
 parentModods (2) ठीक है

 स्ट्रेंजटेस्ट चल रहा है
 asNumber ठीक है
 asSymbol ठीक है
 (च) ठीक है
 पर (ओ) ठीक है
 पर (एक्स) ठीक है
 at (b) ठीक है
 at (A) ठीक है
 at (r) ठीक है
 कॉपी ओके करें
 indexOf ठीक है
 लोअरकेस ओके
 प्लस (ऑपरेटर + 1) ठीक है
 प्लस (2) ठीक है
 प्लस (3) ठीक है
 प्लस (4) ठीक है
 प्लस (5) ठीक है
 प्लस (6) ठीक है
 प्लस (7) ठीक है
 प्लस (8) ठीक है
 प्लस (9) ठीक है
 ठीक है
 आकार (1) ठीक है
 आकार (2) ठीक है
 आकार (3) ठीक है
 आकार (4) ठीक है

 एरेस्टेस्ट चल रहा है
 at (int) ठीक है
 पर (चार) ठीक है
 atPut ठीक है

 चल रहा है gctest
 कॉपी ओके करें

 प्रसंग चलाना
 बैकट्रेस (1) ठीक है
 बैकट्रेस (2) ठीक है
 instClass ठीक है

 चल रहा है आदिम जाति
 स्मॉलइंटाड ओके
 छोटेइंटीडिव ओके
 स्मालइंटेक्वल ओके
 लघुउपाय ठीक है
 स्मॉलइंटमॉड ओके
 छोटेइंटमुल ओके
 स्मॉलइंटसब ओके
 बल्कपियर ठीक है
 objectClass (SmallInt) ठीक है
 ऑब्जेक्टक्लास (ऑब्जेक्ट) ठीक है
 ObjectSize (SmallInt) ठीक है
 objectSize (चार) ठीक है
 ObjectSize (ऑब्जेक्ट) ठीक है
 ऑब्जेक्टएयरक्वाल (1) ठीक है
 ऑब्जेक्टएयरक्वाल (2) ठीक है
 smallIntBitAnd ठीक है
 smallIntBitOr ठीक है
 smallIntShiftLeft ठीक है
 smallIntShiftRight ठीक है
 ->

अवलोकन की गई त्रुटि छवि कोड को संदर्भित करती है, और VM में कोई समस्या नहीं है। मूल lst5 पर परीक्षण छवि को चलाते समय एक ही व्यवहार देखा जाता है।

इसके बाद, आप छवि के साथ खेल सकते हैं और उससे बात कर सकते हैं:

 -> 2 + 3 5 -> (2+3) class SmallInt -> (2+3) class parent Number -> Object class MetaObject -> Object class class Class -> 1 to: 10 do: [ :x | (x * 2) print. $ print ] 2 4 6 8 10 12 14 16 18 20 1

... और इसी तरह। listMethods , viewMethod और allMethods विधियां भी allMethods :

 -> Collection viewMethod: #collect: collect: transformBlock | newList | newList <- List new. self do: [:element | newList addLast: (transformBlock value: element)]. ^ newList

आप माता-पिता ( parent माध्यम से) और बच्चों के बारे में किसी भी वर्ग से पूछ सकते हैं:

 -> Collection subclasses Array ByteArray MyArray OrderedArray String Dictionary MyDict Interval List Set IdentitySet Tree Collection ->

आप संयोजन Ctrl + D भेजकर काम पूरा कर सकते हैं:

 -> Exited normally GC count: 717, average allocations per gc: 25963, microseconds spent in GC: 375509 9047029 messages sent, cache hits: 4553006, misses: 53201, hit ratio 98.85 %

सामान्य तौर पर, एक छवि अपने बारे में बहुत सारी दिलचस्प बातें बता सकती है। इसके स्रोतों में और भी अधिक पाया जा सकता है, जो फ़ाइल llst / image / imageSource.st में निहित है ।

आसान संदर्भ के लिए, मैंने केटपार्ट के लिए एक सिंटैक्स हाइलाइटिंग योजना लिखी, जो अभी भी llst / misc / smalltalk.xml में उसी रिपॉजिटरी में है। इसे काम करने के लिए, आपको इस फ़ाइल को निर्देशिका / usr / share / kde4 / apps / katepart / syntax / या ~ / .kde में एनालॉग में कॉपी करने और संपादक को पुनरारंभ करने की आवश्यकता है। Katepart: Kate, Kwrite, Krusader, KDevelop, आदि का उपयोग करते हुए सभी संपादकों में काम करेंगे।

निष्कर्ष

मुझे आशा है कि मैंने स्मोलटॉक और प्रोग्रामर के शस्त्रागार में इसके स्थान पर लंबे विचारों के साथ आपको बोर नहीं किया। मैं पूरी तरह से परियोजना के विषय पर प्रतिक्रिया सुनना चाहता हूं और विशेष रूप से इसके स्रोतों की पठनीयता।

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

पुनश्च: फिलहाल मैं अपनी ताकत (काम, वह है) के भुगतान किए गए आवेदन के लिए जगह तलाश रहा हूं। यदि आपके पास दिलचस्प परियोजनाएं (विशेष रूप से एक ही योजना) हैं, तो कृपया पीएम में दस्तक दें। मैं खुद नोवोसिबिर्स्क एकेडामोडोरोक में हूं।

LLST: लिटिल स्मालटाक का नया जीवन