วิธีง่ายๆในการปรับปรุงคุณภาพการเผยแพร่ในสภาพแวดล้อม RAD

พื้นหลังเล็กน้อยที่นี่ - เราเป็นทีมเล็ก ๆ (จาก 5) ของนักพัฒนา RAD ที่รับผิดชอบการพัฒนาซอฟต์แวร์ภายใน บริษัท ที่ไม่ใช่ซอฟต์แวร์ขนาดใหญ่ "ซอฟต์แวร์ภายใน" แตกต่างจากแอพพลิเคชันเดสก์ท็อป. NET ที่ใช้เซิร์ฟเวอร์ MSSQL เป็นแบ็กเอนด์ไปยังสคริปต์ Python ที่ทำงานบนพื้นหลังไปยังเอกสารและแม่แบบ MS Word - สวนสัตว์ของเทคโนโลยี

ทีมงานทั้งหมดประกอบด้วยผู้รอบรู้ทุกคนสามารถรับข้อกำหนดจากผู้ใช้รหัสมันทดสอบและปรับใช้ในการผลิต เมื่อซอฟแวร์ในการผลิตมันถูกดูแลโดยทีมอื่น แต่มันมักจะง่ายสำหรับเราที่จะเข้าไปแทรกแซงหากมีอะไรผิดพลาด

ทุกอย่างฟังดูดี แต่มีปัญหา - การเป็นทีม RAD ที่เราต้องปล่อยออกมาบ่อยครั้งและไม่มีวันที่เราจะไม่ปล่อยรุ่นใหม่ของแอปพลิเคชั่นหนึ่งหรือสอง (หรืออาจเป็นสคริปต์เอกสารเวิร์ดที่ได้รับการปรับปรุง แอพคอนโซล C ++ ฯลฯ ) ในการผลิต เราทำการทดสอบการพัฒนาและเกี่ยวข้องกับผู้ใช้ปลายทางโดยให้พวกเขาเรียกใช้ซอฟต์แวร์ในสภาพแวดล้อมของเอือด ...

... แต่ข้อบกพร่องกำลังคืบคลานเข้าสู่การผลิตอยู่ดี ผู้ใช้เข้าใจว่าข้อบกพร่องเหล่านี้และความไม่แน่นอนเป็นครั้งคราวคือราคาที่พวกเขาจ่ายเพื่อให้ได้สิ่งที่พวกเขาต้องการได้อย่างรวดเร็ว แต่ในขณะเดียวกันก็ทำให้เราคิด - บางทีเราอาจปรับปรุงการพัฒนาของเราหรือแนวทางปฏิบัติเพื่อปรับปรุงเสถียรภาพของ ซอฟต์แวร์และลดจำนวนข้อบกพร่องที่เราแนะนำเมื่อเพิ่มฟังก์ชันการทำงานใหม่

สิ่งที่ดี - เราไม่ค่อยมีกระบวนการมากนักในตอนแรกดังนั้นมันควรจะง่ายในการเริ่มต้นพัฒนาสิ่งที่ไม่ดี - เป็นทีม RAD เล็ก ๆ ที่เราไม่มีเวลาและทรัพยากรมากพอที่จะนำไปใช้ สิ่งที่ใหญ่ แต่เราได้คิดเกี่ยวกับความคิดริเริ่มดังต่อไปนี้และจะยินดีรับข้อเสนอแนะเคล็ดลับคำแนะนำและข้อเสนอแนะใด ๆ

1. ปัจจุบันแอปพลิเคชั่นบางตัวได้เปิดตัวสู่การผลิตทันทีหลังจากการทดสอบของนักพัฒนาโดยผ่านการทดสอบการยอมรับของผู้ใช้ การปฏิบัตินั้นควรถูกยกเลิกและแม้แต่การเปลี่ยนแปลงเล็กน้อยก็ต้องมีการทดสอบโดยผู้ใช้ปลายทาง แต่ละแอปพลิเคชันจะมีเครื่องทดสอบเบต้าเฉพาะที่เลือกจากผู้ใช้ปลายทาง หลังจากผู้ทดสอบเบต้าได้ตกลงแล้วจะมีการเปิดตัวรุ่นใหม่ตั้งแต่การทดสอบไปจนถึงสภาพแวดล้อมการผลิต

2. เราไม่ทำการตรวจสอบโค้ด แต่เราจะเริ่มทำการตรวจสอบโค้ดก่อนที่เราจะตรวจสอบการเปลี่ยนแปลง ฉันยังคิดเกี่ยวกับ "การตรวจสอบการเปิดตัว" - โดยทั่วไปหนึ่งในนักพัฒนาต้องนั่งถัดจากคนอื่นดูเขา / เธอกำลังทำซอร์ฟแวร์ (คัดลอกไบนารีอัปเดตการกำหนดค่าเพิ่มตารางใหม่ไปยังฐานข้อมูล ฯลฯ ) - ใช้เวลา 5-10 นาทีจึงไม่ต้องใช้เวลานานในการ "ตรวจสอบการเปิดตัว"

3. วิธีลดเวลาในการย้อนกลับเมื่อมีการพิสูจน์ว่ารุ่นใหม่นั้นมีความบั๊กพอที่จะดึงออกมาจากการผลิตและจะถูกแทนที่ด้วยรุ่นก่อนหน้าที่ดี เราเก็บประวัติของรีลีสทั้งหมด (เป็นไบนารี) เพื่อให้ง่ายต่อการย้อนกลับไปหนึ่งเวอร์ชัน - และแม้ว่าจะรวดเร็ว "เขียนทับไบนารีที่เพิ่งเปิดตัวใหม่ด้วยไบนารีเวอร์ชั่นก่อนหน้า" แต่ก็ยังเป็นกระบวนการแบบแมนนวล และเรียกร้องในบางครั้ง "จะเกิดอะไรขึ้นถ้าการย้อนกลับล้มเหลวและจะทำให้ระบบใช้ไม่ได้แทนที่จะเป็นรถ"

นี่คือที่ที่เรามีความคิดของเราหมดและเราต้องการรับความคิดเห็นของคุณเกี่ยวกับสิ่งเหล่านี้และถ้าคุณสามารถแบ่งปันคำแนะนำในการปรับปรุงกระบวนการเผยแพร่ / พัฒนากระบวนการอย่างง่าย

+1 สำหรับการสัมผัสกับตัวแบบที่ยอดเยี่ยม เมื่อเราทำ "การวางจำหน่ายในช่วงต้นมักจะเป็น" แนวการพัฒนาสิ่งต่าง ๆ ก้าวตามจริงและเมื่อโมเมนตัมสร้างปัญหาดังกล่าวเกิดขึ้นมากมาย (ดังที่คุณอธิบาย) ซึ่งเราไม่ได้เตรียมรับมือ ความกลัวที่เลวร้ายที่สุดคือเมื่อคนมองว่าความเร็วเป็นศัตรูของงานที่ดี

ฉันได้เห็นวรรณกรรมที่ จำกัด มากในเรื่องนี้อย่างไรก็ตามนี่คือสิ่งที่เราฝึกฝนซึ่งช่วยได้อย่างแน่นอน:

1. การติดตามบั๊กที่มีประสิทธิภาพ
ทำให้การติดตามบั๊กมีประสิทธิภาพมากขึ้น - สิ่งที่เราทำไม่เพียง แต่เก็บรายการบั๊กและเครื่องหมายติ๊ก แต่เมื่อปิดเราต้องกำหนดบางสิ่งเช่น "เคยทำซ้ำปัญหาได้หรือไม่", "นี่เป็นวิธีแก้ปัญหาถาวร หรือแก้ไขการทำงาน? "," สาเหตุของปัญหา "คืออะไร? สิ่งนี้จะช่วยให้รู้ว่าเกิดอะไรขึ้นเมื่อข้อผิดพลาดนี้ปรากฏขึ้นในครั้งที่แล้ว นี่คือกุญแจสำคัญในการตรวจสอบว่าข้อผิดพลาดไม่ซ้ำบ่อย

2. กำหนดจุดถอยกลับของกุญแจ
เราทุกคนรู้ว่าข้อบกพร่องจะมาถึงดังนั้นเราจะต้องให้การถอยกลับที่มีประสิทธิภาพซึ่งทำงานได้บ่อยที่สุด ครั้งแล้วครั้งเล่าเราจบ (ด้วยอัตราส่วนประมาณ 1 ของทุก ๆ 10 ในกรณีของเรา) รุ่นทั่วไปที่ทำงานได้ทุกที่ในลักษณะที่เชื่อถือได้มากที่สุด จำนวนรวมของการเปิดตัวอาจมีจำนวนมาก แต่หากมีสิ่งใดผิดพลาดการถอยกลับนั้นมีให้เลือกน้อยและคุณไม่จำเป็นต้องถอยกลับไปอีก หนึ่งในวิธีที่ง่ายที่สุดที่จะทราบว่าการถอยกลับที่ดีที่สุดคือการดูว่าการวางจำหน่ายรุ่นแรกที่ทำงานนานที่สุดในการผลิตโดยไม่มีปัญหามาก

3. แยกแยะความเสี่ยงและความเสถียรหรือการแก้ไขข้อผิดพลาดเล็ก ๆ
เมื่อเรารู้ว่าเรามีการเปลี่ยนแปลงอัลกอริทึมที่สำคัญมีโอกาสมากขึ้นที่ข้อบกพร่องอาจคืบคลานเข้ามาในสถานการณ์ที่ไม่ได้คาดการณ์ไว้ทั้งหมด ในกรณีที่มีบางครั้งที่ปัญหามีขนาดเล็กมาก (หรือเข้าใจดี) และมีความเสี่ยงน้อย ทำไม่ได้สโมสรการทำงานดังกล่าวและข้อผิดพลาดง่าย ๆ ในรุ่นเดียวกัน แก้ไขบั๊กที่เล็กกว่าก่อนซึ่งจะต้องไปทุกที่ที่ต้องการ สร้างรีลีสเฉพาะสำหรับชุดคุณสมบัติพิเศษที่ดีที่สุดคุณสามารถเลิกใช้ฟีเจอร์นั้นได้ แต่ แต่บั๊กที่สำคัญอื่น ๆ ทั้งหมดยังคงมีอยู่ในรุ่นก่อนหน้า

4. สาขาสำหรับการพัฒนาคุณลักษณะที่สำคัญ
สิ่งใดก็ตามที่เชื่อมโยงการเปลี่ยนแปลงที่มีผลกระทบต่อการออกแบบต้องกระทำแยกต่างหากในสาขา การพัฒนาที่ใหญ่ขึ้นไม่ได้เสร็จสิ้นอย่างรวดเร็วเมื่อเทียบกับข้อบกพร่องเล็ก ๆ หากเราแนะนำระดับกลางที่มีงาน 'บางส่วน' ที่เกี่ยวข้องกับคุณสมบัติที่ยังไม่ได้ใช้งาน - เป็นพื้นที่แนะนำข้อบกพร่องที่มีศักยภาพ ข้อผิดพลาดที่จะไม่เกิดขึ้นหากการทำงานเต็มรูปแบบสำหรับคุณสมบัติจะเสร็จสมบูรณ์แบบอะตอมดังนั้นนี่คือข้อบกพร่องที่เราจะไม่ต้องแก้ไขหากมีสาขา

5. วางแผนการวางจำหน่ายทุกครั้งซึ่งเป็นธีมที่ใช้
หลาย ๆ ครั้งที่บั๊กต่าง ๆ มาถึงรีลีสที่แตกต่างกัน - แต่มันก็เป็นการดีที่สุดที่จะจัดระเบียบบั๊ก (และฟีเจอร์) ที่ส่งผลกระทบต่อโมดูลที่คล้ายกัน เตรียมการปล่อยแผนที่ถนนล่วงหน้าให้ดีอยู่เสมอ ข้อบกพร่องยังคงหลั่งไหลเข้ามา - และนั่นก็ตกอยู่ในเป้าหมายที่แตกต่างกันเพื่อให้มีกลุ่มของแมลงที่ดีที่จะถูกยิงด้วยกันอย่างดีที่สุด เมื่อรวมข้อบกพร่องที่คล้ายกันเข้าด้วยกันมันจะให้ความเข้าใจที่ดีขึ้นเกี่ยวกับสถานการณ์ที่ขัดแย้งกัน

6. ขยายรีลีสใหม่ให้กับลูกค้าบางรายก่อน
ในกรณีของเราเราเห็นการทดสอบในสองไซต์แรกและไซต์อื่น ๆ ทั้งหมดจะใช้รีลีสเฉพาะเมื่อมีความต้องการเท่านั้น หลายครั้งที่ผู้ใช้ (หรือส่วนใหญ่) จะกระโดดจากรุ่นเสถียรไปสู่รุ่นเสถียรอื่นเท่านั้น

7. การทดสอบการถดถอย
ตามสายของข้อบกพร่องที่ถูกรวบรวม - สร้างชุดการถดถอย ถ้าเป็นไปได้ให้ทำเครื่องหมายข้อบกพร่องที่สำคัญและทดสอบว่าสำคัญที่สุดที่จะกลายเป็นเกณฑ์ขั้นต่ำที่จะทดสอบก่อนที่ผู้สมัครจะกลายเป็นรุ่นที่แน่นอน

8. หยุดชั่วคราวและไตร่ตรอง
เมื่อมีหลายสิ่งหลายอย่างดำเนินไปอย่างเต็มตัวควรมีเวลาพักบ้าง - หยุดสักพักแล้วปล่อยสิ่งที่ไม่มีประโยชน์ ในความเป็นจริงมีวันหยุดของการเผยแพร่บางครั้ง (ระยะเวลานั้นแปรผกผันกับความถี่) ตัวอย่างเช่นหลาย ๆ ครั้งที่เรามีสิ่งเหล่านี้เรียกว่า "การล้างข้อมูล" ซึ่งไม่ได้มีอะไรใหม่ในมุมมองการทำงาน - แต่ช่วยในการดูแลรักษาโค้ดได้ดี การเผยแพร่ดังกล่าวส่วนใหญ่เป็นจุดถอยที่ยอดเยี่ยมซึ่งคุณแทบไม่เคยนึกถึงประวัติก่อนหน้านั้นมาก่อน

9. บางทีสิ่งที่แปลกที่สุดที่
ฉันพบว่าใช้ยากนี้บ่อยครั้ง แต่เป็นกลอุบายที่ดี สลับเจ้าของโมดูลที่แน่นอน เมื่อผู้คนถูกถามถึงการทบทวนโค้ดให้ทำไม่มากนักจากการฝึกฝนนี้ แต่เมื่อคุณต้องจัดการกับรหัสใหม่นั้นอย่างจริงจังเมื่อคุณสลับผู้เขียนความผิดปกติที่ "ไม่ดี" ที่อาจเกิดขึ้นจะถูกสังเกตได้อย่างรวดเร็วก่อนที่พวกเขาจะเริ่มก่อให้เกิดมลพิษ แน่นอนว่านี่เป็นการลดความเร็ว - แต่ถ้าคุณทำเช่นนี้บ่อยครั้งโอกาสที่ผู้คนจะเชี่ยวชาญในส่วนต่าง ๆ ของรหัสและเรียนรู้เกี่ยวกับผลิตภัณฑ์ทั้งหมดซึ่งเป็นวิธีที่ชาญฉลาดในการสอน

10. สุดท้าย แต่ไม่ใช่อย่างน้อย
เรียนรู้ที่จะกลับไปที่ไวท์บอร์ดบ่อยๆ ยิ่งคุณคิดอีกครั้งราวกับว่าคุณสมบัตินี้จะเป็นส่วนหนึ่งของการออกแบบเริ่มต้นของเราเราจะคิดถึงการออกแบบในเวลานั้นอย่างไร บางครั้งความท้าทายที่ยิ่งใหญ่ที่สุดกับงานที่เพิ่มขึ้นก็คือเราถูก จำกัด ด้วยลำดับการทำงานที่เราสร้างขึ้นก่อนและบ่อยครั้งที่ไม่สามารถย้อนกลับไปสู่พื้นฐานได้ เคล็ดลับคือการคอยดูว่าเราจะพูดคุยกันโดยทั่วไปอย่างไรแทนที่จะรองรับคุณสมบัติใหม่หรือสถานการณ์จำลองนี้ สิ่งนี้ต้องการการออกแบบที่ยังคงเป็นปัจจุบันและเกิดขึ้นได้ก็ต่อเมื่อเรากลับไปเขียนกระดานบ่อยครั้ง นอกจากนี้ในขณะที่โปรแกรมเมอร์รุ่นใหม่เข้าร่วมพวกเขากลายเป็นส่วนหนึ่งของแท็งก์การคิดมากกว่าแค่วางแพตช์

แก้ไข
11. ติดตามการทำงานและออกแบบช่องว่าง
บ่อยครั้งที่เราอยู่ภายใต้แรงกดดันของระยะเวลาในการแก้ไขข้อบกพร่องและปล่อยในการผลิต อย่างไรก็ตามเมื่อข้อผิดพลาดอยู่ในระดับการออกแบบสิ่งเล็ก ๆ น้อย ๆ ต้องเปลี่ยน แต่บ่อยครั้งที่คนจะแก้ไขด้วยการลัดสั้น ๆ เพื่อให้ทันกำหนด นี่คือตกลง อย่างไรก็ตามในขณะที่การแก้ปัญหาเพิ่มขึ้นหลายอย่างรหัสก็จะบอบบาง ติดตามเป็นพิเศษเกี่ยวกับจำนวนช่องว่างการออกแบบที่มีอยู่แล้วโดยทั่วไปเมื่อคุณเจรจาระยะเวลากับผู้จัดการโครงการที่ดีที่สุดคือการทำให้เขา / เธอมุ่งมั่นที่เราจะส่งสิ่งนี้ในทางลัดเพื่อประหยัดการผลิต แต่เราจะต้อง กำหนดเวลาและแหล่งข้อมูลเพื่อรับวิธีแก้ไขปัญหาอย่างถาวร

ฉันทำงานในทีม dev เล็ก ๆ ด้วย (เราแค่ 2 คนเท่านั้น) และเราประสบปัญหาคล้ายกันที่คุณพูดถึง ประเด็นหลักสำหรับเราคือเราทั้งคู่มักจะทำงานแยกกันและมันก็กลายเป็นเรื่องธรรมดาเกินไปที่เราจะทำงานให้เสร็จสมบูรณ์ / ทดสอบทดสอบ (ทดสอบโดยผู้พัฒนาเท่านั้น) และปล่อยอย่างรวดเร็ว สิ่งนี้ส่งผลให้มีการเผยแพร่ขนาดเล็กจำนวนมากกับผู้ใช้ที่รายงานข้อบกพร่องเล็ก ๆ ที่ควรจะหยิบมาทดสอบได้ง่าย

เพื่อปรับปรุงกระบวนการของเราฉันเริ่มต้นด้วยการแนะนำบอร์ดKanban กระดานนี้ง่ายมากที่จะเริ่มต้นด้วยและมีเพียงไม่กี่คอลัมน์ (ตั้งค่าโดยใช้ไวท์บอร์ด, บัตรดัชนีและแม่เหล็กสี):

Backlog | สิ่งที่ต้องทำ เสร็จสิ้น

อย่างไรก็ตามสิ่งนี้พัฒนาอย่างรวดเร็วเพื่อสะท้อนกระบวนการจริงของเรา:

Backlog | การพัฒนา | dev ทดสอบ | UAT | เสร็จสิ้น | การเผยแพร่

พร้อมกับบอร์ดเรามีกฎว่าแต่ละงาน / คุณสมบัติจะต้องทดสอบโดยนักพัฒนาอื่น (เช่นเดียวกับนักพัฒนาที่ใช้งานคุณสมบัติ) ดังนั้นเมื่อการ์ดถึงคอลัมน์ 'เสร็จสิ้น' ควรได้รับการทดสอบโดยนักพัฒนาซอฟต์แวร์อย่างน้อย 2 คนและผู้ใช้ได้รับการทดสอบแล้ว

มีประโยชน์อื่น ๆ อีกมากมายในการใช้ Kanban สำหรับเราแล้วมันมีการปรับปรุงการสื่อสารและช่วยให้เราแบ่งปันความรู้ในขณะที่เรามีส่วนร่วมในระดับหนึ่งในแต่ละงาน นอกจากนี้ยังปรับปรุงกระบวนการวางจำหน่ายของเราเนื่องจากเราสามารถเห็นได้ว่างาน / คุณสมบัติใดพร้อมที่จะปล่อย / ทำและบางครั้งสามารถระงับการปล่อยถ้าเรารู้ว่าจะมีการทำ taks อื่น ๆ ในไม่ช้า สำหรับคนที่อยู่นอกทีมคณะกรรมการยังทำหน้าที่เป็นข้อมูลอ้างอิงอย่างรวดเร็วเพื่อดูว่าเรามีงานที่ต้องทำอะไรบ้างงานที่ทำอยู่ในปัจจุบันและงานที่เพิ่งเปิดตัว

เราใช้แม่เหล็กสี (หนึ่งตัวต่อนักพัฒนา) เพื่อตั้งค่าสถานะการ์ดที่เรากำลังดำเนินการอยู่ แต่ตัวเลือกอื่นคือการเพิ่มเลนว่ายน้ำ (แถว) หนึ่งตัวต่อนักพัฒนาและวางการ์ด Kanban ในเลนว่ายน้ำที่เกี่ยวข้อง อีกครั้งสิ่งนี้จะช่วยเป็นข้อมูลอ้างอิงอย่างรวดเร็วเพื่อดูว่านักพัฒนาแต่ละคนทำงานอะไรอยู่

ลิงค์อื่น ๆ ที่ฉันพบว่ามีประโยชน์:

Kanban ประยุกต์ใช้กับการพัฒนาซอฟต์แวร์: จาก Agile ถึง Lean

ระบบ Kanban สำหรับวิศวกรรมซอฟต์แวร์ - วิดีโอ

หวังว่า Kanban จะพูดกับประเด็นที่ 1 ในคำถามของคุณ ในส่วนที่เกี่ยวข้องกับการตรวจสอบโค้ดเราดำเนินการในขั้นตอนการทดสอบอุปกรณ์เพื่อให้การเปลี่ยนแปลงใด ๆ ที่จำเป็นหลังจากการตรวจทานนั้นได้รับการทดสอบอีกครั้งก่อนที่จะไปที่ UAT การย้อนกลับขึ้นอยู่กับสภาพแวดล้อมของคุณ แต่เราปรับใช้ไฟล์แอปพลิเคชันไปยัง Terminal Server โดยใช้ไฟล์แบทช์ซึ่งเปลี่ยนชื่อไฟล์ปัจจุบันและคัดลอกไฟล์ใหม่จากเซิร์ฟเวอร์กลางและเราสามารถย้อนกลับได้อย่างง่ายดายโดยการวางแบ็คอัพ และเรียกใช้สคริปต์อีกครั้ง

คุณได้ระบุแล้วว่าคุณรู้ว่ามีปัญหากับกระบวนการของคุณที่ส่งผลกระทบต่อคุณภาพของซอฟต์แวร์ของคุณและในขณะที่คำถามนี้จะกระตุ้นให้เกิดคำตอบที่หลากหลายคำแนะนำของฉันคือการดูที่หัวข้อวิศวกรรมซอฟต์แวร์และลองและเรียนรู้ว่า นักพัฒนาในหลักพบว่าตัวเองกำลังทำอะไรมากขึ้นเรื่อย ๆ ในพื้นที่นั้น ฉันขอแนะนำให้คุณเริ่มอ่านแหล่งข้อมูลที่ดีบางอย่างเพื่อให้ตัวคุณเองเริ่มต้น บางสิ่งที่อยู่ในใจ:

• การพัฒนาซอฟต์แวร์แบบลีนโดย Mary และ Tom Poppendeick ให้การอ่านที่ยอดเยี่ยมสำหรับผู้ที่สนใจในการเรียนรู้วิธีระบุ "ของเสีย" และสิ่งที่ต้องทำเกี่ยวกับการเปลี่ยนกระบวนการเพื่อให้ผอมและมีประสิทธิภาพมากขึ้น
• การพัฒนาซอฟท์แวร์แรกโดย Dan Pilone และ Russ Miles เป็นเหมือนหนึ่งในหนังสือ "สำหรับหุ่น" ในแวบแรก แต่เมื่อมองผ่านรูปแบบการนำเสนอที่ยุ่งเหยิงเพียงเล็กน้อยมันมีข้อมูลส่วนใหญ่ที่เกี่ยวข้องกับพื้นฐานของวิศวกรรมซอฟต์แวร์ และมีการเขียนสั้น ๆ เกี่ยวกับการทดสอบพัฒนาขับเคลื่อน
• แนะนำ BDDหน้าแดนนอร์ทเกี่ยวกับการเข้าสู่พฤติกรรมการขับเคลื่อนการพัฒนาหรือบางทีคุณอาจจะชอบBDD วิกิพีเดีย สิ่งเหล่านี้เป็นการอ้างอิงเริ่มต้นสำหรับ BDD และคุณอาจต้องการค้นหาเครื่องมือและกรอบงานเพื่อช่วยคุณ สิ่งสำคัญที่ต้องเข้าใจคือ BDD นั้นถูกนำไปใช้อย่างมีประสิทธิภาพในระดับที่สูงขึ้น ช่วยให้คุณคิดเกี่ยวกับการทดสอบในขณะที่คุณกำลังคิดถึงข้อกำหนดและทดสอบในภาษาเดียวกับที่คุณใช้เมื่อคุณเขียนรายละเอียด โดยทั่วไปเฟรมเวิร์กจะรวมเข้ากับเฟรมเวิร์กการทดสอบหน่วยอื่น ๆ ดังนั้นคุณจะได้รับประโยชน์สูงสุดจากทั้งสองโลกหากคุณตัดสินใจว่าการทดสอบของคุณอาจไม่ได้รับประโยชน์จากไวยากรณ์ BDD
• บทความการพัฒนาซอฟต์แวร์ Agile Software ของ Wikipedia เป็นข้อมูลเบื้องต้นที่ดีเกี่ยวกับการพัฒนาซอฟต์แวร์ agile และให้การอ้างอิงและลิงก์ที่มีประโยชน์จำนวนมากแก่บุคคลที่น่านับถือของชุมชนการพัฒนา

ในการปรับปรุงวิธีการทำงานของคุณคุณต้องยอมให้ตัวเองเปิดกว้างและเต็มใจที่จะก้าวออกนอกเขตความสะดวกสบายของคุณเพื่อเรียนรู้ที่จะปรับปรุงสิ่งที่คุณทำโดยไม่ยึดติดกับแนวคิดบางอย่างที่คุณอาจพบว่าเป็น สะดวกสบายมากขึ้นที่จะแขวนบนเพื่อ การพูดจากประสบการณ์ส่วนตัวนี่อาจเป็นสิ่งที่ยากที่สุดที่จะทำหรือให้กำลังใจผู้อื่น

การเปลี่ยนแปลงเป็นเรื่องยากในช่วงเวลาที่ดีที่สุดแม้ว่าคุณจะรู้สึกว่าคุณกำลังมองหาความเปลี่ยนแปลงดังนั้นคำแนะนำที่ดีที่สุดที่ฉันสามารถให้คุณได้คือการดูวิธีการต่าง ๆ ของ Agile ที่พัฒนาขึ้นในช่วงหลายปีที่ผ่านมาเพื่อทำความคุ้นเคยกับแนวทางปฏิบัติ ที่ได้รับการพิจารณาว่ามีความสำคัญที่สุด (เช่น: การทดสอบหน่วย, การรวมอย่างต่อเนื่อง, การเปลี่ยนโครงสร้าง, ฯลฯ ... ) จากนั้นเลือกวิธีการที่ใกล้เคียงกับสิ่งที่คุณและทีมงานจะรู้สึกสะดวกสบายที่สุด เมื่อคุณตัดสินใจแล้วให้ปรับแนวทางปฏิบัติและกระบวนการพัฒนาของคุณเพื่อให้เหมาะสมกับวิธีที่ทีมของคุณต้องการทำงานโดยคำนึงถึงหลักการที่ไม่ติดมันและวิธีที่คุณต้องการทำงานเพื่อให้ทีมของคุณสามารถสร้างคุณค่าที่ยิ่งใหญ่ที่สุดด้วย เสียน้อยที่สุด สุดท้าย

หากคุณรู้สึกว่ากระบวนการของคุณต้องการการปรับแต่ง แต่คุณเป็นห่วงว่าห่วงโซ่เครื่องมือของคุณยังไม่สามารถตอบสนองความต้องการของคุณได้ อย่างน้อยที่สุดผลิตภัณฑ์การรวมการรวมอย่างต่อเนื่อง (เช่น Continuum, Cruise Control หรือ Hudson) และระบบการติดตามปัญหา (เช่น Jira หรือ Redmine) ควรให้ความสำคัญเพื่อช่วยให้คุณสร้างกระบวนการสร้างและวางจำหน่ายอัตโนมัติ และเพื่อให้บั๊กและคำขอคุณสมบัติของคุณอยู่ในการตรวจสอบ

ความจริงก็คือไม่ว่ากระบวนการของคุณจะเป็นอย่างไรถ้าคุณไม่ลงทุนกับเวลาเพื่อให้ได้สิ่งที่ "ถูกต้อง" สำหรับทีมของคุณปัญหาของคุณก็จะเติบโตต่อไปตามกาลเวลาและการรับรู้เวลาว่าง หดตัวตาม การเปลี่ยนแปลงครั้งใหญ่มักเกิดจากคำถามเมื่ออยู่ภายใต้แรงกดดันอย่างหนัก แต่ให้ลอง "ห้องเลื้อย" เล็ก ๆ น้อย ๆ เพื่อให้ระบบเข้ามาช่วยให้คุณก้าวเข้าสู่วิสัยทัศน์ของทีมเกี่ยวกับวิธีการในอุดมคติ

เมื่อใดก็ตามที่ฉันได้ยินเกี่ยวกับข้อบกพร่องคำถามแรกของฉันจะเกี่ยวกับที่มาของข้อบกพร่องและที่ที่พวกเขาได้รับการตรวจจับและลบออก ประสิทธิภาพการกำจัดข้อบกพร่องเป็นวิธีที่ดีในการวัดและติดตามสิ่งนี้ ด้วยการทราบว่าข้อบกพร่องมาจากที่ใดและทำงานเพื่อปรับปรุงกระบวนการในเฟสเหล่านั้นคุณสามารถลดเวลาและต้นทุนของโครงการได้ เป็นที่ทราบกันดีว่ามันถูกกว่าที่จะแก้ไขข้อบกพร่องที่ใกล้กับจุดฉีดดังนั้นเมื่อคุณทราบว่าข้อบกพร่องนั้นมาจากที่ไหนคุณสามารถดูการเปลี่ยนแปลงของกิจกรรมเพื่อปรับปรุงขั้นตอนเหล่านั้นได้

เมื่อคุณมีข้อมูลเกี่ยวกับที่มาของข้อบกพร่องคุณสามารถดูได้ว่าเทคนิคและเทคโนโลยีที่คุณต้องการใช้นั้นคืออะไร ความคิดเห็นเกี่ยวกับข้อกำหนดการออกแบบและรหัสการทดสอบอัตโนมัติการวิเคราะห์แบบคงที่การรวมอย่างต่อเนื่องและการทดสอบที่ครอบคลุมโดยผู้ใช้อาจเป็นตัวเลือกที่คุณควรพิจารณาทั้งนี้ขึ้นอยู่กับว่าเฟสใดที่ทำให้เกิดข้อบกพร่อง

หากต้องการขยายความต้องการในการตรวจสอบโค้ดคุณควรพิจารณาระดับการตรวจสอบโค้ดในระดับต่างๆตามลำดับความสำคัญและความเสี่ยงของโมดูล ความเสี่ยงต่ำและโมดูลที่มีลำดับความสำคัญต่ำอาจไม่จำเป็นต้องมีการตรวจสอบโค้ดเลยหรืออาจเป็นเพียงการตรวจสอบที่โต๊ะง่าย ๆ ซึ่งผู้พัฒนารายอื่นเพียงแค่อ่านโค้ดด้วยตนเองและแสดงความคิดเห็น เทคนิคการตรวจสอบรหัสอื่น ๆ รวมถึงการเขียนโปรแกรมคู่คำแนะนำการวิพากษ์วิจารณ์และการตรวจสอบกับนักพัฒนาจำนวนมาก

สำหรับวัตถุประสงค์ในการย้อนกลับฉันจะมองหากระบวนการอัตโนมัติโดยใช้สคริปต์บางประเภทเพื่อให้เร็วขึ้นและมีข้อผิดพลาดน้อยลง ในโลกที่สมบูรณ์แบบฉันต้องการเพิ่มคุณภาพของผลิตภัณฑ์ที่จัดส่งโดยที่ไม่จำเป็นต้องย้อนกลับไปและคุณสามารถบรรลุเป้าหมายนี้ได้ การมีความสามารถนั้นอาจเป็นความคิดที่ดี แต่ทำให้ไม่เจ็บปวดเท่าที่จะเป็นไปได้

ดังที่คนอื่น ๆ ชี้ให้เห็นการเพิ่มการทดสอบการถดถอยจะช่วยหลีกเลี่ยงข้อบกพร่องที่เหมือนกันในอนาคต อย่างไรก็ตามหากคุณกำลังพบข้อบกพร่องใหม่อาจถึงเวลาที่คุณจะต้องเพิ่มการยืนยัน (หรือที่รู้จักในสัญญา) ลงในรหัสที่ระบุเงื่อนไขล่วงหน้าเงื่อนไขภายหลังและค่าคงที่ของคลาสและวิธีการ

ตัวอย่างเช่นถ้าคุณมีคลาสที่เมธอดสามารถรับเฉพาะตัวเลขระหว่าง 10 และ 25 (ซึ่งเรียกว่าเงื่อนไขล่วงหน้า) คุณจะเพิ่มคำสั่ง assert ที่จุดเริ่มต้นของเมธอด เมื่อการยืนยันนี้ล้มเหลวโปรแกรมจะหยุดทำงานทันทีและคุณจะสามารถติดตามวิธีการที่นำไปสู่ความล้มเหลวนั้นได้

Python, PHP และภาษาการเขียนโปรแกรมอื่น ๆ จะถูกพิมพ์แบบไดนามิกและไม่ได้เพิ่มเงื่อนไขมากมายให้กับวิธีการต่างๆ ทั้งหมดที่จำเป็นสำหรับบางสิ่งบางอย่างในการทำงานคือมันใช้วิธีการเฉพาะ ฉันสงสัยว่าคุณต้องการเงื่อนไขเพิ่มเติมเกี่ยวกับวิธีการของคุณ คุณต้องกำหนดและทดสอบเพื่อให้แน่ใจว่าวิธีการสามารถทำงานได้จริงในสภาพแวดล้อมของมัน

สำหรับโปรแกรม C / C ++ ฉันพบว่าการเพิ่มการยืนยันเพื่อทดสอบการจัดสรรหน่วยความจำมีประโยชน์มากในการลดจำนวนหน่วยความจำรั่วในโปรแกรม