โปรแกรมเมอร์ที่รวดเร็วและสกปรกรู้ได้อย่างไรว่าพวกมันถูกต้อง?

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

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

รหัสอาจไม่ถูกต้อง

อย่างไรก็ตามมันอาจไม่สำคัญ

รวดเร็วและสกปรกอาจเป็นวิธีที่เหมาะสมในสถานการณ์ที่:

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

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

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

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

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

โอเคที่มีความเสี่ยงต่อการเป็นเหยื่อการลงคะแนนเสียงที่สมบูรณ์ฉันจะ "สนับสนุนปีศาจ" มุมมองของฝ่ายตรงข้าม

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

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

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

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

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

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

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

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

การทดสอบหน่วย มันเป็นวิธีเดียวที่จะมีความมั่นใจในรหัสใด ๆ (สกปรกหรือไม่)

ในหมายเหตุด้าน;

ทางลัดสำหรับการหน่วงเวลานาน (Pippin)

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

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

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

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

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

นี่คือเรื่องราวเกี่ยวกับโปรแกรมเมอร์ที่รวดเร็วและสกปรกที่ฉันรู้จัก

ฉันรู้จักบุคคลที่นับถือหน่วยทดสอบเสียเวลา หลังจากทะเลาะกันมากในที่สุดเขาก็เขียนหนึ่ง มันประกอบไปด้วยวิธีการหนึ่งที่ยาวด้วยโรยด้วย && และ || และส่งคืนบูลีนเพื่อ assertTrue คำสั่งครอบคลุม 20 บรรทัด จากนั้นอีกครั้งเขาเขียนคลาสที่ทุกวิธีมีหนึ่งบรรทัดและอีกหนึ่งคลาสหลักมีมากกว่า 1,000 บรรทัดโดยไม่มีช่องว่าง มันเป็นกำแพงข้อความ เมื่อฉันตรวจสอบรหัสของเขาและแทรกบรรทัดใหม่เขาถาม 'ทำไม' ฉันพูดว่า 'เพราะการอ่านได้' เขาถอนหายใจและลบทิ้ง เขาใส่ความเห็นไว้ด้านบน "อย่าแตะเลยใช้งานได้!"

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

นอกจากนี้เขาคิดว่าการอ่านหนังสือและบล็อกการเขียนโปรแกรมไม่มีประโยชน์ เขาบอกว่า 'เพิ่งเริ่มเขียนโปรแกรม' เขาทำอย่างนั้นมา 12 ปีแล้วและเขาคิดว่าเขาเป็นโปรแกรมเมอร์ที่ยอดเยี่ยม / facepalm

นี่คือบางส่วนเพิ่มเติม

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

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

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

ผู้พัฒนารายหนึ่งตอบกลับบอกเมื่อฉันขอให้เขาใช้รหัสห้องสมุด: "นั่นไม่ใช่การโกงใช่ไหมฉันต้องเขียนรหัสของตัวเองทั้งหมดที่โรงเรียน"

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

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

จัดส่งสินค้า

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

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

ฉันไม่คิดว่าพวกเขาสามารถพูดได้อย่างตรงไปตรงมาว่าพวกเขาเข้าใจถูกต้องหากไม่สามารถบำรุงรักษาได้ง่าย หากพวกเขายอมรับว่าพวกเขาต้อง "ทำความสะอาดในภายหลัง" อาจมีบางสิ่งที่พวกเขาไม่ได้คิดมากพอ การทดสอบอย่างละเอียดจะเปิดเผยปัญหาใด ๆ กับรหัสสกปรกอย่างแท้จริง

โดยส่วนตัวฉันจะไม่ตั้งเป้าหมายที่จะพัฒนาทักษะของ "การเขียนโค้ดสกปรก" และมั่นใจในความถูกต้องของมัน ฉันอยากเขียนรหัสที่เหมาะสมในครั้งแรก

พวกเขารู้ได้อย่างไรว่าพวกเขาทำให้ถูกต้อง การทดสอบคือคำตอบที่ง่าย

หากรหัสของพวกเขาได้รับการทดสอบอย่างละเอียดโดยทีมงาน QA ที่ดีและผ่านไปแล้วฉันจะบอกว่าพวกเขาเข้าใจถูกต้อง

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

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

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

แน่นอนว่าภาพนี้แสดงให้เห็นว่าไม่มีใครควรประมาทอันตรายของรหัสที่รวดเร็วและสกปรก!

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

ในความคิดของฉันการเรียนรู้ที่จะตัดสินรหัส Q & D สำหรับความถูกต้องไม่ใช่ทักษะที่ควรค่าแก่การพัฒนาเพราะเป็นเพียงการปฏิบัติที่ไม่ดี นี่คือเหตุผล:

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

การดูรายงาน CHAOSดั้งเดิมทำให้ค่อนข้างชัดเจนว่า Q&D ไม่ใช่ความคิดที่ดีและจะฆ่างบประมาณในภายหลัง (ไม่ว่าจะเป็นการบำรุงรักษาหรือในระหว่างการขยาย) เรียนรู้วิธีการตัดสินว่ารหัส Q & D เหมาะสมถูกต้องหรือเปล่า ดังที่ Peter Drucker กล่าวว่า "ไม่มีอะไรที่ไร้ประโยชน์เลยหากทำอย่างมีประสิทธิภาพซึ่งไม่ควรทำเลย"

ฉันไม่สามารถบอกได้ว่ารหัสใหม่ของฉันถูกต้องถ้ามันสกปรกเกินไป

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

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

ด้วยความเสี่ยงที่จะเกิดความขัดแย้งเล็กน้อยฉันขอยืนยันว่าไม่มีใครรู้จริง ๆว่ารหัสของพวกเขานั้นถูกต้อง 100% และ 100% โดยไม่มีข้อผิดพลาด แม้ว่าคุณจะมีการครอบคลุมการทดสอบที่ดีมากและคุณใช้การฝึก BDD / TDD อย่างจริงจังคุณก็ยังสามารถพัฒนาโค้ดที่มีข้อผิดพลาดได้และใช่ว่าจะมีผลข้างเคียงด้วย!

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

จุดสำคัญคือรหัสที่ได้รับการทดสอบและผ่านการทดสอบเป็นอย่างดีจะช่วยให้OTHERSมีความมั่นใจในรหัสของคุณซึ่งโดยส่วนใหญ่แล้วสำคัญกว่าความมั่นใจของคุณเอง

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

โปรแกรมเมอร์ที่ดี (Quick & Dirty และอื่น ๆ ) ไม่มีความโอหังที่จะถือว่าพวกเขาเข้าใจถูกต้อง พวกเขาคิดว่าระบบขนาดใหญ่ทั้งหมดมีข้อบกพร่องและข้อบกพร่อง แต่ในบางจุดอาจทดสอบและตรวจสอบได้ดีพอที่จะมีความเสี่ยงต่ำพอสมควรหรือมีความล้มเหลวต่ำพอที่รหัสสามารถส่งได้

เหตุใดจึงต้องเรียกสิ่งเหล่านี้ว่า Quick & Dirty โปรแกรมเมอร์ สมมติฐานของฉันคือการคัดเลือกของดาร์วิน โปรแกรมเมอร์ที่จัดส่งรหัสที่สามารถทำงานได้อย่างรวดเร็วบางครั้งจัดส่งก่อนการแข่งขันเรือหรืองบประมาณหมดหรือ บริษัท ล้มละลาย ดังนั้น บริษัท ของพวกเขายังอยู่ในธุรกิจที่จ้างโปรแกรมเมอร์ใหม่เพื่อบ่นเกี่ยวกับระเบียบที่ต้องทำความสะอาด ดังนั้นจึงเรียกว่า clean code จัดส่งเช่นกัน แต่ก็ไม่แตกต่างกันพอที่จะทำให้ coders ของ Quick & Dirty สูญพันธุ์

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

1-) โครงการมีขนาดใหญ่ขึ้นและแรงจูงใจของทีมลดลงโดยใช้รหัสที่เต็มไปด้วย "การเย็บ" ในกรณีนี้โครงการจะเป็นไปได้อย่างรวดเร็วในการเข้าสู่ความสับสนวุ่นวาย

2-) โครงการกลายเป็นที่รู้จักกันว่าเป็นทางออกที่ไม่เหมาะสมและการใช้งานเริ่มที่จะหมดกำลังใจในความโปรดปรานของโซลูชั่นใหม่หรือ refactoring ที่มีราคาแพงเช่นเดียวกับโซลูชั่นใหม่

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

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

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

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