#12in23 पर किसी ऐसे व्यक्ति के विचार, जिसने इसे पूरा किया

यह पोस्ट मूल रूप से David की वेबसाइट पर छपी थी और यहाँ अनुमति के साथ दोबारा प्रकाशित की जा रही है।

पिछले जनवरी में Exercism ने 12in23 नाम का एक नया प्रोग्राम घोषित किया, जिसमें उन्होंने प्रतिभागियों को 2023 में 12 नई प्रोग्रामिंग भाषाएँ आज़माने की चुनौती दी। हर महीने की एक थीम होती (जैसे "Analytical April" या "Object Oriented October") और उसमें आज़माने के लिए कुछ खास भाषाएँ दिखाई जातीं। मुझे नई चीज़ें सीखना बहुत पसंद है और मैं (प्रोग्रामिंग) भाषाओं का थोड़ा शौकीन हो गया हूँ, तो मैंने इसे आज़माने का फैसला किया। 12 भाषाएँ, 12 महीने!

अब जब साल लगभग खत्म होने वाला है, मैं इस प्रोजेक्ट के नतीजे से बेहद खुश हूँ। मैंने 12 नई भाषाएँ कामयाबी के साथ आज़माईं, Exercism कम्युनिटी में बेहतरीन लोगों से मिला, और साथ-साथ कुछ शानदार ओपन सोर्स योगदान भी भेजे! इस पोस्ट में मैं इन सब पर एक-एक करके चलता हूँ और बताता हूँ कि मुझे हर एक से क्या मिला।

भाषाएँ चुनना

साल भर के लिए मैंने कुछ दिशानिर्देश तय किए, ताकि इस अनुभव का पूरा फायदा उठा सकूँ:

1. भाषाएँ या तो मेरे लिए बिल्कुल नई हों, या कम से कम इतनी अनजानी हों कि मुझे लगे कि मैं बहुत कुछ सीख रहा हूँ।
2. चुनी गई भाषाएँ आगे चलकर मेरे लिए (शायद) काम की हों, ताकि मैं इन्हें और सीख सकूँ। यह प्रोजेक्ट सिर्फ मज़े के लिए था, लेकिन मैं अपना समय (कम से कम कुछ हद तक) काम की चीज़ें सीखने में लगाना चाहता हूँ।
3. मैं जिस भी भाषा का इस्तेमाल करता, उसके लिए सारे लोकल टूल और VSCode प्लगइन इंस्टॉल करता। मैं भाषाओं की तुलना लगभग बराबर आधार पर करना चाहता था, जितनी ज़्यादा से ज़्यादा टाइप हिंटिंग और इंटेलिसेंस के साथ। कॉलेज में मैंने अपना सारा प्रोग्रामिंग होमवर्क Sublime Text में बिना किसी लिंटिंग या ऑटो-कम्पलीट के किया था। मुझे चिंता थी कि अगर मैंने इन सारे टूल के साथ प्रोग्रामिंग सीखी, तो मैं इन पर बहुत ज़्यादा निर्भर हो जाऊँगा और अच्छा प्रोग्रामर नहीं बन पाऊँगा। लेकिन हुआ इसका उल्टा। मैं अपने टूल को जितना ज़्यादा सोचने का काम सौंप सकता हूँ, उतना ही ज़्यादा मैं सामने की वास्तविक समस्या पर सोच सकता हूँ। चीज़ें याद मत रखिए, उन्हें ढूँढना याद रखिए।

चलिए शुरू करते हैं!

January (Unthemed)

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

Go एक दिलचस्प भाषा है। इसका सख्त कंपाइलर मतलब यह है कि आपका प्रोग्राम सही ही होगा, और जब तक कंपाइलर को लगे नहीं कि अब आगे बढ़ना ठीक है, आप एक कदम भी नहीं बढ़ा सकते।¹ एरर हैंडलिंग के प्रति इसका शब्दबहुल तरीका मतलब है कि आप कभी चौंकते नहीं (लेकिन इसकी कीमत यह है कि if err != nil { return err } इतनी इतनी बार लिखना पड़ता है)। यह मुश्किल चीज़ों को आसान बनाने में अच्छा काम करती है (जैसे चैनल के ज़रिए समानांतरता), लेकिन कुछ आसान चीज़ों को मुश्किल भी बना देती है (स्ट्रिंग के साथ काम करना)। इसकी स्टैंडर्ड लाइब्रेरी मज़बूत है, यानी आप ज़्यादातर काम बिना किसी थर्ड-पार्टी मॉड्यूल के पूरे कर सकते हैं। मुझे यह पसंद है कि इसका बहुत सारा इकोसिस्टम (फॉर्मेटिंग, इंस्टॉल करना, बिल्ड करना, वगैरह) फर्स्ट-पार्टी है और go कमांड में ही बना हुआ है। इस भाषा के आलोचक भी हैं, लेकिन मुझे लगता है कि यह सही होने और आसानी से बनाए रखने के अपने लक्ष्यों में काफी हद तक सफल होती है।

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

Functional February

फरवरी सीधे गहरे पानी में कूद गई और फंक्शनल भाषाओं पर केंद्रित रही, जो आम इम्पेरेटिव प्रोग्रामिंग भाषाओं की एक गणित-प्रधान शाखा हैं। फंक्शनल भाषाएँ अपने "प्योर" फंक्शन के लिए जानी जाती हैं (जिनका कोई साइड इफेक्ट नहीं होता)। मैंने Elixir चुना, मुख्य रूप से इसलिए कि मेरे दोस्त Caleb ने इसे Advent of Code के लिए इस्तेमाल किया है और इसकी तारीफों के पुल बांधते हैं।

Elixir के साथ मेरा समय काफी अच्छा बीता। यह Ruby से प्रेरित है (जो तर्कसंगत लगता है; इसके निर्माता José Valim Rails के मुख्य योगदानकर्ता थे)। मुझे मेथड चेनिंग जैसे फंक्शनल कॉन्सेप्ट व्यक्त करना आसान लगा। मुझे वह सारी सिंटैक्टिक शुगर बहुत पसंद आई जो इसे आसान बनाती है, जैसे पाइप ऑपरेटर (|>):

foo(bar(baz(new_function(other_function()))))
# becomes
other_function() |> new_function() |> baz() |> bar() |> foo()

यह मेरा पहली बार मैक्रो के साथ काम करना भी था, यानी ऐसा कोड जो कोड लिखता है। चूँकि Elixir प्रोग्राम को AST के रूप में लिखा जा सकता है, जो खुद वैध Elixir कोड होता है, इसलिए दूसरा वैध कोड बनाने वाला कोड लिखना आसान है। यह बहुत शानदार कॉन्सेप्ट है जिसे Elixir ने आसान बना दिया। मुझे यह तरीका भी बहुत पसंद आया कि फंक्शन अपने आर्गुमेंट के स्वरूप के आधार पर पैटर्न-मैच कर सकते थे, जिससे फंक्शन कॉल को सही इम्प्लीमेंटेशन तक पहुँचाया जा सकता था:

defmodule TuplePrinter do
  def print({a}) do
	IO.puts("single")
	IO.puts(a)
  end

  def print({a, b}) do
	IO.puts("double")
	IO.puts(a)
	IO.puts(b)
  end
end

TuplePrinter.print({1})
TuplePrinter.print({2, 2})

# single
# 1
# double
# 2
# 2

यह ऐसा फीचर लगता है जो या तो बहुत बढ़िया होता है या आपके कोड को पूरी तरह गड़बड़ बना देता है। खैर, यह एक शानदार कॉन्सेप्ट था!

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

मुझे अभी Elixir इस्तेमाल करने की तुरंत ज़रूरत नहीं है, लेकिन इसके साथ काम करने में बहुत मज़ा आया और मैं इसे दोबारा आज़माने के लिए ज़रूर तैयार रहूँगा। साथ ही, जानी-पहचानी समस्याओं को अनजाने तरीकों से हल करना (यानी रिकर्सिव तरीके से) एक दिलचस्प चुनौती थी।

Mechanical March

मार्च "सिस्टम" भाषाओं पर केंद्रित था, जो सीधे मशीन कोड में कंपाइल होती हैं।

विकल्पों में से Go ही एकमात्र भाषा थी जिसमें मेरी दिलचस्पी थी।² अब चौकस पाठक ध्यान देंगे कि मैं Go पर एक महीना पहले ही बिता चुका था, तो इसे दोहराना मेरे 12 में नहीं गिना जाएगा। खैर, जब मैंने इसे जनवरी के लिए चुना, तब उन्होंने थीम की घोषणा अभी नहीं की थी, इसलिए मुझे पता ही नहीं था कि मैं खुद को मुश्किल में फँसा रहा हूँ।

अगर मुझे पता होता कि Bun आने वाला है, तो मैं शायद Zig आज़माता, लेकिन बदकिस्मती से मैं (अभी) भविष्य नहीं देख सकता था। तो, कोई ज़्यादा आकर्षक विकल्प न मिलने पर मैंने Go का एक अतिरिक्त महीना किया, यह समझते हुए कि साल में किसी समय मुझे एक ही भाषा के दो महीने करने पड़ेंगे।

Analytical April

अप्रैल पूरी तरह डेटा साइंस के लिए लोकप्रिय भाषाओं पर था। मैं Python से बहुत परिचित था और कॉलेज में स्टैट्स क्लास में R किया था (और वह मुझे पसंद नहीं आया), तो Julia ही चुना!

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

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

अंत में Julia अच्छी थी, लेकिन ऐसा नहीं लगता कि आगे मुझे इसकी ज़रूरत पड़ेगी।

Mindshifting May

मई ने "कुछ नया आज़माओ" पर और ज़ोर दिया और ऐसी भाषाएँ दिखाईं जो बहुत अनोखी चीज़ें करती हैं। मैंने यह मौका लेकर हमेशा लोकप्रिय Rust आज़माया। कहना पड़ेगा, अब समझ आता है कि लोग इतने उत्साहित क्यों हैं।

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

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

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

Summer of Sexps (June)

जून एस-एक्सप्रेशन का महीना था, जो Lisp में एक आम सिंटैक्स रूप है। मैंने Clojure चुना, जो एक फंक्शनल भाषा है और JVM में चलती है।

मैंने कई साल पहले थोड़ा-सा Clojure लिखा था। मैं अभी स्कूल से निकला था और अपनी पहली नौकरी में किसी काम के लिए बेहद ज़रूरी रोज़ाना स्क्रिप्ट को अकेले ही संभालने लगा था। कहने की ज़रूरत नहीं, वह मुश्किल समय था। मैं जानना चाहता था कि अब जब मैं बड़ा और समझदार हो गया हूँ, तो क्या यह ज़्यादा समझने लायक लगती है।

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

जब दूसरे विकल्प मौजूद हैं, तो मैं खुद को कभी Clojure किसी भी काम में इस्तेमाल करते नहीं देखता, लेकिन यह पूरी तरह बुरा अनुभव भी नहीं था।

साइड क्वेस्ट: Universal Test Runner!

कई सालों से मैं अपनी मौजूदा डायरेक्टरी में यूनिट टेस्ट चलाने के लिए एक छोटा-सा bash फंक्शन इस्तेमाल करता आया हूँ। जब मैं इन सभी नई भाषाओं में काम कर रहा था, तो सुविधा के लिए मैं इसमें लाइनें जोड़ता जा रहा था; हर बार भाषा-विशेष टेस्ट कमांड दोबारा सीखने से t चलाना याद रखना कहीं आसान था।

जैसे-जैसे ज़रूरी लॉजिक bash में मेरी सुविधा से बड़ा होता गया, मैंने जून में कुछ समय निकाला और इस प्रोजेक्ट को अपनी अलग चीज़ बना दिया: Universal Test Runner।

मैंने इसे Exercism फोरम पर साझा किया और अच्छी प्रतिक्रिया मिली। उन्हें यह इतना पसंद आया कि हमने खुद Exercism CLI में भी ऐसी सुविधा जोड़ने का फैसला किया (जो Go में लिखा है, और संयोग से मैंने अभी-अभी उसका ज्ञान ताज़ा किया था)। तो साल के दूसरे हिस्से में मैं उस महीने की भाषा का टेस्ट सूट चलाने के लिए exercism test चला सकता था (यह कमांड Universal Test Runner में पहले से मौजूद है)।

अगर आप इस प्रक्रिया के बारे में और जानना चाहें, तो मैंने इसके लॉन्च होने पर इसके बारे में बहुत विस्तार से लिखा था।

खैर, आगे बढ़ते हैं!

Jurassic July

जुलाई में पुरानी भाषाएँ दिखाई गईं। व्यावहारिकता के हिसाब से इस महीने विकल्प बहुत कम थे। मैंने पुरानी और प्रतिष्ठित COBOL से शुरुआत की, क्योंकि मैंने सुना था कि यह आज भी बहुत सारे ज़रूरी सिस्टम चलाती है। लेकिन अगस्त की शुरुआत में मेरी शादी सिर पर थी, इसलिए मेरे पास इतनी फुरसत नहीं थी कि बैठकर अपने लिए इतनी अलग भाषा सीखूँ। तो इसके बजाय मैंने Visual Basic चुना, क्योंकि वह सबसे कम बुरा विकल्प लगा।

यहाँ कहने के लिए ज़्यादा कुछ नहीं है। भाषा थोड़ी शब्दबहुल लगी, लेकिन इस्तेमाल करने में काफी आसान। मेरी समझ से यह वास्तव में Windows पर UI डेवलपमेंट के लिए बनाई गई थी, इसलिए छोटे अभ्यास करके इसके बारे में पूरी समझ बनाना मुश्किल है।

Appy August

अगस्त ऐप बनाने वाली भाषाओं से भरा था। हैरानी की बात नहीं, इस महीने बहुत सारे विकल्प थे। मैंने Swift चुना। जो व्यक्ति बहुत सारे Apple प्रोडक्ट इस्तेमाल करता है, उसके लिए उनकी खुद बनाई भाषा काफी मायने रखती है। मैं इसके लिए बिल्कुल नया नहीं था: मैंने 2016 में पूरी तरह Swift में लिखा सिर्फ एक iOS ऐप प्रकाशित किया था। लेकिन उसके बाद मैंने इस भाषा को छुआ तक नहीं था और यह बहुत बदल चुकी है, तो मुझे लगा कि यह अभी भी गिना जाएगा।

मुझे खुशी की हैरानी हुई कि इसके साथ काम करना कितना आसान था। यहाँ की कई दूसरी भाषाओं के उलट Swift काफी नई है। यह पहली बार 2014 में जारी हुई थी और साफ तौर पर इसने आधुनिक भाषा डिज़ाइन के सबक से फायदा उठाया है। इसमें फर्स्ट-पार्टी पैकेज मैनेजर, ऑप्शनल चेनिंग, फर्स्ट-क्लास फंक्शन और समझदार स्ट्रिंग इंटरपोलेशन है। Xcode इस्तेमाल न करते हुए भी इसे पढ़ना और लिखना सहज लगा।

फिर भी, Swift ज़्यादातर Apple प्लेटफॉर्म के ऐप्स के संदर्भ में ही काम आती है, और ऐसे ऐप्स मैं अभी नहीं बनाता। अभ्यासों के लिए यह अच्छी चली, लेकिन ऐसा नहीं लगता कि मैं जल्द ही इस पर वापस आऊँगा। हालाँकि मुझे यह बहुत पसंद है कि मैं इसे अपने iPad पर लिख सकता हूँ!

Slimline September

सितंबर में बहुत संक्षिप्त या छोटी भाषाएँ खोजी गईं। मैंने jq चुना, ऐसा टूल जिसे मैं सालों से इस्तेमाल करता आया हूँ और जो मुझे बहुत पसंद है।

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

# input: { "series": "1", "sliceLength": 1 }
. as {series: $series, sliceLength: $sliceLength} |
if
  $series == "" then
	"series cannot be empty" | halt_error
  elif $sliceLength > ($series | length) then
	"slice length cannot be greater than series length" | halt_error
  elif $sliceLength == 0 then
	"slice length cannot be zero" | halt_error
  elif $sliceLength < 0 then
	"slice length cannot be negative" | halt_error
  else
	.
end
| [range(0; $series | length)]
| map($series[. : . + $sliceLength])
| map(select(. | length == $sliceLength))

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

संपादन: Mastodon पर DJ Adams ने मेरा ध्यान खींचा jq-lsp प्रोजेक्ट और उसके VSCode प्लगइन की ओर। इस बार तो मैं यह मौका चूक गया, लेकिन आगे इसे ज़रूर देखूँगा।

Object Oriented October

अक्टूबर ऑब्जेक्ट-ओरिएंटेड भाषाओं में उतरा। OO डिज़ाइन के लिए मेरे दिल में एक खास जगह है, क्योंकि ये उस तरीके से काफी मिलते हैं जिस तरह मैं अपने मन में प्रोग्राम की कल्पना करता हूँ। मैंने Ruby चुना, जो अजीब चुनाव लग सकता है।

मैं Stripe में काम करता हूँ, जो दुनिया के सबसे बड़े Ruby कोडबेस का घर है। तो क्या यह "अनजानी" भाषा नहीं गिनी जाएगी? यह सब सच है, फिर भी हमारा Ruby मोनोलिथ "स्टैंडर्ड" Ruby से बहुत दूर लगता है: सब कुछ Sorbet से टाइपचेक होता है, कोड जनरेशन बहुत ज़्यादा होता है, और सब कुछ साथ चले और स्केल करे, इसके लिए हम बहुत सारा जादू करते हैं। Stripe के अंदर और बाहर Ruby अंत में एक ही भाषा है, लेकिन इतने अलग पैमानों पर काम करने का अनुभव बहुत अलग होता है; मैं जानना चाहता था कि बाहर की दुनिया में जीवन कैसा है (उन सालों में, जबसे मैंने Ruby को गहराई से इस्तेमाल किया था)।

कुल मिलाकर, यह अच्छा था! Ruby खुद बहुत अच्छी है और "प्रोग्रामर की खुशी" को अपना मुख्य लक्ष्य बताती है, जो मुझसे मेल खाता है। मुझे यह पसंद है कि जिन स्टैंडर्ड लाइब्रेरी फंक्शनों का मैंने कभी इस्तेमाल नहीं किया, उनका नाम मैं अक्सर अनुमान से बता लेता हूँ। मुझे यह पसंद है कि फंक्शनल कोड बनाना कितना आसान है और सिंटैक्स कितना सहज और अभिव्यंजक है।

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

Ruby अभी भी बढ़िया भाषा है और मैं काम पर इसे इस्तेमाल करता रहूँगा, लेकिन यह मेरे लिए ऐसा कुछ नहीं करती जो Python नहीं करती, कम से कम अभी तो नहीं।

Nibbly November

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

मैं इस महीने के लिए अप्रत्याशित रूप से अच्छी तरह तैयार था। सिंटैक्स Clojure जैसा लगा और भाषा की बनावट Zachtronic के TIS-100 जैसी लगी। अजीब तरह से मुझे यह पसंद आया कि हर काम के लिए शुरू से शुरू करना पड़ता था; यह पुराने ज़माने जैसा लगा। अगर इस तरह मुझे वास्तव में कोई काम पूरा करना पड़ता, तो मुझे बुरा लगता, लेकिन तब तक यह एक मज़ेदार अनोखी चीज़ थी। ढेर सारी टिप्पणियों के साथ मैं लगभग पढ़ने लायक कुछ लिख पाया:

(module
  (func (export "eggCount") (param $number i32) (result i32)
	(local $res i32) ;; result
	(local $remainder i32) ;; loop counter

	(loop $loop

  	;; $res =
  	(local.set $res
    	;; $res +
    	(i32.add
      	(local.get $res)
      	;; $number % 2
      	(i32.rem_u
        	(local.get $number)
        	(i32.const 2)
      	)
    	)
  	)

  	;; $number //= 2
  	;; (keep on stack)
  	(local.tee $number
    	(i32.div_u
      	(local.get $number)
      	(i32.const 2)
    	)
  	)

  	;; this will keep looping until remainder is 0
  	br_if $loop
	)

	local.get $res
  )
)

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

दिसंबर ने साल का समापन ऐसी भाषाओं के साथ किया जो दूसरी श्रेणियों में नहीं फिट बैठीं। मार्च में एक भाषा दोहराने की वजह से मुझे इस महीने दो भाषाएँ पूरी करनी थीं।

मैंने Wren से शुरुआत की। इसे Bob Nystrom ने बनाई, जो कई चीज़ों के अलावा Crafting Interpreters की शोहरत के लिए जाने जाते हैं। मुझे इसकी बारीकी पर ध्यान, छोटा आकार और टॉप-डाउन डिज़ाइन बहुत भाया; सब कुछ बहुत सोच-समझकर बनाया लगता है। देखभाल का यह स्तर वेरिएबल स्कोपिंग और प्राइवेसी नियमों की बारीकियों में साफ दिखता है। इसका कंपाइलर छोटा है और बहुत सारी टिप्पणियों वाला, इसलिए अगर आप भाषा के इम्प्लीमेंटेशन में दिलचस्पी रखते हैं, तो यह सीखने का बढ़िया संसाधन है।

Wren थोड़ी कच्ची है और लगता है इसे लगभग छोड़ दिया गया है, लेकिन मुझे लगता है कि एक खिलौना भाषा के लिए यह ठीक है। कोई भी इसे प्रोडक्शन के लिए तैयार मानकर नहीं आता। दुनिया में गैर-प्रोडक्शन भाषाओं के लिए जगह तो बेशक है।

और: Lua

इस महीने मेरा दूसरा चुनाव Lua था। Wren के उलट यह बेहद व्यावहारिक है। इसे आसानी से एम्बेड किया जा सकता है, इसलिए यह बहुत जगहों पर दिखती है, जैसे Redis स्क्रिप्टिंग और Factorio मॉड्स। ऑब्जेक्ट मॉडल की आदत डालने में थोड़ा समय लगा, लेकिन मैं देख सकता हूँ कि मैं जल्दी उत्पादक कैसे बन जाऊँगा। मुझे टेबल नाम की सब-कुछ-करने वाली बनावट जल्दी पसंद आ गई। टूलिंग अच्छी थी: पैकेज मैनेजर बिना किसी सेटअप के चल गया और VSCode एक्सटेंशन ने टिप्पणी-आधारित टाइप एनोटेशन बिना झंझट के सपोर्ट किया।

मुझे अभी ऐसा कुछ नहीं है जिसके लिए तुरंत Lua चाहिए, लेकिन इसके व्यापक उपयोग की वजह से यह डिब्बे में रखने लायक एक और बढ़िया टूल है।

समापन

मुझे इस भाषा-यात्रा में उम्मीद से ज़्यादा मज़ा आया। मैंने न सिर्फ कुछ नए काम के कौशल सीखे, बल्कि मुझे लगता है कि मेरे क्षितिज पूरी तरह फैल गए।

आगे क्या है, तो मुझे लगता है कि और बहुत सारी Rust सीखना। डेवलपर टूलिंग के परिदृश्य में इसका महत्व अब साफ है और मैं यह सुनिश्चित करना चाहता हूँ कि जिन चीज़ों पर मैं निर्भर हूँ, उन्हें पढ़ सकूँ और उनमें योगदान दे सकूँ।

मेरे मन में कोई ठोस लक्ष्य नहीं है, लेकिन मेरे पास पढ़ने के लिए पूरी Rust book है, एक साल पहले कंपनी के खर्चे पर लिया गया Rust for JS devs course, और एक पूरा Exercism ट्रैक पूरा करना है। मैं कम से कम एक ओपन सोर्स प्रोजेक्ट में योगदान देना चाहूँगा (शायद Just, जो मेरे नए पसंदीदा प्रोग्रामों में से है), लेकिन देखते हैं साल मुझे कहाँ ले जाता है।

तब तक, छुट्टियों की शुभकामनाएँ और अपने 2023 के बाकी हिस्से का आनंद लीजिए!

1. बिना इस्तेमाल किए वेरिएबल कंपाइलर एरर हैं?? मतलब भई, हद हो गई! ↩

2. मैंने वास्तव में पहले C++ आज़माया था (जो मैंने कॉलेज के बाद से लिखा नहीं था)। उसमें मज़ा नहीं आया, इसलिए छोड़ दिया। ↩

3. यह एक और तरीका है जिसमें "वास्तविक" Ruby Stripe के भीतर के मेरे अनुभव से अलग है, इसलिए मुझे खुशी है कि मुझे दोनों तरीकों से आज़माने का मौका मिला। ↩