2009-12-29 14 views
8

जब मैं कुछ जटिल लिखना शुरू करता हूं, तो मुझे लगता है कि मैं जो चाहता हूं उसके साथ समाप्त होने से पहले 10 बार लिखना पुन: प्रारंभ करता हूं, अक्सर कोड की सैकड़ों लाइनों को छोड़ देता है।मैं परिष्करण से पहले 10 बार अपने कोड को फिर से लिख रहा हूं। क्या यह गलत है?

क्या मैं कुछ गलत कर रहा हूं, या दूसरों के पास वर्कफ़्लो हैं?

संपादित करें: अभी, मैं एक मॉड्यूलर कंपाइलर पर काम कर रहा हूं। जिस परियोजना पर मैं काम कर रहा था वह जावा में एक सर्वर था। इससे पहले यह कुछ समवर्ती सामान था।

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

यह देखते हुए, स्लेट साफ बार-बार साफ करना सामान्य है?

उत्तर

7

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

लेखक की टिप्पणी से:

आमतौर पर मैं पुनः आरंभ क्योंकि मैं सब सामान मेरी कोड में हो रहा से उलझन में मिलता है।

अपने शिल्प का अध्ययन करें और डिजाइन कोड और अन्य सर्वोत्तम प्रोग्रामिंग दर्शनों का अच्छा उपयोग करें ताकि आपका कोड एक अच्छी तरह से परिभाषित संरचना को उधार दे सके ... कुछ आप महीनों और यहां तक ​​कि सड़क के नीचे दिन भी पहचान लेंगे।

1

एक जटिल समस्या पर, यह आम है। यदि आप अंधेरे में पूरी तरह से छेड़छाड़ नहीं कर रहे हैं, तो यह वास्तव में हमारे विचारों को पहले स्केच करने में मदद करता है, लेकिन फिर आप बस 'रीट्रीज़' को कोड से पेपर पर ले जा रहे हैं।

यदि यह आपको एक अच्छा समाधान पाने में मदद करता है, तो यह गलत कैसे हो सकता है?

+0

हाँ मुझे पता है कि आपका क्या मतलब है, लेकिन मैं यह सोचने में मदद नहीं कर सकता कि शायद चीजों को करने का एक और अधिक प्रभावी तरीका है। मेरा मतलब है, मुझे यह कहते हुए पता है कि "कोडिंग के घंटे आपको सोचने के कुछ मिनट बचा सकते हैं", लेकिन मैं भी योजना बना रहा हूं। आम तौर पर मैं पुनरारंभ करता हूं क्योंकि मैं अपने कोड में चल रही सभी चीजों से भ्रमित हो जाता हूं। –

1

यह इस बात पर निर्भर करता है कि मुझे समस्या स्थान कितनी अच्छी तरह से पता है। यदि यह परिचित क्षेत्र है, तो मुझे चिंता होगी अगर इसमें 10 पुनरावृत्तियों लगे। यदि यह अपरिचित क्षेत्र है, तो इसमें 10 पुनरावृत्तियों का समय लग सकता है, लेकिन कम से कम उनमें से कुछ को प्रोटोटाइप में कम किया जाएगा - या प्रोटोटाइप पर प्रयास - त्यागने से पहले।

4

पूरी तरह से सामान्य। कोई फर्क नहीं पड़ता कि मैं आगे कितना योजना बना रहा हूं, मेरे पास अक्सर "आह!" होता है एक बार हाथों ने कीबोर्ड दबाए।

जितनी बार यह एक "बिल्ली क्या सोच रहा था?" पल।

यह सब अच्छा है। आप बेहतर कोड बना रहे हैं।

6

यदि आप कुछ जटिल शुरू कर रहे हैं, से पहले आप लिखना शुरू करना एक अच्छा विचार प्रतीत होता है।

डिजाइन पहले।

1

यदि आप प्रत्येक पुनरावृत्ति के साथ कुछ सीख रहे हैं तो शायद कोई समस्या नहीं है। इस तरह की समय सीमा और बदसूरत चीजें आपके जीवन को थोड़ा और कठिन बना सकती हैं। :)

जब मैं एक नई समस्या पर काम कर रहा हूं, तो मैं अपने टीडीडी के लिए स्टब उत्पन्न करने के हिस्से के रूप में वास्तविक फ़ंक्शन हैंडलर में टिप्पणियों में इसे स्यूडोकोड करना चाहता हूं। फिर फंक्शन बॉडी की टिप्पणियों में मेरे प्रत्येक चरण में कोड जोड़ें।

इससे मुझे इस बात पर ध्यान केंद्रित करने में मदद मिलती है कि मैं क्या समस्या हल कर रहा हूं, और विवरण में जल्दी से खो नहीं जाता है।

1

एक सबसे बड़ा परिवर्तन आप मदद करने के लिए अपने आप को होगा क्या कर सकते हैं अपने कोड पहले की योजना है। कागजों पर।

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

एक बार आपके पास यह है कि, एक मोटा डिजाइन स्केच करें। कक्षाएं, विधियों, कार्यों, वस्तुओं। इसे थोड़ा सा फॉर्म दें। अपने डिजाइन के विभिन्न हिस्सों में कार्यक्षमता का मोटा आवंटन करें।

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

0

आप जिस भी भाषा का उपयोग कर रहे हैं (या उस मामले के लिए किसी भी भाषा में) में कुछ ढांचे को सीखने पर विचार करें।

मुझे लगता है कि सीखने के ढांचे ने मेरे कोड को दस लाख बार बेहतर बनाया है। ढांचे को सीखकर (और अधिक महत्वपूर्ण बात यह है कि वे कैसे काम करते हैं) मैंने न केवल डिजाइन पैटर्न को सीखा, बल्कि वास्तविक रूप से उन्हें कैसे कार्यान्वित किया जाए।

रेल, केकफ़्पी, या डीजेंगो को देखकर विचार करें (मान लीजिए कि आप एक स्क्रिप्टिंग भाषा में हैं; मुझे कोई डेस्कटॉप भाषा ढांचा नहीं पता है। क्षमा करें!)। फिर देखें कि उनके टुकड़े एक साथ कैसे फिट होते हैं।

2

यहां सभी सुझाव मान्य हैं, हालांकि, याद रखें कि कार्यक्रम के जीवनकाल में एक पल है जो "पर्याप्त" है। कभी खत्म होने वाले रिफैक्टरिंग के जाल में गिरना आसान नहीं है, सिर्फ इसलिए कि आप देखते हैं कि "हाँ, यह बेहतर किया जा सकता है!"। खैर, सच्चाई का सामना करें - जब तक कि आपके कार्यक्रम में केवल कुछ पंक्तियां न हों, हमेशा इसे बेहतर करने का एक तरीका है।

मेरा मानना ​​है कि वहां से खुश प्रोग्रामर हैं जो इससे पीड़ित नहीं हैं, लेकिन कम से कम मुझे खुद को याद दिलाना होगा कि एक ऐसी रेखा है जिसे "पर्याप्त पर्याप्त" कहा जाता है।

और यह विशेष रूप से सच है यदि आप किसी और के लिए कोड लिख रहे हैं - कोई भी ध्यान नहीं देगा कि आपने कुछ "अच्छा" किया है, यह सब मायने रखता है "क्या यह अच्छी तरह से काम करता है?"।

इसके अलावा, एक बहुत अच्छा अभ्यास कम से कम इसे लिखने से पहले काम करने के लिए है। फिर आप हमेशा एक पिछले पिछले समाधान पर वापस आ सकते हैं।

(12 वर्षों से मैं लगातार एक गेम लिख रहा हूं जिसे मैं लिख रहा हूं, और मैं अंत में कहीं भी नहीं हूं ...)

1

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

(मैं भी MOSA परियोजना के हिस्से के रूप में एक .NET संकलक पर काम कर रहा हूँ -। Www.mosa-projet.org)

1

कागज पर अपनी समस्या का समाधान। । । टाइप करने के लिए इतनी जल्दी में मत बनो।

+0

+1 तो आप केवल कागज के 9 पृष्ठों को फेंक देते हैं;) – paxos1977

+1

1000 किलोवाट बर्बाद करने के विरोध में: -p –

1

दो स्थितियों रहे हैं। (1) मैं आत्मविश्वास से आगे की योजना बनाने और अपने abstractions अलग करने में सक्षम हो गया है। (2) मैंने नहीं किया है।

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

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

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

1

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

कारण एक refactor चाहिए से कुछ हैं:

  • बढ़ाना प्रदर्शन।
  • कोड व्यवस्थित करना।
  • आप काम करने के लिए कुछ पाने के लिए एक अलग तरह से अपने कोड लिखने की जरूरत है।
  • एक अलग तरीके से कुछ ऐसा करने के लिए, क्योंकि यह एक (यानी .: ActionScript के बजाय MXML का उपयोग करना) काम की बहुत बचत होती है।
  • आपने एक चर के लिए गलत नाम इस्तेमाल किया है।
संबंधित मुद्दे