क्या घोटाले और एक स्थिर विकास एक विरोधाभास का निर्माण करते हैं?

Question

मैं 5 टीमों के साथ एक विकास समूह का हिस्सा हूं, कुल लगभग 40 डेवलपर्स। हम 3-सप्ताह के स्प्रिंट के साथ स्क्रम पद्धति का अनुसरण कर रहे हैं। हमारे पास एक निरंतर एकीकरण सेटअप (जेनकिंस) है, जिसमें एक निर्माण पाइपलाइन कई घंटों (व्यापक स्वचालित परीक्षणों के कारण) के साथ है। मूल रूप से, विकास प्रक्रिया अच्छी तरह से काम करती है।

हालाँकि, हम देखते हैं कि एक नए स्प्रिंट में कुछ दिनों के बाद, हमारा निर्माण अक्सर अस्थिर हो जाता है, और स्प्रिंट-एंड "प्रतिबद्ध स्टॉप" तक अस्थिर रहता है। इसका दुष्परिणाम यह है कि पाइपलाइन से दूर कदमों का निर्माण करें, विशेषकर UI- / वेबस्टेस को कई दिनों तक निष्पादित नहीं किया जाता है (क्योंकि केवल 'ग्रीन' बिल्ड पर ट्रिगर होता है)। नतीजतन, नए शुरू किए गए बग अक्सर स्प्रिंट में बहुत देर से ही पाए जाते हैं।

• प्रत्येक प्रतिबद्ध को परीक्षणों के एक मूल सेट के खिलाफ सत्यापित किया जाता है। एक बार सत्यापित हो जाने के बाद, परिवर्तन को कोड समीक्षा (गुरिट) के बाद मास्टर करने के लिए धकेल दिया जाता है
• मूल इकाई परीक्षण हर 30 मिनट में चलते हैं, जिसकी अवधि 10 मिनट से कम है
• एकीकरण परीक्षण हर 2 एच, अवधि 1 एच
• UI- / वेबटेस्ट सफल एकीकरण परीक्षणों पर चलते हैं, कई घंटे की अवधि

स्प्रिंट के दौरान बिल्ड स्थिरता के लिए कौन जिम्मेदार है (यह जिम्मेदारी स्प्रिंट के आसपास पारित की गई है) के आधार पर, बिल्ड को वापस स्थिर करने के लिए मध्यवर्ती, तदर्थ "स्टॉप स्टॉप" हो सकता है।

तो, हम चाहते हैं:

1. हमारी देव टीमें एक स्प्रिंट के दौरान परिवर्तन विकसित और प्रतिबद्ध करने के लिए
2. यदि बिल्ड निर्माण विफल हो जाता है, तो बाद की बिल्ड परिणामों के बहुत कम अर्थ होने पर हमारी निर्माण प्रक्रिया को छोड़ देना चाहिए
3. डेवलपर्स को समय पर आधार पर गुणवत्ता प्रतिक्रिया देने के लिए हमारी निर्माण प्रक्रिया

दिए गए (2), अंक (1) और (3) एक-दूसरे के विपरीत प्रतीत होते हैं। क्या किसी के पास इससे निपटने का अच्छा अभ्यास है?

( हम वर्तमान में बिंदु ढीला कर रहे हैं (2), और असफल निर्माण चरणों पर भी निर्माण जारी रखने की अनुमति दे रहे हैं। मेरे पास अभी तक कोई प्रतिक्रिया नहीं है कि यह हमारी गुणवत्ता को कैसे प्रभावित करता है )

धन्यवाद, साइमन

Comments

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

— zaitsman

क्या आपके निर्माण का वातावरण आधार पर है या क्लाउड-आधारित है?

— लॉरी लंती

@LauriLaanti, हमारे निर्माण का वातावरण ऑन-प्रिमाइसेस है, 3 दासों के साथ 1 जेनकींस उदाहरण है।

— साइमन

Answer 1

पहले बुनियादी सिद्धांतों के एक जोड़े: - प्रमुख परिवर्तन हमेशा आपके VCS में एक सुविधा शाखा पर होना चाहिए - सुविधा शाखाओं को ट्रंक में विलय करने से पहले सभी परीक्षणों को पास करना चाहिए । जोड़ा - कमिट्स को हमेशा निर्माण करना चाहिए - एक टूटी हुई इमारत को कमिटेटर और / या टीम के बाकी हिस्सों से तत्काल कार्रवाई की आवश्यकता होती है । - एक असफल परीक्षण केवल शेष परीक्षणों को रद्द कर देना चाहिए यदि यह एक महत्वपूर्ण परीक्षा है।

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

आप यूआई / वेब परीक्षणों के लिए रात भर चलने वाली सुबह की पहली बात के रूप में नवीनतम "सफल" बिल्ड का स्वचालित परीक्षण, (जरूरी नहीं कि एकीकरण परीक्षण पास कर सकते हैं) जोड़ सकते हैं ।

Comments

यहां जोड़ने के लिए एक अच्छा अभ्यास यह है कि फीचर शाखाओं को मेनलाइन में विलय होने से पहले सभी परीक्षणों को पास करना चाहिए

— बार्ट वैन इनजेन शेनौ

@BartvanIngenSchenau - अच्छा बिंदु जोड़ा गया!

— स्टीव बार्न्स

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

— सिमोन

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

— स्टीव बार्न्स

Answer 2

स्क्रैम से कोई लेना-देना नहीं है। आपका निर्माण निरंतर स्थिर होना चाहिए, भले ही वह कुछ भी हो।

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

कोई भी ऐसी चीज का परिचय देता है जिसके कारण निर्माण विफल हो जाता है या विफल होने के लिए एक इकाई परीक्षण को सार्वजनिक रूप से शर्मिंदा होना चाहिए । यदि निर्माण टूट गया है, तो इसे तुरंत ठीक किया जाना चाहिए।

Comments

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

— मारवाड़

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

— जॉन वू

हमारी प्रक्रिया में, कोई भी प्रतिबद्धता शाख में (जेरिट में) है, और मास्टर में विलय करने से पहले परीक्षणों का एक मूल सेट पास करना होगा। वे मूल परीक्षण एक घंटे तक नहीं चल सकते, क्योंकि हम समीक्षा करना चाहते हैं और जल्दी से विलय करना चाहते हैं। यह मर्ज के बाद जहां समस्या शुरू होती है, मेरी टिप्पणी देखें @SteveBarnes

— साइमन

Answer 3

आपकी समस्या यह प्रतीत होती है कि परीक्षण को चलाने में बहुत लंबा समय लगता है। सौभाग्य से, मूर के कानून ने हमें उस समस्या का समाधान प्रदान किया है। आज, हाई-एंड सर्वर सीपीयू में आसानी से 10 कोर (और 10 हाइपरथ्रेड्स) हो सकते हैं। एकल कंप्यूटर में कई ऐसे CPU हो सकते हैं।

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

तो, कई घंटे 10-30 मिनट में बदल जाएंगे।

आपने यह नहीं बताया कि बिल्ड में कितना समय लगता है, लेकिन मानक बिल्ड टूल जैसे कि बिल्ड को भी समानांतर बनाने की अनुमति देता है। यदि आप अपने यूनिट परीक्षणों को समानांतर करते हैं और विशिष्ट डेवलपर कंप्यूटर में 4 कोर और 4 हाइपरथ्रेड्स होते हैं, तो 10 मिनट से कम यूनिट परीक्षण 2 मिनट से कम में बदल जाएगा। तो, शायद आप एक नीति लागू कर सकते हैं कि हर किसी को करने से पहले इकाई परीक्षण चलाने चाहिए?

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

मुझे स्क्रम और आपकी समस्याओं के बीच कोई संबंध नहीं दिखता है। समस्याएं वास्तव में किसी भी विकास प्रक्रिया के साथ हो सकती हैं।

Comments

मैं सहमत हूं, तेजी से निर्माण के साथ चीजें बहुत आसान होंगी। हमारे TechTeam ने हमारी निर्माण प्रक्रिया की गति को सुधारने में दिन बिताए हैं, अन्यथा हम घंटों के बजाय दिनों की प्रतीक्षा कर रहे होते। अभी तक, उस प्रतिक्रिया की अवधि लगभग दी गई है। 2 घंटे। तो मैं एक दृष्टिकोण की तलाश कर रहा हूं जो "दिया" के रूप में लेता है। (बेशक, हम लगातार निर्माण में तेजी लाने की कोशिश कर रहे हैं। लेकिन निकट भविष्य के लिए, यह 2 घंटे होगा)

— साइमन

कुछ परीक्षण समानांतर रन के साथ संघर्ष कर सकते हैं

— डेफ्रिटास

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

— c_maker

Answer 4

क्या अधिक जेनकिंस इंस्टॉलेशन होना संभव नहीं है और डेवलपर्स को एक अलग जेनकिन्स इंस्टेंस पर जांचना है?

मुझे लगता है कि सबसे अच्छा समाधान यहाँ है कि कोड को सभी परीक्षणों को पास करने से पहले मास्टर शाखा में जांच की जाए और मुख्य जेनकींस उदाहरण द्वारा संकलित / परीक्षण किया जाए। लोगों को उस कोड की जांच न करने दें जो बिल्ड को तोड़ता है।

मैं अपने कोड को विकास शाखा में देखता हूं, देखें कि क्या यह परीक्षण पास करता है और पुल अनुरोध बनाता है। लेकिन आप स्पष्ट रूप से जेनकिंस एक सुविधा शाखा खींच सकते हैं और परीक्षण कर सकते हैं कि एक।

Answer 5

बिंदु (2) सबसे दर्दनाक बिंदु लगता है, इसलिए मैं उस पर ध्यान केंद्रित करूंगा।

यह कई मॉड्यूल में प्रोजेक्ट को तोड़ने का समय हो सकता है।

https://en.wikipedia.org/wiki/Dependency_inversion_principle

A. उच्च-स्तरीय मॉड्यूल निम्न-स्तर के मॉड्यूल पर निर्भर नहीं होना चाहिए। दोनों को अमूर्तता पर निर्भर होना चाहिए।

बी। सार विवरण पर निर्भर नहीं होना चाहिए। विवरण अमूर्तता पर निर्भर होना चाहिए।

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

यह आपको अन्य बिल्ड विफलताओं पर प्रतिक्रिया दे सकता है, ताकि अगले निर्माण से पहले आपके पास एक से अधिक टूटे हुए मॉड्यूल को ठीक करने का समय हो।

सामान्य तौर पर, SOLID सिद्धांतों की कल्पना पुस्तकालयों से निपटने और मुद्दों के निर्माण के लिए की जाती है। दूसरे शब्दों में - आपके द्वारा सामना की जा रही सटीक प्रकार की समस्याओं को हल करने के लिए सिद्धांतों के इस सेट की कल्पना की जाती है।

---

साइड नोट के रूप में (जूहिस्ट का जवाब देखें), यदि आप बिल्ड को अलग-अलग मॉड्यूल में विभाजित नहीं करते हैं, तो आप बिल्ड को तेज़ी से (समानांतरण द्वारा) नहीं चला सकते।

Answer 6

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

• कोड में यूनिट टेस्ट होते हैं
• एक स्वचालित निर्माण के हिस्से के रूप में इकाई परीक्षण पास
• कोड को मुख्य में मिला दिया गया है (और विवाद हल हो गए हैं)
• आदि।

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

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

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