เพราะเหตุใดลุงบ๊อบจึงแนะนำว่ามาตรฐานการเข้ารหัสไม่ควรจดบันทึกหากคุณสามารถหลีกเลี่ยงได้
หากคุณกำลังถามเหตุผลที่อยู่เบื้องหลังความเห็นของเขาคุณอาจมีคำตอบเฉพาะถ้าเขาจะโพสต์คำตอบที่นี่ ( ความคิดเห็นของเราไม่เกี่ยวข้องเลย) อย่างไรก็ตาม ...
เหตุใดฉันจึงไม่ควรเขียนมาตรฐานการเข้ารหัส
หากคุณกำลังถามว่าเขาเป็นคนที่เหมาะสมเกี่ยวกับมันให้ฉันเป็นเพียงคนเดียวที่ไม่เป็นที่นิยมหนึ่ง (ไกล) เพื่อบอกว่าคุณมีเหตุผลที่จะหลีกเลี่ยงมันไม่มี
เขียนมันลง อย่างไรก็ตามฉันจะพยายามอธิบายเหตุผลของฉัน ...
เดวิดเสนอแนะในความคิดเห็นว่าประเด็นหลักของคำตอบของสตีเฟ่นไม่ใช่เหตุผลที่คุณไม่ควรเขียนเอกสาร แต่อยู่ในรูปแบบใด หากมีการใช้แนวทางอย่างเป็นทางการในเครื่องมือ (ไม่ใช่แค่การตรวจสอบโค้ดด้วยตนเอง) ฉันอาจเห็นด้วย (เมื่อกฎหมายไม่ต้องการสิ่งอื่น) โปรดทราบว่าน่าเสียดายที่เครื่องมือไม่สามารถตรวจสอบทุกอย่าง (ทฤษฎีการคำนวณไม่ได้เป็นเพื่อนของเรา) มักจะเป็นเพราะพวกเขากำลัง จำกัด ให้เฉพาะหน่วยการแปลหรือแพคเกจหรือสิ่งที่โทรภาษาที่คุณชื่นชอบเขตแดน
อย่างไรก็ตามถ้อยคำของลุงบ๊อบไม่ได้ทำให้ฉันคิดว่าเขากำลังพูดถึงเรื่องนั้น
ฉันไม่เห็นด้วยกับผู้เชี่ยวชาญอาวุโสคนนั้นได้ไหม ฉันทำเกือบทุกจุดในโพสต์ที่อ้างถึง (ดูส่วนที่สองของคำตอบนี้เพื่อดูรายละเอียด) ลองทำความเข้าใจว่าทำไม (สมมติว่าคุณรู้อยู่แล้วว่าแนวทางการเข้ารหัสไม่ได้เกี่ยวกับปัญหาการจัดรูปแบบเล็กน้อย)
- ในบางสถานการณ์กฎหมายกำหนดมาตรฐานการเข้ารหัสเป็นลายลักษณ์อักษร
- ฉันอ่านเอกสารและฉันแน่ใจว่าฉันไม่ได้อยู่คนเดียว สมาชิกในทีมอาจเปลี่ยนแปลงได้เมื่อเวลาผ่านไปความรู้ไม่สามารถอยู่ใน codebase อายุ 5-10 ปีหรือในใจของสมาชิกในทีม องค์กรควรไล่คนที่ไม่ปฏิบัติตามแนวทางภายใน
- มาตรฐานการเข้ารหัสเมื่อได้รับการอนุมัติจะไม่เปลี่ยนแปลงบ่อยและหากคุณต้องการทราบเกี่ยวกับมัน หากมาตรฐานเปลี่ยนไปเอกสารของคุณ(เป็นรหัส) ล้าสมัยเพราะรหัสทั้งหมดของคุณไม่เป็นไปตามมาตรฐานใหม่ การจัดรูปแบบ / refactoring อาจจะช้า แต่คุณมักจะมีเขียนเผด็จการแนวทางที่จะปฏิบัติตาม
- การอ่านเอกสาร 5 หน้าดีกว่าการตรวจสอบ 10 / 20K LOC เพื่อคาดการณ์กฎ (ซึ่งคุณอาจเข้าใจผิด BTW) ไม่ต้องสงสัยเลยว่า
- เป็นเรื่องน่าขันที่ใครบางคนที่เขียนหนังสือหลายเล่มเกี่ยวกับหลักการออกแบบและสไตล์การเขียนโค้ดแนะนำว่าคุณไม่ควรเขียนแนวทางของคุณเองมันจะดีกว่าไหมถ้าเขาทิ้งตัวอย่างโค้ดไว้กับเรา? ไม่เพราะแนวทางที่เป็นลายลักษณ์อักษรไม่เพียง แต่บอกคุณว่าต้องทำอะไร แต่ยังมีอีกสองสิ่งที่รหัสขาด: สิ่งที่ไม่ควรทำและเหตุผลที่ต้องทำหรือไม่
"การเขียนโปรแกรมจัดระเบียบตนเองฟรี" ดีสำหรับนินจาอายุ 16 ปี แต่องค์กรมีข้อกำหนดอื่น ๆ :
- คุณภาพของรหัสจะต้องได้รับ (และกำหนดไว้) ในระดับ บริษัท ไม่ใช่สิ่งที่ทีมเดียวอาจตัดสินใจ พวกเขาอาจไม่มีทักษะในการตัดสินใจว่าจะดีกว่า (ตัวอย่างเช่นนักพัฒนาจำนวนเท่าไรมีทักษะที่จำเป็นทั้งหมดเพื่อทบทวน MISRA หรือแม้แต่เข้าใจกฎแต่ละข้อเท่านั้น)
- สมาชิกอาจถูกย้ายข้ามทีมต่าง ๆ : ถ้าทุกคนปฏิบัติตามมาตรฐานการเข้ารหัสเดียวกันการรวมนั้นราบรื่นและมีข้อผิดพลาดน้อยกว่า
- ถ้าทีมเป็นตัวการจัดระเบียบแล้วมาตรฐานจะมีวิวัฒนาการในช่วงเวลาที่สมาชิกในทีมเปลี่ยน - แล้วคุณจะมี codebase ขนาดใหญ่ที่ไม่เป็นไปตามปัจจุบันมาตรฐานได้รับการยอมรับ
หากคุณกำลังคิดเกี่ยวกับผู้คนก่อนกระบวนการผมขอแนะนำให้อ่านเกี่ยวกับ TPS เท่านั้น: มนุษย์เป็นส่วนสำคัญของการผลิตแบบลีน
แน่นอนว่าองค์กรขนาดเล็กที่มีเพียงหนึ่งทีมอาจปล่อยให้ทีมตัดสินใจว่าจะนำมาตรฐานมาใช้ แต่ต้องเขียนลงไป ที่นี่ใน Programmers.SE คุณอาจจะอ่านโพสต์โดยเอริค Lippert: ฉันคิดว่าเราทุกคนเห็นด้วยเขาเป็นนักพัฒนาที่มีประสบการณ์เมื่อเขาทำงานให้กับไมโครซอฟท์ที่เขาจะต้องเป็นไปตามหลักเกณฑ์การเขียนของพวกเขา (แม้ว่ากฎบางอย่างอาจจะไม่ถูกต้อง , ไม่ได้บังคับหรือไร้ประโยชน์ถึงเขา) แล้ว Jon Skeet ล่ะ? หลักเกณฑ์ของ Google ค่อนข้างเข้มงวด (และหลายคนไม่เห็นด้วยกับพวกเขา) แต่เขาต้องปฏิบัติตามแนวทางดังกล่าว พวกเขาดูหมิ่นหรือไม่? ไม่มีพวกเขาอาจจะทำงานเพื่อกำหนดและปรับปรุงแนวทางดังกล่าว บริษัท ไม่ได้ทำโดยหนึ่งในสมาชิก (หรือทีมใดทีมหนึ่ง) และแต่ละทีมไม่ได้เป็นเกาะ
ตัวอย่าง
- คุณตัดสินใจที่จะไม่ใช้มรดกหลายและการเรียนซ้อนกันใน C ++ เพราะคุณสมาชิกในทีมที่เกิดขึ้นจริงไม่เข้าใจมันได้ดี หลังจากนั้นบางคนที่ต้องการใช้การสืบทอดหลายครั้งต้องเรียกดู LOC ทั้งหมด 1M เพื่อดูว่ามีการใช้งานหรือไม่ มันไม่ดีเพราะถ้าการออกแบบไม่ได้มีการบันทึกไว้คุณต้องศึกษา codebase ทั้งหมดเพื่อทำความเข้าใจ และถึงแม้ว่าถ้ามันไม่ได้ใช้งานนั่นเป็นเพราะมันขัดกับมาตรฐานการเข้ารหัสหรืออนุญาต แต่ก็ไม่มีสถานการณ์ก่อนหน้านี้ที่การสืบทอดหลายแบบนั้นเหมาะสมหรือไม่
- ใน C # คุณมีวิธีการมากเกินไปเพื่อให้พารามิเตอร์เริ่มต้นเพราะฐานรหัสของคุณเริ่มต้นเมื่อพารามิเตอร์ทางเลือกไม่สามารถใช้ได้ใน C # จากนั้นคุณเปลี่ยนและคุณก็เริ่มใช้มัน (ทำการเปลี่ยนรหัสเก่าให้ใช้ทุกครั้งที่คุณต้องแก้ไขฟังก์ชั่นดังกล่าว) แม้ในภายหลังคุณตัดสินใจว่าพารามิเตอร์ทางเลือกไม่ดีและคุณเริ่มหลีกเลี่ยงการใช้พารามิเตอร์เหล่านั้น อะไรคือกฎรหัสของคุณบอกคุณ? มันไม่ดีเพราะวิวัฒนาการมาตรฐานแต่โค้ดเบสนั้นช้ากว่าที่จะวิวัฒนาการและถ้ามันเป็นเอกสารของคุณคุณก็มีปัญหา
- จอนย้ายจากทีม A ไปยังทีม B. จอนต้องเรียนรู้มาตรฐานใหม่ ในขณะที่การเรียนรู้เขาอาจจะแนะนำข้อบกพร่องที่ละเอียดยิ่งขึ้น (หรือหากโชคดีใช้เวลานานในการทำความเข้าใจโค้ดที่มีอยู่และทำให้การตรวจสอบโค้ดอีกต่อไป)
- ทีม A ย้ายไปยัง codebase ที่ทีม B เป็นเจ้าของก่อนหน้านี้มันมีมาตรฐานการเข้ารหัสที่แตกต่างกันโดยสิ้นเชิง เขียน? ปรับ? ผสม? พวกเขาทั้งหมดไม่ดีเท่ากัน
ลุงบ๊อบ
ปล่อยให้พวกมันมีวิวัฒนาการในช่วงการทำซ้ำสองสามครั้งแรก
ทรูจนกว่าคุณจะไม่ได้มีมาตรฐานและองค์กรของคุณได้รับมอบหมายงานที่คุณจะสร้างหนึ่ง
ให้พวกเขาเป็นทีมที่เฉพาะเจาะจงแทน บริษัท ที่เฉพาะเจาะจง
ไม่ด้วยเหตุผลทั้งหมดที่อธิบายไว้ข้างต้น แม้ว่าคุณคิดว่าจะทำเป็นทางการเพียงแค่การจัดรูปแบบโค้ด (สิ่งที่มีประโยชน์น้อยที่สุดที่คุณอาจต้องการทำเป็นทางการ) ฉันยังมีความทรงจำเกี่ยวกับสงครามที่ไม่มีวันสิ้นสุด (และไร้ประโยชน์) เกี่ยวกับการจัดรูปแบบ ฉันไม่ต้องการที่จะมีชีวิตอยู่อีกครั้งและอีกครั้งตั้งทุกครั้ง
อย่าจดลงไปหากคุณสามารถหลีกเลี่ยงได้ ค่อนข้างปล่อยให้รหัสเป็นวิธีที่มาตรฐานถูกจับ
ไม่ได้ด้วยเหตุผลทั้งหมดที่อธิบายไว้ข้างต้น (แน่นอนเว้นแต่คุณจะทำการปรับเปลี่ยนรหัสของคุณทั้งหมดในครั้งเดียวเมื่อมีการเปลี่ยนแปลงแนวทาง) คุณต้องการที่จะปล่อยให้รหัสของคุณตามที่เป็นอยู่? คุณตรวจสอบ codebase อย่างไรเพื่อทำความเข้าใจแนวทางปัจจุบัน ค้นหาตามอายุไฟล์และปรับเปลี่ยนรูปแบบการเข้ารหัสของคุณเป็นอายุไฟล์ต้นฉบับหรือไม่
อย่าออกกฎหมายการออกแบบที่ดี (เช่นอย่าบอกให้คนอื่นไม่ใช้ goto)
จริงแนวทางต้องสั้นหรือไม่มีใครอ่านได้ อย่าทำซ้ำอย่างชัดเจน
ตรวจสอบให้แน่ใจว่าทุกคนรู้ว่ามาตรฐานนั้นเกี่ยวกับการสื่อสาร
ไม่เพียง แต่มาตรฐานที่ดีจะเกี่ยวกับคุณภาพเว้นแต่คุณต้องการมีรายละเอียดเพียงเล็กน้อยเท่านั้น
หลังจากการทำซ้ำสองสามครั้งแรกให้ทีมร่วมกันตัดสินใจ
เห็นจุดแรกและอย่าลืมว่ามาตรฐานการเข้ารหัสมักจะเป็นกระบวนการที่ใช้เวลาหลายปีกว่าจะได้รับการพัฒนาและปรับปรุง: มีการทำซ้ำเพียงไม่กี่ครั้ง จริงๆ? คุณต้องการที่จะพึ่งพาหน่วยความจำอาวุโสของสมาชิกคนหนึ่ง (ถ้ามี) หรือไม่?
สามบันทึก:
- ในความเห็นของฉันข้อเสียมีความสำคัญกับบางภาษามากกว่าภาษาอื่นตัวอย่างเช่นใน C ++ มาตรฐานระดับ บริษัท เป็นสิ่งจำเป็นมากกว่าใน Java
- เหตุผลนี้อาจใช้ไม่ได้ทั้งหมด (และเหตุผลของลุงบ็อบอาจรุนแรงน้อยกว่า) หากคุณทำงานใน บริษัท เล็ก ๆ ที่คุณมีทีมเล็ก ๆ เพียงทีมเดียว
- คุณได้รับการว่าจ้าง (เป็นทีม) และคุณจะทำงานคนเดียวกับโครงการใหม่หนึ่งโครงการจากนั้นคุณจะลืมมันและไปต่อ ในกรณีนี้คุณอาจไม่สนใจ (แต่นายจ้างของคุณควร ... )