โค้ดของโปรแกรมเมอร์ที่ดีมีลักษณะอย่างไร? [ปิด]

ฉันเป็นโปรแกรมเมอร์งานอดิเรก (เริ่มต้นด้วย VBA เพื่อให้เก่งเร็วขึ้น) และทำงานกับ VB.NET / C # .NET และกำลังพยายามเรียนรู้ ADO.NET

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

• พวกเขามีความเข้าใจที่ดีขึ้นเกี่ยวกับวัตถุ / คลาส / วิธีการทั้งหมดในภาษาที่กำหนด?
• โปรแกรมของพวกเขามีประสิทธิภาพมากขึ้น?
• การออกแบบโปรแกรมของพวกเขาดีกว่ามากในแง่ของเอกสารที่ดีกว่าการเลือกชื่อฟังก์ชั่นที่ดี ฯลฯ ?

พูดอีกอย่างคือถ้าฉันดูรหัสของโปรแกรมเมอร์มืออาชีพสิ่งแรกที่ฉันจะสังเกตเห็นเกี่ยวกับรหัสของพวกเขาเมื่อเทียบกับของฉันคืออะไร? ตัวอย่างเช่นฉันอ่านหนังสือเช่น 'Professional ASP.NET' โดย Wrox press ตัวอย่างโค้ดในหนังสือ 'ระดับโลก' หรือไม่? นั่นคือจุดสุดยอด? โปรแกรมเมอร์มือฉมังคนใดจะมองรหัสนั้นและคิดว่ามันเป็นรหัสที่ดี?

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

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

• ความคิดเห็นเกี่ยวกับรหัสที่ดีอธิบายว่าเหตุใดสิ่งที่ทำไม่ใช่สิ่งที่ทำ โค้ดอธิบายถึงสิ่งที่ทำ ความต้องการความคิดเห็นควรมีน้อย

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

• รหัสที่ดีได้รับการทดสอบอย่างดี การทดสอบทำหน้าที่เป็นข้อกำหนดที่สามารถเรียกใช้งานได้ของโค้ดและตัวอย่างการใช้งาน

• รหัสที่ดีไม่ใช่ "ฉลาด" มันทำสิ่งต่างๆอย่างตรงไปตรงมาและชัดเจน

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

ฉันยังไม่ได้อ่าน แต่หนังสือที่ฉันวางแผนจะอ่านในหัวข้อนี้คือClean Codeโดย Robert C. Martin

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

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

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

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

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

อ้างถึง Fowler สรุปความสามารถในการอ่าน:

คนโง่ทุกคนสามารถเขียนโค้ดที่คอมพิวเตอร์เข้าใจได้
โปรแกรมเมอร์ที่ดีเขียนโค้ดที่มนุษย์เข้าใจได้

กล่าวว่า

ส่วนตัวฉันจะต้องพูดถึง"The Zen of Python"โดย Tim Peters มันบอกโปรแกรมเมอร์ Python ว่าโค้ดของพวกเขาควรมีลักษณะอย่างไร แต่ฉันพบว่ามันใช้ได้กับโค้ดทั้งหมดโดยทั่วไป

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

รหัสคือบทกวี

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

ปฏิบัติตามข้อพิสูจน์:

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

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

ข้อพิสูจน์ที่สอง:

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

ข้อพิสูจน์ที่สาม:

เป็นที่ทราบกันดีว่า Corollary two ทำซ้ำตัวเองหลายครั้งในวงจรอุบาทว์ของโค้ดที่มีเอกสารไม่ดีตามด้วยการบังคับเขียนซ้ำ

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

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

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

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

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

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1229267173&sr=8-1

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

โปรแกรมเมอร์ทุกคนในระดับที่มีความสามารถ:

• แสดงความคิดเห็นอย่างถูกต้อง
• โครงสร้างอย่างมีประสิทธิภาพ
• เอกสารสะอาด

ครั้งหนึ่งฉันเคยได้ยินเพื่อนร่วมงานคนหนึ่งพูดว่า " ฉันเป็นคนมีเหตุผลและมีเหตุผลมาตลอดฉันคิดว่านั่นเป็นเหตุผลที่ฉันสนุกกับการพัฒนา "

ในความคิดของฉันเป็นความคิดของโปรแกรมเมอร์โดยเฉลี่ย ผู้ที่มองโลกในแง่ของกฎเกณฑ์และตรรกะและในที่สุดก็ปฏิบัติตามกฎเหล่านั้นเมื่อออกแบบและเขียนโปรแกรม

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

ใส่อย่างชัดเจน อย่างชัดเจนรหัสของโปรแกรมเมอร์ที่ดีสามารถอ่านและเข้าใจได้

ในความคิดของฉันรหัสโปรแกรมเมอร์ที่ดีคือภาษาที่เข้าใจได้ง่าย ; โค้ดที่เขียนอย่างดีสามารถอ่านและทำความเข้าใจได้ในเวลาอันสั้นโดยใช้ความคิดเพียงเล็กน้อยโดยไม่คำนึงถึงภาษาโปรแกรมที่ใช้ ไม่ว่าโค้ดจะอยู่ใน Java, Python, C ++ หรือ Haskell ผู้ที่ไม่ได้เขียนโปรแกรมในภาษานั้น ๆ ก็เข้าใจได้

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

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

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

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

• อ่านง่าย
• เขียนง่าย
• ดูแลรักษาง่าย

ทุกสิ่งทุกอย่างเป็นลวดลายเป็นเส้น

รหัสที่ดีควรเข้าใจได้ง่าย
ก็ควรจะแสดงความคิดเห็นได้ดี
ส่วนที่ยากควรจะแสดงความคิดเห็นได้ดียิ่งขึ้น

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

แทนที่จะพูดคำแนะนำที่ดีของคนอื่นซ้ำฉันจะแนะนำให้คุณอ่านหนังสือแทน Code Completeโดย Steve McConnell

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

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

(อย่างที่กล่าวไปก่อนหน้านี้คำตอบที่เป็นส่วนตัวมากขออภัยสำหรับภาษาอังกฤษของฉัน)

ฉันขอแนะนำ "Clean Code" ของ Bob Martin เป็นอันดับสอง

"รหัสสวย" ได้รับความนิยมอย่างมากเมื่อสองสามปีก่อน

หนังสือของ McConnell ควรค่าแก่การอ่าน

บางที "The Pragmatic Programmer" ก็น่าจะเป็นประโยชน์เช่นกัน

%

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

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

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

โค้ดที่ดีเขียนขึ้นโดยคำนึงถึงอนาคตทั้งจากมุมมองของโปรแกรมเมอร์และมุมมองของผู้ใช้

นี่เป็นคำตอบที่ค่อนข้างดีในหนังสือของฟาวเลอร์เรื่อง "Refactoring" มันไม่มี "กลิ่น" ทั้งหมดที่เขาอธิบายตลอดทั้งเล่ม

ฉันไม่เคยเห็น 'Professional ASP.NET' แต่ฉันจะแปลกใจถ้ามันดีกว่าตกลง ดูคำถามนี้สำหรับหนังสือบางเล่มที่มีรหัสที่ดีจริงๆ (แน่นอนว่ามันแตกต่างกันไป แต่คำตอบที่ยอมรับนั้นยากที่จะเอาชนะได้)

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

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

1. ความถูกต้องและประสิทธิภาพด้วยอัลกอริทึมที่ได้รับการพิสูจน์แล้ว (แทนที่จะเป็นการแฮ็กแบบไร้เดียงสาและแบบ adhoc)
2. ความชัดเจน (แสดงความคิดเห็นสำหรับเจตนาโดยอ้างอิงถึงอัลกอริทึมที่ไม่สำคัญ)
3. ความครบถ้วนเพื่อให้ครอบคลุมพื้นฐาน (หลักการเข้ารหัสการกำหนดเวอร์ชันเอกสารประกอบการทดสอบหน่วย ฯลฯ )
4. ความชัดเจน (แห้ง)
5. ความทนทาน (ยืดหยุ่นต่อการป้อนข้อมูลโดยพลการและการหยุดชะงักของคำขอเปลี่ยนแปลง)

ฉันสองคำแนะนำสำหรับ "รหัสสะอาด" ของลุงบ๊อบ แต่คุณอาจต้องการดูที่http://www.amazon.com/Implementation-Patterns-Addison-Wesley-Signature-Kent/dp/0321413091เนื่องจากฉันคิดว่าข้อนี้เกี่ยวข้องกับคำถามเฉพาะของคุณดีกว่าเล็กน้อย โค้ดที่ดีควรกระโดดออกจากหน้าเว็บและบอกคุณว่ามันทำอะไร / ทำงานอย่างไร

Jeff Atwood เขียนบทความที่น่าสนใจเกี่ยวกับการอ้างอิงครั้งแรกของนักพิมพ์รหัส: http://www.codinghorror.com/blog/archives/001188.html

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

โครงสร้าง

ความคิดเห็น

ภูมิภาค

ฉันเป็นวิศวกรซอฟต์แวร์ซึ่งหมายความว่าในระหว่างการศึกษาของฉันฉันเจอภาษาต่างๆมากมาย แต่การเขียนโปรแกรมของฉันมักจะ "รู้สึก" เหมือนเดิมเหมือนกับที่ฉันเขียนใน fekberg.wordpress.com ฉันมีวิธี "พิเศษ" สำหรับการพิมพ์

ตอนนี้การเขียนโปรแกรมแอปพลิเคชันที่แตกต่างกันและในภาษาที่แตกต่างกันเช่น Java, C #, Assembler, C ++, C ฉันมาถึง "มาตรฐาน" ของการเขียนที่ฉันชอบ

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

นี่เป็นสิ่งที่สำคัญมากฉันมักจะเห็นโค้ดของฉันที่ฉันทำในฐานะ "เป็นส่วนหนึ่งของ API" เมื่อสร้างโครงสร้าง API และความสง่างามเป็นสิ่งสำคัญมาก

คิดเกี่ยวกับสิ่งนี้. อ่านบทความของฉันCommunication issues when adapting outsourcingที่อธิบายคร่าวๆว่าโค้ดที่ไม่ดีสามารถขัดแย้งกันอย่างไร Enterpret ตามที่คุณต้องการ: http://fekberg.wordpress.com/2008/12/14/communication-issues-when-adapting-outsourcing/

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

รหัสที่ดีสำหรับฉันคือสิ่งที่เข้าใจง่าย แต่มีความซับซ้อน สิ่งที่ทำให้คุณไป "ว้าวแน่นอนทำไมฉันไม่คิดแบบนั้น". รหัสที่ดีจริง ๆ นั้นไม่ยากที่จะเข้าใจเพียงแค่แก้ปัญหาด้วยวิธีตรงไปตรงมา (หรือวิธีเรียกซ้ำถ้าง่ายกว่านั้น)

รหัสที่ดีคือที่ที่คุณรู้ว่าเมธอดใช้ชื่ออะไร รหัสไม่ถูกต้องคือที่ที่คุณต้องคำนวณว่าโค้ดทำอะไรเพื่อให้เข้าใจถึงชื่อ

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

รหัสที่ดีมีการตั้งชื่อสิ่งต่างๆเพื่อให้ความคิดเห็นที่ไม่สำคัญโดยไม่จำเป็น

โค้ดที่ดีมักจะสั้น

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

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

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

เมื่อโปรแกรมเมอร์มีความคิดเช่นนั้นสิ่งอื่น ๆ ทั้งหมดจะเข้าที่อย่างสวยงาม

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

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

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

ด้วยเหตุนี้รหัสของเขาจึงต้อง:

1. ทำงาน (ไม่สำคัญว่ารหัสจะตอบผิดได้เร็วแค่ไหนในโลกแห่งความเป็นจริงไม่มีเครดิตบางส่วน)
2. อธิบายว่าเขารู้ได้อย่างไรว่ารหัสนี้ทำงาน นี่คือการรวมกันของเอกสาร (javadoc เป็นเครื่องมือที่ฉันเลือก) การจัดการข้อยกเว้นและรหัสทดสอบ ตามความเป็นจริงฉันเชื่อว่าโค้ดสำหรับบรรทัดโค้ดทดสอบมีค่ามากกว่าโค้ดที่ใช้งานได้หากไม่มีเหตุผลอื่นนอกจากอธิบายว่า "โค้ดนี้ใช้งานได้นี่คือวิธีที่ควรใช้และนี่คือเหตุผลที่ฉันควรได้รับ จ่ายแล้ว "
3. ได้รับการบำรุงรักษา รหัสตายคือฝันร้าย การบำรุงรักษารหัสเดิมเป็นงานที่น่าเบื่อ แต่ต้องทำ (และจำไว้ว่ามันเป็น "มรดก" ทันทีที่ออกจากโต๊ะทำงานของคุณ)

ในทางกลับกันฉันเชื่อว่าโปรแกรมเมอร์ที่ดีไม่ควรทำสิ่งเหล่านี้:

1. หมกมุ่นอยู่กับการจัดรูปแบบ มี IDE ตัวแก้ไขและเครื่องพิมพ์สวย ๆ มากมายที่สามารถจัดรูปแบบโค้ดให้ตรงตามมาตรฐานหรือความชอบส่วนบุคคลที่คุณคิดว่าเหมาะสม ฉันใช้ Netbeans ฉันตั้งค่าตัวเลือกรูปแบบหนึ่งครั้งและกด alt-shift-F เป็นระยะ ๆ ตัดสินใจว่าคุณต้องการให้โค้ดมีลักษณะอย่างไรตั้งค่าสภาพแวดล้อมของคุณและปล่อยให้เครื่องมือทำงานหนัก
2. หมกมุ่นอยู่กับรูปแบบการตั้งชื่อโดยใช้ค่าใช้จ่ายในการสื่อสารของมนุษย์ หากรูปแบบการตั้งชื่อนำคุณไปสู่เส้นทางการตั้งชื่อชั้นเรียนของคุณ "IElephantProviderSupportAbstractManagerSupport" แทนที่จะเป็น "Zookeeper" ให้เปลี่ยนมาตรฐานก่อนที่จะทำให้คนถัดไปยากขึ้น
3. ลืมไปว่าเขาทำงานเป็นทีมกับมนุษย์จริงๆ
4. ลืมไปว่าแหล่งที่มาหลักของข้อผิดพลาดในการเข้ารหัสอยู่ที่แป้นพิมพ์ของเขาในขณะนี้ หากมีข้อผิดพลาดหรือข้อผิดพลาดเขาควรพิจารณาตัวเองก่อน
5. ลืมไปว่าสิ่งที่เกิดขึ้นรอบตัว งานใด ๆ ที่เขาทำในตอนนี้เพื่อให้รหัสของเขาสามารถเข้าถึงได้มากขึ้นสำหรับผู้อ่านในอนาคตเกือบจะเป็นประโยชน์ต่อเขาโดยตรง (เพราะใครจะเป็นคนแรกที่ขอให้ดูรหัสของเขาเขาคือ)

1. มันได้ผล
2. มีการทดสอบหน่วยที่พิสูจน์ว่าใช้งานได้จริง

ที่เหลือเป็นไอซิ่ง ...

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

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

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

ฉันมีตัวอย่างที่ดี:

อ่าน GWT (google web tookit) ซอร์สโค้ดคุณจะเห็นว่าคนโง่ทุกคนเข้าใจมัน (หนังสือภาษาอังกฤษบางเล่มอ่านยากกว่ารหัสนี้)