एक प्रोग्रामर के रूप में आपके कैरियर में सबसे खराब विरोधी पैटर्न क्या हैं?
मैं ज्यादातर जावा में शामिल हूं, हालांकि यह शायद भाषा-स्वतंत्र है।
मुझे लगता है कि यह सबसे खराब है जिसे मैं मुख्य विरोधी पैटर्न कहता हूं । इसका अर्थ है एकल, अत्यंत बड़ी कक्षा (कभी-कभी छोटी कक्षाओं की एक जोड़ी के साथ) जिसमें सभी तर्क होते हैं। आमतौर पर एक बड़े लूप के साथ जिसमें सभी व्यावसायिक तर्क समाहित होते हैं, कभी-कभी कोड की हजारों लाइनें होती हैं।
जवाबों:
कोड बाहर टिप्पणी की। इसके ब्लॉक, शायद सैकड़ों लाइनें। सिद्धांत, हे यह टिप्पणी की जा रही है, यह कोई नुकसान नहीं करता है और शायद हमें भविष्य में इसकी आवश्यकता होगी।
मैं "कॉपी-पास्ता" के साथ एक और स्पष्ट हिट करूँगा। कोड को कॉपी करना जो आप चाहते हैं के लगभग समान है, फिर कुछ चीजों को बदलना (एक विधि में निकालने के बजाय)।
यह विशेष रूप से 90 के दशक के उत्तरार्ध से कुछ कार्यात्मक और एपीआई परीक्षण कोड में प्रचलित है: लगभग समान-समान परीक्षण मामलों के शाब्दिक सैकड़ों (या हजारों) जो कुछ कार्यों में भंग हो सकते थे जो 3 या 4 पैरामीटर लेते हैं - या, और भी बेहतर , कुछ डेटा-चालित। कॉलेज से बाहर मेरी पहली नौकरी का शाब्दिक अर्थ था 8 महीने की कॉपी-पास्ता की हज़ारों पंक्तियों को फिर से लिखना और रीफ्रैक्ट करना, जो कि पदावनत विधियों का उपयोग कर रहे थे। जब तक मैं किया गया था, तब तक परीक्षण फाइलें उनके मूल आकार के 10 वें हिस्से से कम और बहुत अधिक बनाए रखने योग्य थीं (और पठनीय!)।
मुझे लगता है कि मैं पैटर्न मेनिया और समाधानों के बारे में बहुत कुछ लिख सकता हूं जिन्हें बहुत कम प्रयास से हल किया जा सकता है, लेकिन मैं एक महान लेख की ओर इशारा करता हूं जिसे मैंने हाल ही में एक शानदार उदाहरण के साथ पढ़ा है कि कैसे एक सरल समाधान को पूरा किया जा सकता है ।
जावा में फैक्टरियल लिखने के लिए कैसे (नहीं) या तो हम आपके एल्गोरिथ्म में एक कारखाना लगाते हैं
"मेरे पास एक हथौड़ा है और बाकी सब कुछ एक कील है।"
क्षेत्र
C # में आप कोड के एक क्षेत्र को परिभाषित कर सकते हैं जिसे IDE में ढहाया जा सकता है, इस प्रकार इसे छिपाते हुए जब तक आप उस कोड से निपटना नहीं चाहते। मैं एक प्रोजेक्ट पर (वर्तमान में चालू) रहा हूं, जहां क्षेत्रों ने सैकड़ों पंक्तियों को फैलाया (काश मैं अतिशयोक्तिपूर्ण होता) और एक हजार लाइन फ़ंक्शन में कई क्षेत्र थे (फिर से मैं चाहता था कि मैं मजाक कर रहा था)।
उल्टा, क्षेत्र को बनाने वाले डेवलपर ने एक क्षेत्र के भीतर विशिष्ट कार्यों की पहचान करने में बहुत अच्छा काम किया। इतना कि मैं क्षेत्र पर एक निकालने की विधि करने और आगे बढ़ने में सक्षम था।
क्षेत्र डेवलपर्स को सादे दृष्टि में अपनी बकवास को "छिपाने" के लिए प्रोत्साहित करते हैं।
DoNotUseRegions।
#region SQL Updateइसे संक्षिप्त बनाता है इसलिए कम स्क्रॉलिंग की आवश्यकता होती है।
मेरे लिए सबसे खराब पैटर्न कॉपी / पेस्ट है ।
लूप स्विच अनुक्रम
http://en.wikipedia.org/wiki/Loop-switch_sequence
वे मुझे कोई अंत नहीं करने के लिए गुस्सा करते हैं और वास्तव में दिखाते हैं कि देव कितना अनुभवहीन था
एक बार एक वेब एप्लिकेशन के साथ काम किया गया था जहां सभी राज्य ब्राउज़र में रखे गए थे। (मुसीबत से मुक्त मापदण्ड सुनिश्चित करने के लिए सभी अपवादों को नजरअंदाज कर दिया गया था)।
बड़े पैमाने पर जाँच
जब मैं देखता हूं कि एक डेवलपर ने एक हफ्ते में चेक-इन नहीं किया है तो मुझे नफरत है। इसका मतलब है कि वह या तो फंस गया है और उसने मदद के लिए नहीं देखा है, या वह एक बड़े चेक-इन में सुविधाओं का एक गुच्छा टकरा रहा है। (मैंने सबसे खराब स्थिति को छोड़ दिया, वह अभी कुछ नहीं कर रहा है। यह हल करना आसान है ... दो शब्द लगता है जैसे आप काम पर रखे गए हैं।)
यदि आप एक बड़ा चेक-इन कर रहे हैं, तो आप SCM के बहुत से लाभों को खो देते हैं, जैसे कि किसी विशिष्ट सुविधा में परिवर्तन लिंक करने में सक्षम होना। इसके अलावा, आपके पास करने के लिए बहुत सारे विलय होने की संभावना है और यह सही होना आसान नहीं है।
वर्तमान में, मैं विरासत कोड के एक टुकड़े के साथ काम कर रहा हूं और मुझे उस तरह से प्यार है जो पिछले कोडर को सूची का पहला तत्व मिलता है:
String result;
for(int i = 0; i < someList.size(); i++) {
result = someList.get(i);
break;
}
लेकिन इस कोड में मैंने जो सबसे बुरा देखा है वह इनलाइन JSP पृष्ठों को परिभाषित करने वाली कक्षाओं को परिभाषित कर रहा है, सभी HTML, CSS और जावास्क्रिप्ट को स्क्रिप्टलेट और out.println का उपयोग करते हुए लिखें :-(
सबसे खराब व्यवहार विरोधी पैटर्न मैंने देखा है कि एक दुकान थी जो केवल उत्पादन में होने के बाद कोड को संस्करण नियंत्रण में जांचने की अनुमति देती थी। VSS में अनन्य चेकआउट के साथ युग्मित, इसने पूर्ववत चेकआउट की एक जटिल प्रक्रिया का नेतृत्व किया, यदि उत्पादन दोष को अगली रिलीज़ से पहले ठीक करने की आवश्यकता है, तो अकेले एक व्यक्ति को आगामी रिलीज़ के लिए दिए गए फ़ाइल को बदलने की आवश्यकता है।
तथ्य यह है कि यह एक विभागीय नीति थी, इस तरह से व्यवहार करने वाले एकल डेवलपर के मामले से भी बदतर बना दिया।
एक स्ट्रिंग शाब्दिक पर ताला
synchronized("one") { /* block one A*/ }
synchronized("one") { /* block one B*/ }
बहुत लंबे वर्ग के नाम। (JRE में)
com.sun.java.swing.plaf.nimbus.
InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState
गरीब विरासत संरचना
com.sun.corba.se.internal.Interceptors.PIORB extends
com.sun.corba.se.internal.POA.POAORB extends
com.sun.corba.se.internal.iiop.ORB extends
com.sun.corba.se.impl.orb.ORBImpl extends
com.sun.corba.se.spi.orb.ORB extends
com.sun.corba.se.org.omg.CORBA.ORB extends
org.omg.CORBA_2_3.ORB extends
org.omg.CORBA.ORB
एक अपवाद जो नहीं है।
public interface FlavorException { }
व्यर्थ और गुप्त त्रुटि से निपटने
if (properties.size() > 10000)
System.exit(0);
वस्तुओं का अनावश्यक निर्माण
Class clazz = new Integer(0).getClass();
int num = new Integer(text).intValue();
अन्य उद्देश्यों के लिए एक अपवाद फेंकना
try {
Integer i = null;
Integer j = i.intValue();
} catch (NullPointerException e) {
System.out.println("Entering "+e.getStackTrace()[0]);
}
स्थिर तरीकों के लिए उदाहरण वस्तुओं का उपयोग करना।
Thread.currentThread().sleep(100);
गैर-अंतिम फ़ील्ड पर सिंक्रनाइज़ करना
synchronized(list) {
list = new ArrayList();
}
एक निरंतर स्ट्रिंग की व्यर्थ प्रतिलिपि
String s = new String("Hello world");
String.toString () के लिए व्यर्थ कॉल
String s = "Hello";
String t = s.toString() + " World";
कुछ मेमोरी फ्री करने के लिए System.gc () को कॉल करें
कुछ मेमोरी को खाली करने के लिए स्थानीय चर सेट करना
// list is out of scope anyway.
list = null;
}
प्रदर्शन कारणों (या किसी अन्य माइक्रो-माइक्रो-ऑप्टिमाइज़ेशन) के लिए i ++ के बजाय ++ i का उपयोग करना
डमी के लिए इटरेटर:
Iterator iCollection = collection.iterator();
for(int i = 0 ; i < collection.size() ; i++ ){
if(collection.get(i) == something){
iCollection.remove();
}
}
Singletono-फैक्टरी:
public class SomeObject{
private SomeObject() {}
public static SomeObject getInstance(){
return new SomeObject();
}
}
अगर-और संचालित विकास (इसे खुले करीबी सिद्धांत भी कहा जाता है - समझ के लिए संशोधन के लिए खुला):
if (sth1){
...
}else if(sth2){
..
}
...
..
else if(sth1000000000000){
...
}
StringPattern (जिसे StringObject भी कहा जाता है):
a) sendercode
if(sth1)
str+="#a";
if(sth2)
str+="#b";
...
if(sth1000)
str+="#n";
b) receiver
regexp testing if str contains #a, #b, ... #n
else ifयह अक्सर चीजों को प्राप्त करने का एकमात्र तरीका है, हालांकि। मैं तार के बारे में सोच रहा हूं; एक स्विच का उपयोग नहीं कर सकते। उपयोगी होने के लिए शर्तों को समान होना चाहिए।
getInstanceएक ही उदाहरण देता है। इस तरह की धारणा अतिक्रमण को तोड़ देगी और वास्तव में सबसे आम विरोधी प्रतिमानों में से एक है।
यह कोडिंग पैटर्न का इतना नहीं है, लेकिन एक व्यवहारिक पैटर्न है, हालांकि यह बहुत बुरा है: कोड में कुछ को संशोधित करना (मान लीजिए कि आवश्यकताओं को बदल दिया गया है), फिर कोड के पास होने तक सभी यूनिट परीक्षणों को ट्विक करना। परीक्षा पद्धति से सभी परीक्षण कोड को हटा देना या हटा देना, लेकिन विधि को वहीं छोड़ देना।
यह एक अधिक सामान्य से जुड़ा हुआ है, हालांकि, यह पैटर्न क्या होगा , यहां इसके लिए एक प्रतिनिधि लाइन है:
int num = new Integer( stringParam ).parseInt( stringParam );
यह काम करता है, सब के बाद।
मैं पूरी तरह से अमूर्त व्युत्क्रम को घृणा करता हूं , या उच्च-स्तर की प्राथमिकताओं के शीर्ष पर निम्न-स्तरीय प्राइमेटिव्स को सुदृढ़ करना। कभी-कभी, हालांकि, यह खराब भाषा डिजाइनरों के कारण होता है, न कि खराब प्रोग्रामर के कारण। उदाहरण:
फ़ंक्शन पॉइंटर के बजाय बिना सदस्य चर और संबंधित इंटरफ़ेस के साथ एकल विधि वर्ग का उपयोग करना, (फ़ंक्शन पॉइंटर्स की तालिकाओं के संदर्भ में लागू)। ध्यान दें कि जावा जैसी भाषाओं में, आपके पास कोई विकल्प नहीं हो सकता है।
MATLAB और R में, यह आग्रह कि एक आदिम के बजाय सब कुछ एक वेक्टर / मैट्रिक्स है।
जब हम MATLAB को कोस रहे हैं, तो इस तथ्य के बारे में कि इसका कोई पूर्णांक नहीं है, इसलिए जब आपको पूर्णांक की आवश्यकता होती है तो आपको एक डबल का उपयोग करना होगा।
विशुद्ध रूप से कार्यात्मक भाषाएं जहां आपको लूप लिखने के लिए फ़ंक्शन कॉल का उपयोग करना पड़ता है।
यह निश्चित रूप से कॉपी / पेस्ट होगा, मैंने इसके कारण बहुत बुरा कोड देखा है, यह और चरवाहा कोडिंग और उससे प्राप्त होने वाली हर चीज को कोड करता है। (गॉड क्लासेस, अतिरिक्त बड़े तरीके, बुरे विचार वाले एल्गोरिदम, आदि)
और अगर डिजाइन पैटर्न की अनुमति है, तो मैं कहूंगा: किसी भी डिजाइन या डोमेन विश्लेषण किए बिना, एक योजना से कार्यों के एक सेट के रूप में एक परियोजना करना।
बहु उपयोग जावा सेम -
बहुत सारे वैरिएबल के साथ एक जावा बीन, कुछ अलग तरह के ऑपरेशन में इस्तेमाल किया जाता है। प्रत्येक ऑपरेशन बीन चर के कुछ मनमाने उपसमुच्चय का उपयोग करता है, और दूसरों की उपेक्षा करता है। गुई राज्य के लिए कुछ चर, कुछ चर घटकों के बीच से गुजरने के लिए फेंके गए, कुछ जिन्हें शायद अब इस्तेमाल भी नहीं किया जाता है। सर्वश्रेष्ठ उदाहरणों में कोई प्रलेखन नहीं है, जो पैटर्न की सराहना में बाधा होगी।
इसके अलावा, प्रिय को भूल नहीं सकते
try{
... //many lines of likely dangerous operations
}
catch(Exception e){}
कुछ ऐसा है जिसने मुझे बहुत दुःख दिया है "आकाश में बड़ा मानचित्र" पैटर्न। उचित वस्तुओं का उपयोग करने के बजाय मानचित्र के चारों ओर फेंकना। आपको यह पता नहीं है कि डिबगिंग के बिना इसमें "वैरिएबल" क्या है, और आपको पता नहीं है कि कोड को पीछे की ओर ट्रेस किए बिना इसमें क्या हो सकता है। आमतौर पर स्ट्रिंग्स को ऑब्जेक्ट्स, या स्ट्रिंग्स से स्ट्रिंग्स में मैप करता है, जिसे आप संभावित रूप से प्रिमिटिव में पार्स करने वाले हैं।
मेरे पसंदीदा विकास विरोधी पैटर्न में से एक डेटाबेस "डिज़ाइन" का उपयोग होता है, जिसे लगातार एक या एक से अधिक तालिकाओं को प्रोग्रामेटिक रूप से अतिरिक्त कॉलम जोड़ने की आवश्यकता होती है । यह "डिज़ाइन" का एक चचेरा भाई है जो एक इकाई के प्रत्येक उदाहरण के लिए एक नई तालिका बनाता है। दोनों डेटाबेस सर्वर की अनिवार्य रूप से हिट सीमाएं हैं, लेकिन आमतौर पर तब तक नहीं जब तक सिस्टम काफी समय से उत्पादन में नहीं है।
मुझे लगता है कि मैंने सबसे खराब एंटी-पैटर्नों में से एक देखा है जिसमें कंप्यूटर मेमोरी का उपयोग करने के बजाय अस्थायी भंडारण के रूप में डेटाबेस तालिका का उपयोग करना शामिल है।
समस्या डोमेन स्वामित्व है जो मुझे इसे समझाने से रोकता है, लेकिन मूल समस्या को समझना आवश्यक नहीं है। यह एक GUI एप्लीकेशन था जो जावा में बैकएंड डेटाबेस के साथ लिखी गई थी। यह कुछ इनपुट डेटा लेना था, उसमें हेरफेर करना और फिर डेटाबेस में संसाधित डेटा को कमिट करना था।
हमारी परियोजना में काफी जटिल एल्गोरिथ्म है जो बाद में प्रसंस्करण के लिए मध्यवर्ती मूल्यों को बचाता है। अस्थायी वस्तुओं को ... ऑब्जेक्ट्स में इनकैप्सुलेट करने के बजाय, "t_object" की तरह एक डेटाबेस टेबल बनाया गया था। हर बार एक मूल्य की गणना की गई थी, इसे इस तालिका में जोड़ा गया था। एल्गोरिथ्म समाप्त होने के बाद यह काम करता है, यह सभी मध्यवर्ती मूल्यों का चयन करेगा और उन सभी को एक बड़े मानचित्र ऑब्जेक्ट में संसाधित करेगा। सभी प्रसंस्करण समाप्त हो जाने के बाद, बचाए गए शेष मानों को वास्तविक डेटाबेस स्कीमा में जोड़ा जाएगा और "t_object" तालिका में अस्थायी प्रविष्टियों को फेंक दिया जाएगा।
तालिका को एक अद्वितीय सूची की तरह भी उपयोग किया गया था, डेटा केवल एक बार मौजूद हो सकता है। यह डिज़ाइन की एक अच्छी विशेषता हो सकती है कि हमने टेबल पर बाधाओं को लागू किया था, लेकिन हमने यह देखने के लिए पूरी तालिका के माध्यम से पुनरावृत्ति की कि क्या डेटा मौजूद है या नहीं। (नहीं, हमने उन प्रश्नों का भी उपयोग नहीं किया है, जो CONTAINS के साथ उपयोग किए जाते हैं)
इस डिज़ाइन के कारण हम जिन समस्याओं में भागे उनमें से कुछ विशेष रूप से डिबगिंग थीं। एप्लिकेशन को पाइपलाइन डेटा के लिए बनाया गया था, ताकि इस एल्गोरिदम पर आने से पहले कई जीयूआई होंगे जो डेटा को पूर्व-संसाधित करेंगे। डिबगिंग की प्रक्रिया एक परीक्षण के मामले की प्रक्रिया थी और फिर उपरोक्त अनुभाग को समाप्त करने के बाद सही रोक दिया गया था। फिर हम डेटाबेस को यह देखने के लिए क्वेरी करेंगे कि इस तालिका में क्या डेटा शामिल था।
हमें पता चला कि एक अन्य समस्या यह थी कि इस अस्थायी तालिका से डेटा को ठीक से हटाया नहीं जा रहा था, जो भविष्य में रन के साथ हस्तक्षेप करेगा। हमने पाया कि यह अपवाद ठीक से संभाले नहीं जाने के कारण था और इसलिए एप्लिकेशन ठीक से बाहर नहीं निकल रहा था और तालिका में डेटा को हटाने नहीं था, यह नियंत्रण में था।
अगर हमने बेसिक ऑब्जेक्ट-ओरिएंटेड डिज़ाइन का उपयोग किया होता और सब कुछ मेमोरी में रखा होता, तो ये उपरोक्त समस्याएं कभी नहीं होतीं। पहले, डिबगिंग सरल होता क्योंकि हम आसानी से एप्लिकेशन में ब्रेक पॉइंट सेट कर सकते थे और फिर स्टैक और हीप में मेमोरी का निरीक्षण कर सकते थे। दूसरे, आवेदन से असामान्य रूप से बाहर निकलने पर, जावा मेमोरी को डेटाबेस से हटाने के बारे में चिंता किए बिना स्वाभाविक रूप से साफ किया गया होगा।
ध्यान दें: मैं यह नहीं कह रहा हूं कि यह पैटर्न स्वाभाविक रूप से खराब है, लेकिन इस उदाहरण में मैंने पाया कि यह अनावश्यक है जब बुनियादी ओओ सिद्धांत पर्याप्त होंगे।
मैं इस विरोधी पैटर्न के लिए एक नाम के बारे में निश्चित नहीं हूं क्योंकि यह पहली बार है जब मैंने ऐसा कुछ भी देखा है। कोई भी अच्छा नाम जो आप लोग इस पैटर्न के लिए सोच सकते हैं?
कार्ट-बिफोर-द-हॉर्स - उर्फ YouMightNeedIt
उदाहरण के लिए:
IMO ने जो सबसे खराब प्रतिमान देखा है, वह है "हमें किसी भी प्रकार के स्टिंकिन पैटर्न की आवश्यकता नहीं है" आवश्यकतानुसार चिपकाना।
माननीय उल्लेख करने के लिए कोड है कि डेटाबेस से एक वस्तु लोड पुराने VB6 शैली का उपयोग करता है:
Foobar oFoo = new Foobar();
oFoo.FooID = 42;
if (oFoo.Load()) {
// do something with oFoo
}
वास्तव में प्रति-विरोधी नहीं है, लेकिन उचित वास्तुकला और चिंताओं को अलग करने का लाभ लेने की कमी दर्शाता है।
इसके अलावा, इस तरह की बातें:
// this name is misleading, we may not always want to stand in fire,
// we may want to stand in slime or voidzones or ice patches...
public Foobar StandInFire() { }
// why is this here???
public string BeatWithNerfBat(string whom) { }
// ????
public int GivePony(string to) { }