Refactor หรือ Concentrate สำหรับการทำแอพให้สมบูรณ์

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

แอปที่สมบูรณ์แล้วจะทำให้คุณได้รับแอปที่ยากต่อการบำรุงรักษาในภายหลังหรือไม่

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

ทำให้มันใช้งานได้ จากนั้นทำให้เร็ว ในที่สุดทำให้มันสวยงาม

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

หากคุณมีปัญหาในการปรับโครงสร้างซ้ำอีกครั้งนั่นอาจเป็นโค้ดกลิ่น - ฉันขอแนะนำให้คุณดูSolid Principles

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

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

ฉันมักจะปรับโครงสร้างเมื่อฉันไปโดยเฉพาะอย่างยิ่งการใช้ TDD

1. เขียนแบบทดสอบ

2. ทำการทดสอบผ่าน

3. refactor

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

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

การปรับโครงสร้างใหม่นั้นเหมือนกับการยกขึ้นห้องของคุณ

หากคุณรักษาสิ่งต่าง ๆ ให้เป็นระเบียบคุณจะมีค่าใช้จ่ายเชิงเส้นตรงตามสัดส่วนของปริมาณงานที่คุณผลิตในโค้ด O (n) ในแง่อัลกอริธึม สมมติว่าคุณใช้เวลา 10% ในการปรับโครงสร้างเวลา (หรือทำให้ห้องของคุณเรียบร้อย) จะได้รับ 10% และจะคงที่ตลอดเวลา

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

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

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

และแน่นอนถ้าคุณก้าวเข้าสู่โครงการที่ยุ่งเหยิงทวีคูณมหาศาลคุณมีทางเลือก จำกัด

TL; DR: หากมีข้อสงสัย refactor คุณควรมีหลักฐานที่ดีจริง ๆ ก่อนตัดสินใจไม่ทำ

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

ขึ้นอยู่กับว่าคุณอยู่ที่ไหน!

สิ่งอื่น ๆ ที่คิดเกี่ยวกับ:

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

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

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

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

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

การปรับโครงสร้างจะมีความสำคัญมากในขณะที่คุณดำเนินการเกี่ยวกับการกรอกใบสมัครให้สมบูรณ์

+ VES

1. Clear Flow: การปรับโครงสร้างซ้ำจะให้ความชัดเจนของรหัสเพราะบางครั้งหากโค้ดไม่มีโครงสร้างเล็กน้อยให้เข้าใจการไหลของรหัสหลังจากระยะเวลาหนึ่งจะกลายเป็นเรื่องยากและรหัส refactoring อาจกลายเป็นงานที่ขึ้นเนิน

2. ปรับปรุงประสิทธิภาพ: การปรับโครงสร้างแอปพลิเคชันใหม่อย่างเหมาะสมจะช่วยปรับปรุงประสิทธิภาพแอปพลิเคชั่นได้อย่างแน่นอน

3. การบำรุงรักษา:สุดท้าย แต่ไม่ใช่อย่างน้อยมันจะง่ายกว่าที่จะรักษาในระยะยาว

-ve

1. การใช้เวลา:มันจะเสียเวลามากขึ้นในทุกขั้นตอนของความก้าวหน้าของคุณ ดังนั้นอาจมีความล่าช้าในการเสร็จสิ้น

บรรทัดล่าง

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

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

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