กระทบยอดคำแนะนำในการเขียนโปรแกรมที่ขัดแย้ง: ทำให้บางสิ่งบางอย่างทำงานและทำซ้ำเทียบกับจริงๆคิดก่อนผ่านการเข้ารหัส

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

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

คำแนะนำที่สองคือคิดโครงการก่อนที่จะเขียนโค้ดใด ๆ

ฉันประสบความสำเร็จทั้งสองวิธีและฉันจะบอกว่าฉันเห็นด้วยกับแต่ละปรัชญา

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

ฉันจะไปเกี่ยวกับโครงการเหล่านี้ได้อย่างไร

ฉันเพิ่งเริ่มเขียนโค้ด SOMETHING และเรียนรู้ (แพลตฟอร์ม / วิธี / ภาษา / สถาปัตยกรรม) ตามที่ฉันไปหรือไม่หรือฉันจะหยุดการเข้ารหัสและทำการวิจัย / อ่านก่อนที่ฉันจะเปิด IDE หรือไม่

ฉันจะปรับคำแนะนำในการเขียนโปรแกรมเหล่านี้ได้อย่างไร

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

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

เป็นเพียงตัวอย่างเล็กน้อย วันก่อนฉันกำลังดิ้นรนกับการตัดสินใจออกแบบซอฟต์แวร์ ในตอนหลังมันค่อนข้างเล็กน้อย แต่ฉันมีสองทางเลือกและดูเหมือนว่าทั้งสองจะทำงานได้ ฉันวนเวียนกลับไปยังข้อดี / ข้อเสียของแต่ละคนจากนั้นวนกลับและพิจารณาการตัดสินใจของฉันอีกครั้ง มองย้อนกลับไปมันน่าอายนิดหน่อยว่าฉันใช้เวลาคิดนานแค่ไหน จากนั้นฉันก็พูดกับตัวเอง f # @ k มัน! และแทนที่จะใช้การออกแบบอย่างใดอย่างหนึ่งฉันเพิ่งไปข้างหน้าและแฮ็คโค้ดเข้าด้วยกันโดยไม่สนใจสิ่งดีทั้งหมดที่คุณเรียนรู้เกี่ยวกับการออกแบบที่ดี ฉันได้รับคุณลักษณะการทำงานในประมาณ 45 นาที จากนั้นฉันก็กลับไปดูที่รหัสของฉันและทำให้มันเป็นของแข็งและสิ่งที่ฉันจะไม่รู้สึกละอายใจกับการตรวจสอบการควบคุมแหล่งที่มา ส่วนที่ตลกคือหลังจากที่แฮ็คทำงานได้มาเพื่อ "

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

มีการตัดสินใจบางอย่างที่จำเป็นต้องทำล่วงหน้า

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

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

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

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

ฉันไม่ได้มองว่าทั้งสองเป็นเอกสิทธิ์เฉพาะบุคคล

เช่นเดียวกับการบริหารโครงการใด ๆ ที่คุณต้องการทั้งวิสัยทัศน์ระยะยาวและเป้าหมายระยะสั้น

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

คุณปล่อย / etc บ่อยครั้งเพียงใด ขึ้นอยู่กับวิธีการเฉพาะที่คุณใช้

สิ่งที่คุณต้องวิจัยขึ้นอยู่กับสิ่งที่คุณรู้เมื่อเทียบกับสิ่งที่คุณไม่พอใจ

"การย้ำ" และ "การคิดผ่าน" ไม่ได้ขัดแย้ง แต่เป็นการเสริม

แม้จะอยู่สุดขั้วพวกเขาก็สะท้อนสองเส้นทางเพื่อไปยังสถานที่เดียวกัน

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

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

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

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

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

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

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

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