🌅 🍃 〽️ टीम विकास के आधार के रूप में अपरिवर्तनीयता और विश्वास का भ्रम 👩‍❤️‍💋‍👨 💞 👴🏾

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

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

यह तब था कि जावा में मेरी अनुभवहीनता ने खुद को महसूस किया। C ++ की तुलना में मुझे भाषा सुविधाओं की कमी थी। हां, final कीवर्ड है, लेकिन final Object C ++ में Object* const तरह है, const Object* । यानी final List<String> आप उदाहरण के लिए, पंक्तियों को जोड़ सकते हैं। यह C ++ व्यवसाय है: मायर्स टेस्टामेंट के अनुसार हर जगह कास्ट करना, और यह बात है! कोई कुछ नहीं बदलेगा। तो? खैर, वास्तव में नहीं। मैंने अपने अवकाश पर ~~उस उपयोगिता को करने के बजाय इसके~~ बारे में थोड़ा सोचा, और जो मैं आया था।

सी ++

मुझे आपको स्वयं कार्य याद दिलाने दें:

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

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

foo.hpp

 #pragma once #include <iostream> #include <list> struct Foo { const int intValue; const std::string strValue; const std::list<int> listValue; Foo(int intValue_, const std::string& strValue_, const std::list<int>& listValue_) : intValue(intValue_) , strValue(strValue_) , listValue(listValue_) {} }; std::ostream& operator<<(std::ostream& out, const Foo& foo) { out << "INT: " << foo.intValue << "\n"; out << "STRING: " << foo.strValue << "\n"; out << "LIST: ["; for (auto it = foo.listValue.cbegin(); it != foo.listValue.cend(); ++it) { out << (it == foo.listValue.cbegin() ? "" : ", ") << *it; } out << "]\n"; return out; }

api.hpp

 #pragma once #include "foo.hpp" #include <iostream> class Api { public: const Foo& getFoo() const { return currentFoo; } private: const Foo currentFoo = Foo{42, "Fish", {0, 1, 2, 3}}; };

main.cpp

 #include "api.hpp" #include "foo.hpp" #include <list> namespace { void goodConsumer(const Foo& foo) { // do nothing wrong with foo } } int main() { { const auto& api = Api(); goodConsumer(api.getFoo()); std::cout << "*** After good consumer ***\n"; std::cout << api.getFoo() << std::endl; } }

जाहिर है, यहां सब कुछ ठीक है, डेटा अपरिवर्तित है।

निष्कर्ष

 *** After good consumer *** INT: 42 STRING: Fish LIST: [0, 1, 2, 3]

और अगर कोई कुछ बदलने की कोशिश करता है?

main.cpp

 void stupidConsumer(const Foo& foo) { foo.listValue.push_back(100); }

हां, कोड केवल संकलन नहीं करता है।

त्रुटि

 src/main.cpp: In function 'void {anonymous}::stupidConsumer(const Foo&)': src/main.cpp:16:36: error: passing 'const std::__cxx11::list<int>' as 'this' argument discards qualifiers [-fpermissive] foo.listValue.push_back(100);

क्या गलत हो सकता है?

यह सी ++ है - अपने पैरों पर शूटिंग के लिए हथियारों के एक समृद्ध शस्त्रागार के साथ एक भाषा! उदाहरण के लिए:

main.cpp

 void evilConsumer(const Foo& foo) { const_cast<int&>(foo.intValue) = 7; const_cast<std::string&>(foo.strValue) = "James Bond"; }

खैर, वास्तव में सब कुछ:

 *** After evil consumer *** INT: 7 STRING: James Bond LIST: [0, 1, 2, 3]

मैं यह भी ध्यान देता हूं कि इस मामले में const_cast बजाय reinterpret_cast का उपयोग करने से संकलन त्रुटि हो जाएगी। लेकिन सी की शैली में कास्ट आपको इस फ़ोकस को क्रैक करने की अनुमति देगा।

हां, इस तरह के कोड से अपरिभाषित व्यवहार हो सकता है [C ++ 17 10.1.7.1/4] । वह आम तौर पर संदिग्ध दिखता है, जो अच्छा है। समीक्षा के दौरान पकड़ना आसान है

यह बुरा है कि दुर्भावनापूर्ण कोड उपभोक्ता में कहीं भी छिपा हो सकता है, लेकिन यह वैसे भी काम करेगा:

main.cpp

 void evilSubConsumer(const std::string& value) { const_cast<std::string&>(value) = "Loki"; } void goodSubConsumer(const std::string& value) { evilSubConsumer(value); } void evilCautiousConsumer(const Foo& foo) { const auto& strValue = foo.strValue; goodSubConsumer(strValue); }

निष्कर्ष

 *** After evil but cautious consumer *** INT: 42 STRING: Loki LIST: [0, 1, 2, 3]

इस संदर्भ में C ++ के फायदे और नुकसान

जो अच्छा है:

आप आसानी से कुछ भी पढ़ने की घोषणा कर सकते हैं
इस प्रतिबंध का आकस्मिक उल्लंघन संकलन चरण में पाया गया है, क्योंकि निरंतर और गैर-स्थिर वस्तुओं में अलग-अलग इंटरफेस हो सकते हैं
एक कोड समीक्षा पर गंभीर उल्लंघन का पता लगाया जा सकता है

क्या बुरा है:

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

जावा

जावा में, जैसा कि मैं इसे समझता हूं, थोड़ा अलग दृष्टिकोण का उपयोग किया जाता है। final रूप में घोषित आदिम प्रकार सी ++ में उसी तरह से स्थिर हैं। जावा में स्ट्रिंग्स मूल रूप से अपरिवर्तनीय हैं, इसलिए final String वह है जो हमें इस मामले में चाहिए।

संग्रह को अपरिवर्तनीय आवरणों में रखा जा सकता है, जिसके लिए java.util.Collections class - unmodifiableList , unmodifiableMap आदि के स्थिर तरीके हैं। यानी निरंतर और गैर-स्थिर ऑब्जेक्ट के लिए इंटरफ़ेस समान है, लेकिन गैर-स्थिर ऑब्जेक्ट उन्हें बदलने की कोशिश करते समय एक अपवाद फेंकते हैं।

कस्टम प्रकारों के लिए, उपयोगकर्ता को अपरिवर्तनीय आवरण बनाने होंगे। सामान्य तौर पर, यहां जावा के लिए मेरा विकल्प है।

Foo.java

 package foo; import java.util.Collections; import java.util.List; public final class Foo { public final int intValue; public final String strValue; public final List<Integer> listValue; public Foo(final int intValue, final String strValue, final List<Integer> listValue) { this.intValue = intValue; this.strValue = strValue; this.listValue = Collections.unmodifiableList(listValue); } @Override public String toString() { final StringBuilder sb = new StringBuilder(); sb.append("INT: ").append(intValue).append("\n") .append("STRING: ").append(strValue).append("\n") .append("LIST: ").append(listValue.toString()); return sb.toString(); } }

Api.java

 package api; import foo.Foo; import java.util.Arrays; public final class Api { private final Foo foo = new Foo(42, "Fish", Arrays.asList(0, 1, 2, 3)); public final Foo getFoo() { return foo; } }

Main.java

 import api.Api; import foo.Foo; public final class Main { private static void goodConsumer(final Foo foo) { // do nothing wrong with foo } public static void main(String[] args) throws Exception { { final Api api = new Api(); goodConsumer(api.getFoo()); System.out.println("*** After good consumer ***"); System.out.println(api.getFoo()); System.out.println(); } } }

निष्कर्ष

 *** After good consumer *** INT: 42 STRING: Fish LIST: [0, 1, 2, 3]

असफल परिवर्तन का प्रयास

यदि आप उदाहरण के लिए कुछ बदलने की कोशिश करते हैं, तो:

Main.java

 private static void stupidConsumer(final Foo foo) { foo.listValue.add(100); }

यह कोड संकलित करेगा, लेकिन एक अपवाद रनटाइम पर फेंक दिया जाएगा:

अपवाद

 Exception in thread "main" java.lang.UnsupportedOperationException at java.base/java.util.Collections$UnmodifiableCollection.add(Collections.java:1056) at Main.stupidConsumer(Main.java:15) at Main.main(Main.java:70)

सफल प्रयास

और अगर बुरे तरीके से? टाइप से final क्वालीफायर को हटाने का कोई तरीका नहीं है। लेकिन जावा में एक बहुत अधिक शक्तिशाली चीज है - प्रतिबिंब।

Main.java

 import java.lang.reflect.Field; private static void evilConsumer(final Foo foo) throws Exception { final Field intField = Foo.class.getDeclaredField("intValue"); intField.setAccessible(true); intField.set(foo, 7); final Field strField = Foo.class.getDeclaredField("strValue"); strField.setAccessible(true); strField.set(foo, "James Bond"); }

और इम्युनिटी खत्म हो गई

 *** After evil consumer *** INT: 7 STRING: James Bond LIST: [0, 1, 2, 3]

ऐसा कोड C ++ में cosnt_cast तुलना में अधिक संदेहास्पद लगता है, एक समीक्षा पर पकड़ना और भी आसान है। और यह अप्रत्याशित प्रभावों को भी जन्म दे सकता है (यानी, क्या जावा में यूबी है ?)। और यह मनमाने ढंग से गहराई से छिपा भी सकता है।

ये अप्रत्याशित प्रभाव इस तथ्य के कारण हो सकते हैं कि जब final वस्तु को प्रतिबिंब का उपयोग करके बदल दिया जाता है, तो hashCode() विधि द्वारा लौटाया गया मान समान हो सकता है। एक ही हैश के साथ अलग-अलग ऑब्जेक्ट कोई समस्या नहीं है, लेकिन अलग-अलग हैश के साथ समान ऑब्जेक्ट खराब है।

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

लेकिन! JVM को विभिन्न सुरक्षा सेटिंग्स के साथ चलाया जा सकता है। पहले से ही डिफॉल्ट किया गया Security Manager सक्रिय हो रहा है, उपरोक्त सभी चालों को परावर्तन के साथ दबा देता है:

अपवाद

 $ java -Djava.security.manager -jar bin/main.jar Exception in thread "main" java.security.AccessControlException: access denied ("java.lang.reflect.ReflectPermission" "suppressAccessChecks") at java.base/java.security.AccessControlContext.checkPermission(AccessControlContext.java:472) at java.base/java.security.AccessController.checkPermission(AccessController.java:895) at java.base/java.lang.SecurityManager.checkPermission(SecurityManager.java:335) at java.base/java.lang.reflect.AccessibleObject.checkPermission(AccessibleObject.java:85) at java.base/java.lang.reflect.Field.setAccessible(Field.java:169) at Main.evilConsumer(Main.java:20) at Main.main(Main.java:71)

इस संदर्भ में जावा के फायदे और नुकसान

जो अच्छा है:

एक final कीवर्ड है जो किसी भी तरह डेटा परिवर्तन को सीमित करता है
संग्रह को अपरिवर्तनीय में बदलने के लिए पुस्तकालय विधियाँ हैं
कोड की समीक्षा से सचेत प्रतिरक्षा उल्लंघन का आसानी से पता लगाया जा सकता है
JVM सुरक्षा सेटिंग्स हैं

क्या बुरा है:

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

अजगर

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

foo.py

 class Foo(): def __init__(self, int_value, str_value, list_value): self.int_value = int_value self.str_value = str_value self.list_value = list_value def __str__(self): return 'INT: ' + str(self.int_value) + '\n' + \ 'STRING: ' + self.str_value + '\n' + \ 'LIST: ' + str(self.list_value)

api.py

 from foo import Foo class Api(): def __init__(self): self.__foo = Foo(42, 'Fish', [0, 1, 2, 3]) def get_foo(self): return self.__foo

main.py

 from api import Api def good_consumer(foo): pass def evil_consumer(foo): foo.int_value = 7 foo.str_value = 'James Bond' def main(): api = Api() good_consumer(api.get_foo()) print("*** After good consumer ***") print(api.get_foo()) print() api = Api() evil_consumer(api.get_foo()) print("*** After evil consumer ***") print(api.get_foo()) print() if __name__ == '__main__': main()

निष्कर्ष

 *** After good consumer *** INT: 42 STRING: Fish LIST: [0, 1, 2, 3] *** After evil consumer *** INT: 7 STRING: James Bond LIST: [0, 1, 2, 3]

यानी कोई चाल की जरूरत नहीं है, इसे ले लो और किसी भी वस्तु के क्षेत्र को बदल दें।

सज्जन का समझौता

अजगर में निम्नलिखित प्रथा स्वीकार की जाती है:

कस्टम फ़ील्ड और विधियाँ जिनके नाम एकल अंडरस्कोर से शुरू होते हैं, संरक्षित (C ++ और जावा में संरक्षित ) फ़ील्ड और विधियाँ हैं
कस्टम फ़ील्ड और दो अंडरस्कोर से शुरू होने वाले नामों के तरीके निजी फ़ील्ड और विधियाँ हैं

भाषा "निजी" क्षेत्रों के लिए भी प्रबंध करती है। एक बहुत भोली सजावट, सी ++ के साथ कोई तुलना नहीं है, लेकिन यह अनजाने (या भोली) त्रुटियों को अनदेखा करने (लेकिन पकड़ने नहीं) के लिए पर्याप्त है।

कोड

 class Foo(): def __init__(self, int_value): self.__int_value = int_value def int_value(self): return self.__int_value def evil_consumer(foo): foo.__int_value = 7

निष्कर्ष

 *** After evil consumer *** INT: 42

और जानबूझकर गलती करने के लिए, बस कुछ वर्ण जोड़ें।

कोड

 def evil_consumer(foo): foo._Foo__int_value = 7

निष्कर्ष

 *** After evil consumer *** INT: 7

एक और विकल्प

मुझे Oz N Tiram द्वारा प्रस्तावित समाधान पसंद आया। यह एक साधारण सज्जाकार है कि जब केवल पढ़ने के क्षेत्र को बदलने की कोशिश की जाती है तो एक अपवाद होता है। यह सहमत दायरे से थोड़ा सा परे है ("तरीकों और इंटरफेस का एक गुच्छा न बनाएं"), लेकिन, फिर से, मुझे यह पसंद आया।

foo.py

 from read_only_properties import read_only_properties @read_only_properties('int_value', 'str_value', 'list_value') class Foo(): def __init__(self, int_value, str_value, list_value): self.int_value = int_value self.str_value = str_value self.list_value = list_value def __str__(self): return 'INT: ' + str(self.int_value) + '\n' + \ 'STRING: ' + self.str_value + '\n' + \ 'LIST: ' + str(self.list_value)

main.py

 def evil_consumer(foo): foo.int_value = 7 foo.str_value = 'James Bond'

निष्कर्ष

 Traceback (most recent call last): File "src/main.py", line 35, in <module> main() File "src/main.py", line 28, in main evil_consumer(api.get_foo()) File "src/main.py", line 9, in evil_consumer foo.int_value = 7 File "/home/Tmp/python/src/read_only_properties.py", line 15, in __setattr__ raise AttributeError("Can't touch {}".format(name)) AttributeError: Can't touch int_value

लेकिन यह रामबाण नहीं है। लेकिन कम से कम संबंधित कोड संदिग्ध लग रहा है।

main.py

 def evil_consumer(foo): foo.__dict__['int_value'] = 7 foo.__dict__['str_value'] = 'James Bond'

निष्कर्ष

 *** After evil consumer *** INT: 7 STRING: James Bond LIST: [0, 1, 2, 3]

इस संदर्भ में पायथन के फायदे और नुकसान

क्या अजगर बहुत बुरा लगता है? नहीं, यह भाषा का सिर्फ एक और दर्शन है। आमतौर पर यह वाक्यांश " हम सभी सहमति वयस्क यहाँ हैं " द्वारा व्यक्त किया गया है ( हम सभी यहाँ वयस्क सहमति दे रहे हैं )। यानी यह माना जाता है कि कोई भी विशेष रूप से स्वीकृत मानदंडों से विचलित नहीं होगा। अवधारणा निश्चित नहीं है, लेकिन यह जीवन का अधिकार है।

जो अच्छा है:

यह खुले तौर पर घोषित किया जाता है कि प्रोग्रामर को एक्सेस अधिकारों की निगरानी करनी चाहिए, न कि कंपाइलर या दुभाषिया की
सुरक्षित और निजी क्षेत्रों और विधियों के लिए आम तौर पर स्वीकृत नामकरण सम्मेलन है
कोड की समीक्षा पर कुछ एक्सेस उल्लंघनों का आसानी से पता लगाया जाता है

क्या बुरा है:

भाषा के स्तर पर वर्ग के क्षेत्रों तक पहुंच को प्रतिबंधित करना असंभव है
सब कुछ पूरी तरह से डेवलपर्स की सद्भावना और ईमानदारी पर टिकी हुई है
त्रुटियां केवल रनटाइम पर होती हैं

जाओ

एक और भाषा जिसे मैं समय-समय पर महसूस करता हूं (ज्यादातर सिर्फ लेख पढ़ रहा हूं), हालांकि मैंने अभी तक इस पर वाणिज्यिक कोड की एक पंक्ति नहीं लिखी है। const कीवर्ड मूल रूप से है, लेकिन केवल तार और पूर्णांक मान जिसे ज्ञात समय पर संकलित किया जाता है (यानी C ++ से constexpr ) constexpr हो सकते हैं। लेकिन संरचना क्षेत्र नहीं कर सकते। यानी यदि खेतों को खुला घोषित किया जाता है, तो यह अजगर की तरह निकलता है - जो आप चाहते हैं उसे बदलें। नीरस। मैंने एक उदाहरण कोड भी नहीं दिया।

खैर, खेतों को निजी होने दें, और खुले मूल्यों के लिए कॉल के माध्यम से उनके मूल्यों को प्राप्त करने दें। क्या मुझे गो में जलाऊ लकड़ी मिल सकती है? बेशक, यहाँ प्रतिबिंब भी है।

foo.go

 package foo import "fmt" type Foo struct { intValue int strValue string listValue []int } func (foo *Foo) IntValue() int { return foo.intValue; } func (foo *Foo) StrValue() string { return foo.strValue; } func (foo *Foo) ListValue() []int { return foo.listValue; } func (foo *Foo) String() string { result := fmt.Sprintf("INT: %d\nSTRING: %s\nLIST: [", foo.intValue, foo.strValue) for i, num := range foo.listValue { if i > 0 { result += ", " } result += fmt.Sprintf("%d", num) } result += "]" return result } func New(i int, s string, l []int) Foo { return Foo{intValue: i, strValue: s, listValue: l} }

api.go

 package api import "foo" type Api struct { foo foo.Foo } func (api *Api) GetFoo() *foo.Foo { return &api.foo } func New() Api { api := Api{} api.foo = foo.New(42, "Fish", []int{0, 1, 2, 3}) return api }

main.go

 package main import ( "api" "foo" "fmt" "reflect" "unsafe" ) func goodConsumer(foo *foo.Foo) { // do nothing wrong with foo } func evilConsumer(foo *foo.Foo) { reflectValue := reflect.Indirect(reflect.ValueOf(foo)) member := reflectValue.FieldByName("intValue") intPointer := unsafe.Pointer(member.UnsafeAddr()) realIntPointer := (*int)(intPointer) *realIntPointer = 7 member = reflectValue.FieldByName("strValue") strPointer := unsafe.Pointer(member.UnsafeAddr()) realStrPointer := (*string)(strPointer) *realStrPointer = "James Bond" } func main() { apiInstance := api.New() goodConsumer(apiInstance.GetFoo()) fmt.Println("*** After good consumer ***") fmt.Println(apiInstance.GetFoo().String()) fmt.Println() apiInstance = api.New() evilConsumer(apiInstance.GetFoo()) fmt.Println("*** After evil consumer ***") fmt.Println(apiInstance.GetFoo().String()) }

निष्कर्ष

 *** After good consumer *** INT: 42 STRING: Fish LIST: [0, 1, 2, 3] *** After evil consumer *** INT: 7 STRING: James Bond LIST: [0, 1, 2, 3]

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

गोफर समुदाय में स्पष्ट रूप से अपरिवर्तनीय प्रकार का अभाव है , लेकिन निश्चित रूप से गो 1.x में कोई भी नहीं होगा।

इस संदर्भ में गो के फायदे और नुकसान

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

जो अच्छा है:

संकलन के दौरान सभी पहुंच त्रुटियां होती हैं
समीक्षा में प्रतिबिंब आधारित गंदी चाल स्पष्ट रूप से दिखाई दे रही है

क्या बुरा है:

"केवल पढ़ने वाले डेटासेट" की कोई अवधारणा नहीं है
पैकेज के भीतर संरचना क्षेत्रों तक पहुंच को प्रतिबंधित करना असंभव है
पैकेज के बाहर के परिवर्तनों से खेतों को बचाने के लिए, आपको गेटर्स लिखना होगा
सभी संदर्भ संग्रह परस्पर हैं
प्रतिबिंब की सहायता से आप निजी क्षेत्रों को भी बदल सकते हैं

Erlang

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

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

foo.erl

 -module(foo). -export([new/3, print/1]). new(IntValue, StrValue, ListValue) -> {foo, IntValue, StrValue, ListValue}. print(Foo) -> case Foo of {foo, IntValue, StrValue, ListValue} -> io:format("INT: ~w~nSTRING: ~s~nLIST: ~w~n", [IntValue, StrValue, ListValue]); _ -> throw({error, "Not a foo term"}) end.

api.erl

 -module(api). -export([new/0, get_foo/1]). new() -> {api, foo:new(42, "Fish", [0, 1, 2, 3])}. get_foo(Api) -> case Api of {api, Foo} -> Foo; _ -> throw({error, "Not an api term"}) end.

main.erl

 -module(main). -export([start/0]). start() -> ApiForGoodConsumer = api:new(), good_consumer(api:get_foo(ApiForGoodConsumer)), io:format("*** After good consumer ***~n"), foo:print(api:get_foo(ApiForGoodConsumer)), io:format("~n"), ApiForEvilConsumer = api:new(), evil_consumer(api:get_foo(ApiForEvilConsumer)), io:format("*** After evil consumer ***~n"), foo:print(api:get_foo(ApiForEvilConsumer)), init:stop(). good_consumer(_) -> done. evil_consumer(Foo) -> _ = setelement(1, Foo, 7), _ = setelement(2, Foo, "James Bond").

निष्कर्ष

 *** After good consumer *** INT: 42 STRING: Fish LIST: [0,1,2,3] *** After evil consumer *** INT: 42 STRING: Fish LIST: [0,1,2,3]

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

इस संदर्भ में एरलांग के फायदे और नुकसान

जो अच्छा है:

डेटा में बिल्कुल बदलाव नहीं किया जा सकता है

क्या बुरा है:

हर जगह नकल, नकल

निष्कर्ष और निष्कर्ष के बजाय

और इसका परिणाम क्या है? खैर, इस तथ्य के अलावा कि मैंने कुछ समय पहले पढ़ी गई कुछ पुस्तकों से धूल उड़ा दी, मैंने अपनी उंगलियों को बढ़ाया, 5 अलग-अलग भाषाओं में एक बेकार कार्यक्रम लिखा और एफएक्यू खरोंच किया?

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

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

तीसरी बात: डेटा को लिखने से बचाने के लिए भाषा चाहे कितनी भी कोशिश कर ले, लेकिन उपयोगकर्ता चाहें तो यह लगभग हमेशा कर सकता है ("लगभग" एर्लांग के कारण)। और अगर आप खुद को मुख्य धारा की भाषाओं तक सीमित रखते हैं - तो यह हमेशा आसान होता है। और यह पता चला है कि इन सभी const और final में सिफारिशों से अधिक कुछ नहीं है, इंटरफेस के सही उपयोग के निर्देश हैं। सभी भाषाओं में यह नहीं है, लेकिन मैं अभी भी अपने शस्त्रागार में ऐसे उपकरण रखना पसंद करता हूं।

-, : () , , — . , , const , - ( ), , , ( ) . यानीमुझे अपने साथियों पर भरोसा है ।

नहीं, मैं लंबे समय से जानता हूं कि आधुनिक सॉफ्टवेयर विकास 99.99% मामलों में टीम वर्क है। लेकिन मैं भाग्यशाली था, मेरे सभी साथी "वयस्क, जिम्मेदार" लोग थे। मेरे लिए, यह हमेशा किसी न किसी तरह रहा है, और यह इस बात के लिए लिया जाता है कि सभी टीम के सदस्य स्थापित नियमों का पालन करें। मुझे इस बात का एहसास है कि हम लगातार एक दूसरे पर भरोसा करते हैं और सम्मान करते हैं, लेकिन शांत और सुरक्षित है।

पुनश्च

यदि कोई उपयोग किए गए कोड उदाहरणों में रुचि रखता है, तो आप उन्हें यहां ले जा सकते हैं ।

टीम विकास के आधार के रूप में अपरिवर्तनीयता और विश्वास का भ्रम

सी ++

और अगर कोई कुछ बदलने की कोशिश करता है?

क्या गलत हो सकता है?

इस संदर्भ में C ++ के फायदे और नुकसान

जावा

असफल परिवर्तन का प्रयास

सफल प्रयास

इस संदर्भ में जावा के फायदे और नुकसान

अजगर

सज्जन का समझौता

एक और विकल्प

इस संदर्भ में पायथन के फायदे और नुकसान

जाओ

इस संदर्भ में गो के फायदे और नुकसान

Erlang

इस संदर्भ में एरलांग के फायदे और नुकसान

निष्कर्ष और निष्कर्ष के बजाय

पुनश्च

More articles: