SOLID vs. การหลีกเลี่ยงสิ่งที่เป็นนามธรรมก่อนวัยอันควร

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

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

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

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

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

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

• หลักการความรับผิดชอบเดี่ยว: Sin SOLID คุณสามารถมีวัตถุที่มีขนาดใหญ่มากในแง่ของจำนวนวิธีการหรือปริมาณข้อมูลและยังคงสนับสนุนหลักการนี้ ใช้เวลาเช่นวัตถุทับทิมสตริง วัตถุนี้มีวิธีการมากกว่าที่คุณสามารถสั่นคลอนได้ แต่ก็ยังมีความรับผิดชอบเพียงอย่างเดียว: ถือสตริงข้อความสำหรับแอปพลิเคชัน ทันทีที่วัตถุของคุณเริ่มรับผิดชอบใหม่ให้เริ่มคิดอย่างหนัก ปัญหาการบำรุงรักษาถามตัวเองว่า "ฉันคาดหวังว่าจะพบรหัสนี้ที่ไหนถ้าฉันมีปัญหากับมันในภายหลัง"
• นับความเรียบง่าย: Albert Einstein กล่าวว่า "ทำให้ทุกอย่างง่ายที่สุดเท่าที่จะทำได้ แต่ไม่ง่ายกว่านี้" คุณต้องการวิธีการใหม่จริงหรือไม่? คุณสามารถทำสิ่งที่คุณต้องการด้วยฟังก์ชันที่มีอยู่ได้หรือไม่ หากคุณคิดว่าจำเป็นต้องมีวิธีการใหม่คุณสามารถเปลี่ยนวิธีการที่มีอยู่เพื่อตอบสนองทุกสิ่งที่คุณต้องการได้หรือไม่? ในสาระสำคัญ refactor ในขณะที่คุณสร้างสิ่งใหม่

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

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

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

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

I want to avoid premature abstraction.In my experience drawing abstraction lines without concrete use cases... 

นี่คือบางส่วนถูกและผิดบางส่วน

ไม่ถูกต้อง
นี่ไม่ใช่เหตุผลที่จะป้องกันไม่ให้ใช้หลักการ OO / โซลิด มันป้องกันไม่ให้ใช้งานเร็วเกินไป

ซึ่งเป็น...

ขวา
อย่า refactor รหัสจนกว่าจะ refactorable; เมื่อเป็นความต้องการที่สมบูรณ์ หรือเมื่อ "กรณีการใช้งาน" มีทั้งหมดตามที่คุณพูด

I find simple, tightly coupled procedural or God object code is sometimes easier to understand than very well-factored...

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

Code is fresh in your head
Code is familiar
Code is easy to mentally compartmentalize
You wrote it

3/4 ของสิ่งที่ดีเหล่านี้จะตายอย่างรวดเร็วในเวลาอันสั้น

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

นอกเหนือจากนั้นคุณควรคำนึงถึง SOLID แต่เป็นแนวทางมากกว่ากฎ

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

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

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

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

นี่หมายถึงอะไรคือระดับของต้นแบบการทดลองและการย้อนรอยในโค้ด

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

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

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

การวาดเส้นนามธรรมที่เหมาะสมเป็นสิ่งที่เราดึงมาจากประสบการณ์ คุณจะทำผิดพลาดในการทำเช่นนั้นจะปฏิเสธไม่ได้

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

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

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

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

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