ทำงานกับรหัสของคนอื่น [ปิด]

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

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

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

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

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

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

ในความคิดของวิธีที่เร็วที่สุดที่จะเรียนรู้คนรหัส else's (โดยเฉพาะอย่างยิ่งเมื่อมีการเปลี่ยนแปลงก่อให้เกิดพฤติกรรมที่ไม่คาดคิดในขณะที่คุณอธิบาย) คือการก้าวผ่านรหัสโดยใช้โปรแกรมดีบัก

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

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

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

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

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

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

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

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

อย่าเร็วเกินไปที่จะถือว่ารหัสของคนอื่นค้างอยู่

แต่มักจะสงสัย

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

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

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

อย่างไรก็ตามสิ่งแรกที่คุณจะได้เรียนรู้คือเราไม่ได้อยู่ในโลกในอุดมคติ!

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

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

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

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

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

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

โปรดทราบว่าความสามารถในการอ่านโค้ดที่คุณยังไม่ได้เขียนนั้นเป็นทักษะที่มีค่ามากซึ่งอาจมีค่ามากกว่าการเขียนโค้ด น่าเสียดายที่โรงเรียนนี้มีการเรียนการสอนอย่างกว้างขวางและไม่ได้รับการสอน

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

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

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

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

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

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

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

ขั้นตอนพื้นฐานที่ฉันอยากจะแนะนำ:

• ครอบคลุมรหัสด้วยการทดสอบที่ครอบคลุมการใช้งานปัจจุบัน
• Refactor จนกว่าจะเข้าใจได้
• เขียนทดสอบสำหรับฟังก์ชั่นใหม่หรือปรับเปลี่ยน
• ใช้งานฟังก์ชั่นใหม่
• Refactor จนพอใจ

ฉันตั้งใจออกจากการระบุรสชาติของการทดสอบ (หน่วย, การรวม, ... ) - เพียงแค่ได้รับความคุ้มครองการทดสอบอัตโนมัติบางอย่าง

(และใช่ทำตามรูปแบบการเข้ารหัสในแง่ของรูปแบบและการตั้งชื่อ)

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

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

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

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

• งานจะใช้เวลานานและเจ้านายของคุณจะไม่เข้าใจ
• รหัสที่คุณเปลี่ยนต้องได้รับการทดสอบและมีค่าใช้จ่าย โซลูชันปัจจุบันได้รับการทดสอบและรับรองแล้ว
• มันจะยากที่จะเห็นการเปลี่ยนแปลงที่แก้ไขงานปัจจุบันและการแก้ไข 'เพียง'

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

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

คิดว่ามันเหมือนการดำเนินการกับบุคคล

คุณมองเข้าไปข้างในปัญหาที่คุณต้องแก้ไขและสังเกตว่าหลอดเลือดแดงส่วนใหญ่ ฯลฯ ไม่ได้ตั้งค่าวิธีที่คุณจะทำ - ดังนั้นคุณจึงตัดและสับมันจนกว่ามันจะเหมาะสมกับคุณแล้วแก้ไขปัญหา

น่าประหลาดใจที่ผู้ป่วยของคุณเสียชีวิตเกือบจะในทันที

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

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

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

สิ่งหนึ่งที่ฉันไม่ได้สัมผัสมาก่อนเลย - ไม่ทำงานบนเกาะ

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

ถามคำถาม. จำนวนมาก

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

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

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

และเมื่อห้าปีที่แล้วให้กำลังใจคนใหม่คนต่อไปที่จะใช้คุณเป็นที่ปรึกษา

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

• ฉันไม่ฉลาดพอที่จะเข้าใจว่ารหัสนี้ทำงานอย่างไร

• คนที่เขียนรหัสนี้ไม่รู้ว่าเขากำลังทำอะไรอยู่

• เวทมนตร์มีส่วนเกี่ยวข้อง: เวทมนต์ดำมาก

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

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

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

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

หากคุณสามารถลบองค์ประกอบของรหัสลงในห้องสมุดฉันจะทำมันเว้นแต่ว่าคุณกำลังทำงานในห้องสมุด

เมื่อเวลาผ่านไปเมื่อคุณเข้าใจตรรกะคุณสามารถเขียนและทดสอบได้อีกครั้ง

คำแนะนำนี้แบ่งตามภาษาที่คุณใช้ความสามารถในการรับการทดสอบและข้อ จำกัด อื่น ๆ ที่คุณมี

ลองใช้เครื่องมือวิเคราะห์รหัสเพื่อค้นหารหัสที่ไม่ได้ใช้ซึ่งสามารถลบได้ดังนั้นอย่างน้อยคุณก็ไม่ต้องกังวลกับรหัสนี้

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

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

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

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

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

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

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

แหล่งข้อมูลที่ดีในรูปแบบการออกแบบคือ

http://sourcemaking.com/design_patterns

http://www.oodesign.com/

และแน่นอนหนังสือ

http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

การติดตามการไหลของการควบคุมระหว่างวิธีการมีความสำคัญมากในการพัฒนาแผนที่ทางจิตของตรรกะทางธุรกิจ

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

การสร้างโมเดลข้อมูลเวิร์กโฟลว์เป็นวิธีที่ดีที่สุดในการวิเคราะห์พา ธ โค้ดทั้งหมด:

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

และการมองเห็นเวิร์กโฟลว์นั้นเหมาะอย่างยิ่ง:

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

อ้างอิง

• ทำความเข้าใจกระบวนการทำงานดั้งเดิมด้วยการวิเคราะห์รันไทม์ (pdf)
• การทดสอบลอจิกแบบอิงระบบเชิงวัตถุ (pdf)
• console.trace () - Web APIs | MDN
• วิธีการติดตามการโทรผ่านพร็อกซี
• วิธีสอดแนมวิธีทับทิมของคุณ
• การติดตามการเรียกฟังก์ชันที่ซ้อนง่าย ๆ ใน Python - เว็บไซต์ของ Eli Bendersky
• การบันทึกการเข้า / ออกวิธี - Mebyon Kernow
• ติดตาม: การใช้เครื่องมือเพื่อแสดงการเรียกใช้ฟังก์ชัน
• -Xtrace -
• GitHub - johnno1962 / SwiftTrace: การติดตามเมธอด Swift และ Objective-C
• Debug :: Trace - Perl extension เพื่อติดตามการเรียกรูทีนย่อย - metacpan.org

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