วิธีการย้อนกลับและดูรหัสด้วยตาสด [ปิด]

ฉันใช้เวลาหนึ่งปีที่แล้วในฐานะทีมคนเดียวที่พัฒนาแอปพลิเคชันที่มีลูกเล่นมากมาย (35,000+ LoC สำหรับสิ่งที่คุ้มค่า) ปัจจุบันมีเสถียรภาพและในการผลิต อย่างไรก็ตามฉันรู้ว่าทักษะของฉันเริ่มขึ้นเมื่อเริ่มต้นโครงการดังนั้นไม่ต้องสงสัยเลยว่ามีปัญหาสำคัญในรหัส ณ จุดนี้ปัญหาส่วนใหญ่อยู่ในสถาปัตยกรรมโครงสร้างและการโต้ตอบ - ปัญหาง่าย ๆ แม้แต่ปัญหาด้านสถาปัตยกรรม / การออกแบบก็ถูกกำจัดออกไปแล้ว

โชคไม่ดีที่ฉันใช้เวลากับโครงการนี้มากจนฉันคิดว่ามันยาก - เข้าใกล้จากมุมมองใหม่เพื่อดูข้อบกพร่องที่ฝังลึกหรือมีอยู่ในการออกแบบ

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

วิธีในการเข้าถึงสิ่งนี้:

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

หากคุณมีตัวอย่างเฉพาะที่คุณต้องการแก้ไขอาจโพสต์ไว้ที่นี่

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

เรียนรู้และพัฒนาทักษะของคุณต่อไป มันยากที่จะรู้ว่าคุณไม่รู้อะไร แต่เมื่อคุณเห็นมันช่วงเวลา "aha" จะกระทบคุณ อาจมาจากการเรียนรู้ภาษาอื่นหรือรูปแบบการออกแบบ

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

ผู้ใช้จะเริ่มบ่น เมื่อคุณคิดว่าทุกอย่างยอดเยี่ยม ...

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

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

เมื่อคุณระบุพื้นที่ที่ต้องทำงานแล้วลองหาว่าปัญหาคืออะไร มีหนังสือที่ใช้วิธีการอย่างเป็นระบบเพื่อจัดหมวดหมู่ปัญหาการออกแบบ ดูRefactoringของ Martin Fowler มาตรฐานการเข้ารหัส C ++ของ Herb Sutter , Clean Codeของ Robert Martin และอื่น ๆ พวกเขามี "กฎ" มากมายที่ทำให้คุณดูรหัสของคุณได้อย่างเป็นกลาง

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

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

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

ฉันรู้ว่าสถานการณ์นี้ดีมาก เมื่อฉันติดอยู่ในแบบนั้นฉันก็ลองมองมุมมองต่าง ๆ ในโครงการ

1. ) มุมมองของผู้ใช้ / ลูกค้า - ใช้ความคิดเห็น

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

2. ) ทำการวิเคราะห์การทำงานของรหัสของคุณและมองเห็นมัน

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

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

3. ) ใช้วิธีการทั่วไปในการประกันคุณภาพ

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

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

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

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

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

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

อย่าเหงื่อสิ่งเล็ก ๆ น้อย ๆ

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

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

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

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

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

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

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

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

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

"นี่เป็นปัญหาที่เล็กกว่าที่ฉันคิดหรือเป็นปัญหาของคนอื่นด้วยเช่นกัน"

Sheesh พอแล้ว. หากรหัสในการผลิตปราศจากข้อผิดพลาดและทำในสิ่งที่ควรทำสถาปัตยกรรมไม่สำคัญ อย่างน้อยก็ตอนนี้.

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

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

นอกจากคำตอบอื่น ๆ ฉันขอแนะนำให้ไปที่การประชุมนักพัฒนาซอฟต์แวร์

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

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

อนึ่งสิ่งนี้ก็มีผลกับทีมของคนด้วยเช่นกันเนื่องจากความคิดแบบกลุ่มสามารถเกิดขึ้นได้ทุกที่

สุดท้ายถ้าคุณไม่ได้รับการอนุมัติให้พูดหนึ่งครั้งต่อปีเปลี่ยนงาน

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

• ติดตั้งโค้ดเพื่อให้ทุกอย่างที่แอพต้องการนั้นสามารถกำหนดค่าและบำรุงรักษาได้

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

ฉันเชื่อว่า 'การเตะไปรอบ ๆ ' ความกังวลกับคนฉลาดบางคนช่วย จำเป็นต้องมีข้อมูลเฉพาะ เป็นเว็บไซต์ 24x7x365 หรือไม่ แอป LoB มันทำงานหรือโฮสต์อยู่ที่ไหน

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