.NET के लिए एंबेडेड भाषा, या मैंने एरिक लिपर्ट को कैसे तर्क दिया

प्रस्तावना

ऐसा होता है कि एक जुनून आपके सिर में इतनी दृढ़ता से बैठता है कि आप कई सालों तक बार-बार उसके पास वापस आते हैं। आप दूसरी तरफ से समस्या का सामना करने की कोशिश करते हैं, नए ज्ञान का लाभ उठाते हैं, या बस फिर से सभी को खरोंच से शुरू करते हैं - और इस तरह जब तक कि सवाल एक बार और सभी के लिए तय नहीं हो जाता। मेरे लिए, फिक्स लैंग्वेज प्रोग्रामिंग लैंग्वेज बन गई हैं। तथ्य यह है कि एक कार्यक्रम आपको मेरी आँखों में अन्य कार्यक्रमों को बनाने की अनुमति देता है यह एक अतुलनीय भग्न सौंदर्य के साथ संपन्न है। इस तरह का कार्यक्रम लिखना केवल कुछ समय के लिए था।



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

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

• स्पष्ट आयात के बिना किसी भी उपलब्ध .NET प्रकार के साथ बातचीत करना
• सामान्य समर्थन
• अनाम फ़ंक्शंस और क्लोज़र के लिए समर्थन
• कम से कम कुछ व्यावहारिक मूल्य की उपस्थिति

उपर्युक्त किसी ने भी भाग लेने की इच्छा व्यक्त की, और काम उबलने लगा। उन्होंने भाषा के डिज़ाइन को बनाने में एक सक्रिय भाग लिया और एफ # में एक पार्सर लिखा, और मैंने वाक्यविन्यास के पेड़ और आंतरिक बुनियादी ढांचे का वर्णन किया।

बाद में लेख में मैं इस बारे में बात करूंगा कि परिणाम क्या था, रास्ते में क्या नुकसान हुए, और क्यों लेख में ऐसी पीली हेडलाइन है।

किसे चाहिए दूसरी बाइक?

लगभग तीन साल पहले, हब पर एक विषय में, हमें पता चला कि दुनिया में अभी भी 2500 से अधिक प्रोग्रामिंग भाषाएं हैं। कोई और क्यों काम आएगा? संभवतः उसमें क्या हो सकता है जो दूसरों में नहीं है?

जावास्क्रिप्ट और लुआ की अपार सफलता भाषा को एम्बेड करने के लिए एक अवसर था, .NET होस्ट अनुप्रयोगों के साथ एकीकरण पर जोर देने के साथ। यहाँ से प्रोजेक्ट का नाम आया - LENS - ए लिगमेंट फॉर लैंग्वेज फॉर एंबेडेबल। NET स्क्रिप्टिंग । "एकीकरण" का अर्थ है किसी स्क्रिप्ट में एक प्रकार या फ़ंक्शन को घोषित करने की क्षमता, साथ ही साथ बाहरी और एम्बेडेड कार्यक्रमों के बीच सीधे समय पर वस्तुओं का आदान-प्रदान। उदाहरण के लिए, इस तरह:

public void Run() { var source = "a = 1 + 2"; var a = 0; var compiler = new LensCompiler(); compiler.RegisterProperty("a", () => a, newA => a = newA); try { var fx = compiler.Compile(source); fx(); Console.WriteLine("Success: {0}", a); } catch (LensCompilerException ex) { Console.WriteLine("Error: {0}", ex.FullMessage); } } 

जैसा कि आप उदाहरण से देख सकते हैं, LENS समर्थन कनेक्ट करना बहुत सरल है: बस असेंबली को प्रोजेक्ट के संदर्भ में जोड़ें, एक उदाहरण बनाएं और इसे स्रोत कोड फ़ीड करें। सभी "जादू" रजिस्टरप्रॉपर्टी विधि में निहित है - इसकी मदद से, होस्ट प्रोग्राम से कोई भी मूल्य स्क्रिप्ट में पढ़ने और लिखने दोनों के लिए उपलब्ध हो सकता है। प्रकार और कार्यों के लिए, क्रमशः RegisterFunction टाइप और RegisterFunction विधियां हैं।

भाषा सुविधाएँ

वाक्य रचना के संदर्भ में, लेंस भाषा ने पायथन और एफ # भाषाओं से बहुत कुछ सीखा है। सी-लाइक भाषाओं के साथ काम करने के दस वर्षों में, अर्धविराम और घुंघराले कोष्ठक गले में होते हैं, इसलिए लाइन ब्रेक और ब्लॉक के साथ अभिव्यक्तियां इंडेंट होती हैं।

आधार प्रकार

मूल प्रकार bool , int , double और string । इन प्रकारों के लगातार सी # में उसी तरह लिखे जाते हैं।

परिवर्तनीय घोषणा

वेरिएबल्स को var और let कीवर्ड का उपयोग करके घोषित किया जाता है। पहला एक परिवर्तनशील चर घोषित करता है, दूसरा एक केवल पढ़ने योग्य चर घोषित करता है।

 let a = 42 var b = "hello world" 

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

शर्त का उपयोग करते हुए लिखा है if ब्लॉक, लूप का उपयोग while लिखा जाता है:

 var a = 1 while(a < 10) if(a % 2 == 0) print "{0} is even" a else print "oops, {0} is odd" a a = a + 1 

नियंत्रण निर्माण एक मान लौटाते हैं । इसका मतलब है कि if असाइनमेंट साइन के दाईं ओर भी इस्तेमाल किया जा सकता है:

 let description = if(age < 21) "child" else "grown-up" 

कार्यों

जैसा कि आप ऊपर दिए गए उदाहरण से देख सकते हैं, print फ़ंक्शन को एक कार्यात्मक शैली में कहा जाता है: पहला, फ़ंक्शन का नाम या प्रतिनिधि ऑब्जेक्ट, इसके बाद रिक्त स्थान द्वारा अलग किए गए तर्क। यदि आपको एक अभिव्यक्ति पास करने की आवश्यकता है जो एक तर्क के रूप में शाब्दिक या एक चर नाम से अधिक जटिल है, तो इसे कोष्ठक में लिया जाता है।

 print "test" print abc print "result is: " (1 + 2) 

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

एक फ़ंक्शन घोषणा कीवर्ड की fun साथ शुरू होती fun :

 fun launch of bool max:int name:string -> var x = 0 while(x < max) println "{0}..." x x = x - 1 print "Rocket {0} name is launching!" name let rocket = new Rocket () rocket.Success countdown 10 

LENS में कोई भी return कीवर्ड नहीं है। किसी फ़ंक्शन का रिटर्न मान इसकी अंतिम अभिव्यक्ति है। यदि फ़ंक्शन को कुछ भी वापस नहीं करना चाहिए, लेकिन अंतिम अभिव्यक्ति कुछ प्रकार की है, तो परिचित शाब्दिक () । कीवर्ड break और continue नहीं continue ।

वर्तमान में हम जिस संस्करण में काम कर रहे हैं, उस फ़ंक्शन को स्वचालित रूप से यादगार बनाया जा सकता है। ऐसा करने के लिए, फ़ंक्शन विवरण से पहले pure कीवर्ड का उपयोग करें। यादगार फ़ंक्शंस शब्दकोश में उनके मूल्यों को कैश करते हैं: यदि कोई फ़ंक्शन पहले से ही मापदंडों के इस सेट के साथ एक बार बुलाया गया है, तो इसका मूल्य इस शब्दकोश से प्राप्त किया जाएगा, और फिर से गणना नहीं की जाएगी:

 pure fun add of int x:int y:int -> print "calculating..." x + y add 1 2 // output add 2 3 // output add 2 3 // no output! 

कस्टम संरचनाएं और बीजगणितीय प्रकार

record कीवर्ड का उपयोग करके, आप संरचना और उसके क्षेत्रों की सूची का वर्णन कर सकते हैं।

 record Point X : int Y : int let zero = new Point () let one = new Point 1 1 

बीजगणितीय प्रकारों को कीवर्ड और उन विकल्पों की सूची द्वारा घोषित किया जाता है जिन्हें इस प्रकार स्वीकार कर सकते हैं। एक प्रकार में किसी भी प्रकार का एक लेबल भी हो सकता है:

 type Card Ace King Queen Jack ValueCard of int let king = King let ten = ValueCard 10 print (ten is Card) // true 

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

कंटेनर

अक्सर उपयोग किए जाने वाले कंटेनरों को आरंभ करने के लिए, विशेष new सिंटैक्स का उपयोग किया जाता है:

 let array = new [1; 2; 3; 4; 5] let list = new [[ "hello"; "world" ]] let tuple = new (13; 42.0; true; "test") let dict = new { "a" => 1; "b" => 2 } 

कंटेनरों के लिए, सबसे उपयुक्त सामान्य प्रकार स्वचालित रूप से प्रदर्शित होता है। उदाहरण के लिए:

 let a = new [1; 2; 3.3] // double[] let b = new [King; Queen] // Card[] let c = new [1; true; "hello"] // object[] 

एक्सटेंशन के तरीके

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

 let a = Enumerable::Range 1 10 let sum = a.Product () 

LINQ थोड़ा चालाक सिंटैक्स का उपयोग करके समर्थित है:

 let oddSquareSum = Enumerable::Range 1 100 |> Where ((x:int) -> x % 2 == 0) |> Select ((x:int) -> x ** 2) |> Sum () 

इसके अलावा

संकलक ने कई और दिलचस्प बातें लागू की हैं:

• लगातार अभिव्यक्तियों का संकलन समय पर किया जाता है
• ओवररेटेड ऑपरेटरों ने समर्थन किया
• शास्त्रीय अपवाद से निपटने का प्रयास try \ catch के रूप में किया जाता है
• यदि इसमें कुछ भी आयात नहीं किया जाता है तो उत्पन्न विधानसभा को .exe में बचाया जा सकता है।
• कोड में वर्णित कार्यों को विस्तार विधियों के रूप में उपयोग किया जा सकता है

तो क्या Lippert के बारे में?

जो लोग इस लेख को पढ़ते हैं, वे निश्चित रूप से प्रत्याशा में सुस्त हैं - वादा किया गया नाटक कहां है? मुझे याद है, मुझे याद है, लेकिन पहले एक विषयांतर।

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

पहली समस्या जो मैंने चलाई वह उत्पन्न प्रकारों का निरीक्षण करने में असमर्थता थी:

 var intMethods = typeof(int).GetMethods(); //   var myType = ModuleBuilder.DefineType("MyType"); myType.DefineMethod("Test", MethodAttributes.Public); myType.GetMethods(); // NotSupportedException 

स्टैकओवरफ्लो में, उन्होंने मुझे स्पष्ट रूप से समझाया कि बनाई गई विधियों की एक सूची को संग्रहीत करना, साथ ही साथ उन्हें खोजना, पेन के साथ करना होगा। यह श्रमसाध्य है, लेकिन मुश्किल नहीं है।

लेकिन आगे - और।

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

 class A { public List<A> Values = new List<A>(); } 

यह एक दुष्चक्र बन जाता है: आप टाइप List<A> का एक निर्माता प्राप्त कर सकते हैं List<A> केवल जब विधानसभा पहले से ही अंतिम रूप दे दी गई है और इसकी अब आवश्यकता नहीं है।

Stackoverflow पर मेरा अगला सवाल जॉन स्कीट ( गहराई में सी # के लेखक) और एरिक लिपर्ट (हाल ही में सी # डेवलपर का नेतृत्व करने तक) द्वारा उत्तर दिया गया था । एरिक का फैसला निराशाजनक और अपूरणीय था:

Reflection.Emit वास्तविक संकलक बनाने के लिए उपयोग करने के लिए बहुत कमजोर है । यह LINQ प्रश्नों में डायनेमिक कॉल साइट्स और एक्सप्रेशन ट्री को उत्सर्जित करने जैसे छोटे टॉय संकलन कार्यों के लिए बहुत अच्छा है, लेकिन एक कंपाइलर में आने वाली समस्याओं के प्रकार के लिए आप जल्दी से इसकी क्षमताओं को पार कर जाएंगे।

Reflection.Emit इस पर एक वास्तविक संकलक बनाने के लिए बहुत कमजोर है। यह LINQ प्रश्नों में डायनेमिक कॉल या एक्सप्रेशन ट्री बनाने जैसे "टॉय" संकलन कार्यों के लिए उपयुक्त है, लेकिन एक वास्तविक कंपाइलर की समस्याओं को हल करने के लिए, इसकी क्षमताएं जल्दी से पर्याप्त हो जाएंगी।

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

और ऐसी विधि वास्तव में थी! यह भी मेरी अपेक्षा से कहीं अधिक स्पष्ट था।

जैसा कि मुझे एक ही TypeBuilder पर संकेत दिया गया था, TypeBuilder क्लास में स्थिर तरीके हैं जो आपको एक विधि, क्षेत्र या संपत्ति प्राप्त करने की अनुमति देते हैं:

 var myType = createType("MyType"); var listType = typeof(List<>); var myList = listType.MakeGenericType(myType); var genericMethod = listType.GetMethod("Add"); var actualMethod = TypeBuilder.GetMethod(myList, genericMethod); 

यहां, हालांकि, एक महत्वपूर्ण कमी है: लौटे तरीके में तर्क प्रकार प्रतिस्थापित नहीं किए गए हैं। परिणाम List<MyType>.Add(T item) विधि के लिए एक हैंडल होगा: तर्क का प्रकार बिल्कुल T (जेनेरिक पैरामीटर) होगा, अपेक्षित MyType ।

इस खामी के उन्मूलन के लिए एक एल्गोरिथ्म के कार्यान्वयन की आवश्यकता होती है जो युक्त प्रकार और आधार विधि के विवरण से तर्क प्रकारों के मूल्यों की गणना करेगा, और फिर उन्हें सही स्थानों पर प्रतिस्थापित करेगा। TypeBuilder विधियों के साथ TypeBuilder इन दो तंत्रों ने दुष्चक्र को दरकिनार कर दिया है।

निष्कर्ष - यहां तक ​​कि महान लोगों को भी कभी-कभी गलत माना जाता है, लेकिन प्रतिबिंब पर। आप पूरी तरह कार्यात्मक संकलक बना सकते हैं। सच है, आपको भाप स्नान करना होगा।

यदि कोई भी Reflection.Emit की सीमाओं के बारे में अधिक जानने के लिए उत्सुक है। तो, मैं सुझाव देता हूं कि 2009 में MSDN ब्लॉग लेख को वापस पढ़ा जाए। वर्ग टोपोलॉजी के कुछ उदाहरण हैं जो उत्पन्न नहीं किए जा सकते हैं। सावधानी, VB पर उदाहरण!

संस्मरण के चमत्कार

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

• यह जांचना कि क्या अभिव्यक्ति को एक प्रकार के लिए डाला जा सकता है
• सबसे उपयुक्त अधिभार विधि के लिए खोजें
• एक संग्रह के लिए सबसे उपयुक्त सामान्य प्रकार की परिभाषाएं

इस पद्धति में एक दर्जन से अधिक सभी प्रकार के चेक शामिल थे और संकलन समय के काफी हिस्से पर कब्जा कर लिया था। लेकिन दो प्रकारों के बीच की दूरी समय के साथ नहीं बदलती है, इसलिए इसे Dictionary<Tuple<Type, Type>, int> शब्दकोश में कैश करना काफी संभव है। तीन प्रमुख तरीकों को याद करते हुए लगभग आधे घंटे लगे और कई जटिल लिपियों के संकलन समय को लगभग 60 गुना कम कर दिया ।

भविष्य की परियोजना

वर्तमान में, कंपाइलर सख्ती से काम कर रहा है और दो सौ से अधिक परीक्षण पास करता है। यह पहले से ही वास्तविक परियोजनाओं में इस्तेमाल किया जा सकता है, लेकिन इसका मतलब यह नहीं है कि काम पूरा हो गया है। मुख्य कार्य पार्सर को F # से C # में फिर से लिखना है। पार्सर्स के निर्माण के लिए FParsec लाइब्रेरी का उपयोग करना स्वयं को उचित नहीं ठहराता है, और व्याकरण में परिवर्तन का समर्थन असहनीय हो गया है। इसके अलावा, यह F # रनटाइम और 500 किलोबाइटी निर्भरता के सभी के साथ त्रुटि संदेश और ड्रग्स प्रदर्शित करने के लिए अल्प सुविधाएँ प्रदान करता है। यह मानते हुए कि सभी संकलक कोड 250 kb लगते हैं, यह बहुत कुछ है।

इस कारण से, कुछ विशेषताओं को पहले से ही कंपाइलर में लागू किया गया है, लेकिन अभी भी पार्सर में समर्थित नहीं हैं - व्याकरण में थोड़े से बदलाव हिमस्खलन जैसी लहर की वजह से परीक्षण विफल हो जाते हैं। इन "ट्रिक्स" में for/foreach , फ़ंक्शंस हैंडलिंग और फ़ंक्शंस के साथ-साथ मामूली सिंटैक्स रिफाइनमेंट्स के दौरान finally सेक्शन।

अन्यथा, काम का मोर्चा निम्नलिखित है:

• पैटर्न मिलान समर्थन जोड़ें
• ऑब्जेक्ट इनिशियलाइज़र के लिए समर्थन जोड़ें
• सामान्य तरीकों और संभवतः संरचनाओं की घोषणा करने की अनुमति दें
• ईवेंट सदस्यता सहायता जोड़ें
• प्रलेखन में सभी सुविधाओं का वर्णन करें

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

मैं कहां कोशिश कर सकता हूं?

सभी स्रोत कोड github रिपॉजिटरी में उपलब्ध है:

github.com/impworks/lens

प्रोजेक्ट में तीन टेस्ट होस्ट प्रोग्राम हैं जिन पर आप कंपाइलर का परीक्षण कर सकते हैं। उनके काम के लिए F # Redistributable की आवश्यकता होगी। यदि आपने Visual Studio 2010 और पुराने को स्थापित किया है, तो आपको कुछ भी स्थापित करने की आवश्यकता नहीं है।

विंडोज के लिए एकत्रित डेमो

कंसोल

संकलक के लिए सबसे आसान मेजबान। कार्यक्रम को लाइन से लाइन में प्रवेश किया जाता है या फ़ाइल से लोड किया जाता है। शुरू करने के लिए, लाइन के अंत में # वर्ण डालें।

द्रोह करनेवाला

आपको फॉर्मूला y = f(x) में इसके सूत्र द्वारा द्वि-आयामी फ़ंक्शन को प्लॉट करने की अनुमति देता है। आप रेंज और स्टेप सेट कर सकते हैं।


(तस्वीरें क्लिक करने योग्य हैं)

ग्राफिक सैंडबॉक्स

सबसे कार्यात्मक मेजबान आवेदन। यह स्क्रिप्ट को सर्कल और रेक्ट के प्रकार प्रदान करता है, जिन्हें स्क्रीन पर प्रदर्शित किया जा सकता है और उनके व्यवहार के तर्क का वर्णन किया जा सकता है। कई डेमो स्क्रिप्ट शामिल हैं।

कुल मिलाकर

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