คำถามติดแท็ก design

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันทำงานให้กับ บริษัท ขนาดกลางที่มีนักพัฒนาประมาณ 250 คน น่าเสียดายที่หลายคนติดอยู่ในกระบวนการคิดและบางทีมส่งมอบแอปพลิเคชันสคริปต์ธุรกรรมขนาดใหญ่อย่างต่อเนื่องซึ่งในความเป็นจริงแล้วแอปพลิเคชันมีตรรกะมากมาย พวกเขายังไม่สามารถจัดการการพึ่งพาการออกแบบและจบลงด้วยบริการที่ขึ้นอยู่กับบริการจำนวนมากอีกตัวอย่าง (ตัวอย่างที่ชัดเจนของBig Ball of Mud ) คำถามของฉันคือคุณสามารถแนะนำวิธีกระจายความรู้ประเภทนี้ได้อย่างไร ฉันรู้ว่าพื้นผิวของปัญหาคือแอปพลิเคชันเหล่านี้มีสถาปัตยกรรมและการออกแบบที่ไม่ดี อีกปัญหาคือมีนักพัฒนาบางคนที่ต่อต้านการเขียนการทดสอบใด ๆ บางสิ่งที่ฉันทำเพื่อเปลี่ยนแปลงสิ่งนี้ (แต่ฉันล้มเหลวหรือการเปลี่ยนแปลงเล็กเกินไป) ใช้งานนำเสนอเกี่ยวกับหลักการออกแบบ (SOLID, clean code, ฯลฯ ) การประชุมเชิงปฏิบัติการเกี่ยวกับ TDD และ BDD ทีมการฝึกสอน (ซึ่งรวมถึงการใช้โซนาร์, findbugs, jdepend และเครื่องมืออื่น ๆ ) การพูดถึง IDE & Refactoring …

14 design  learning  object-oriented  architecture 

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

14 c#  design-patterns  design  hierarchy 

ฉันมีชั้นเรียนขนาดใหญ่ที่มีโค้ดมากกว่า 2K บรรทัด (และเพิ่มขึ้นเรื่อย ๆ ) ที่ฉันอยากจะสร้างใหม่หากเป็นไปได้เพื่อให้มีการออกแบบที่เบาและสะอาดมากขึ้น เหตุผลที่มันใหญ่มากส่วนใหญ่เป็นเพราะคลาสเหล่านี้จัดการกับชุดของแผนที่ที่วิธีการส่วนใหญ่จำเป็นต้องเข้าถึงและวิธีการเชื่อมต่อกันมาก ฉันจะยกตัวอย่างชัดเจน: ฉันมีคลาสที่เรียกServerว่าจัดการข้อความขาเข้า มันมีวิธีการเช่นjoinChatroom, searchUsers, sendPrivateMessageและอื่น ๆ ทั้งหมดของวิธีการเหล่านี้จัดการแผนที่เช่นusers, chatrooms, servers... บางทีมันอาจจะดีถ้าฉันมีข้อความการจัดการเรียนที่เกี่ยวข้องกับห้องสนทนาการจัดการกับผู้ใช้อื่น ๆ แต่ปัญหาหลักที่นี่คือฉันต้องใช้แผนที่ทั้งหมดในวิธีการส่วนใหญ่ นั่นเป็นเหตุผลที่ตอนนี้พวกเขาทั้งหมดติดอยู่ในServerชั้นเรียนเพราะพวกเขาทั้งหมดพึ่งพาแผนที่ทั่วไปเหล่านี้และวิธีการเชื่อมต่อซึ่งกันและกัน ฉันจะต้องสร้างห้องเรียนแชท แต่มีการอ้างอิงถึงวัตถุอื่น ๆ ผู้ใช้คลาสอีกครั้งโดยอ้างอิงถึงวัตถุอื่นทั้งหมดเป็นต้น ฉันรู้สึกว่าฉันจะทำอะไรผิด

14 java  object-oriented  design-patterns  design 

สมมติว่าอินเตอร์เฟสมีวิธีการเหล่านี้: Car find(long id); List<Car> find(String model); จะเป็นการดีกว่าถ้าจะเปลี่ยนชื่อพวกเขาเช่นนี้? Car findById(long id); List findByModel(String model); อันที่จริงนักพัฒนาซอฟต์แวร์ใด ๆ ที่ใช้ API นี้ไม่จำเป็นต้องดูที่อินเทอร์เฟซเพื่อรับทราบข้อโต้แย้งที่เป็นไปได้ของfind()วิธีการเริ่มต้น ดังนั้นคำถามของฉันจึงเป็นเรื่องทั่วไปมากขึ้น: อะไรคือประโยชน์ของการใช้วิธีโอเวอร์โหลดในโค้ดเนื่องจากลดความสามารถในการอ่าน

14 design  naming  readability  method-overloading 

เมื่อออกแบบคลาสควรมีความสอดคล้องในพฤติกรรมได้รับการสนับสนุนมากกว่าการฝึกเขียนโปรแกรมทั่วไป? เพื่อให้ตัวอย่างที่เฉพาะเจาะจง: หลักการทั่วไปคือ: ถ้าคลาสเป็นเจ้าของวัตถุ (เช่นสร้างมัน) มันมีหน้าที่รับผิดชอบในการทำความสะอาดเมื่อทำเสร็จแล้ว ตัวอย่างที่เฉพาะเจาะจงจะอยู่ใน. NET ซึ่งหากคลาสของคุณเป็นเจ้าของIDisposableวัตถุก็ควรกำจัดทิ้งเมื่อสิ้นสุดอายุการใช้งาน และหากคุณไม่ได้เป็นเจ้าของมันก็อย่าแตะต้องมัน ตอนนี้ถ้าเราดูStreamWriterคลาสใน. NET จากนั้นเราสามารถค้นหาได้ในเอกสารที่มันปิดสตรีมพื้นฐานเมื่อมันถูกปิด / จำหน่าย นี่เป็นสิ่งจำเป็นในกรณีที่StreamWriterอินสแตนซ์ถูกสร้างขึ้นโดยส่งผ่านชื่อไฟล์ในฐานะผู้เขียนสร้างสตรีมไฟล์พื้นฐานและดังนั้นจึงจำเป็นต้องปิดมัน อย่างไรก็ตามสามารถส่งผ่านกระแสข้อมูลภายนอกที่ผู้เขียนปิดได้เช่นกัน สิ่งนี้ทำให้ฉันรำคาญหลายครั้ง (ใช่ฉันรู้ว่าคุณสามารถสร้างเสื้อคลุมที่ไม่ปิด แต่นั่นไม่ใช่ประเด็น) แต่เห็นได้ชัดว่า Microsoft ได้ตัดสินใจว่าจะสอดคล้องกันมากขึ้นเพื่อปิดสตรีมไม่ว่าจะมาจากที่ใด เมื่อฉันเข้ามาในรูปแบบดังกล่าวในหนึ่งในชั้นเรียนของฉันฉันมักจะสร้างownsFooBarธงที่ได้รับการตั้งค่าเป็นเท็จในกรณีที่FooBarมีการฉีดผ่านคอนสตรัคและเป็นจริงอย่างอื่น วิธีนี้ความรับผิดชอบในการทำความสะอาดมันจะถูกส่งไปยังผู้โทรเมื่อเขาผ่านอินสแตนซ์อย่างชัดเจน ตอนนี้ฉันสงสัยว่าบางทีความมั่นคงควรจะสนับสนุนการปฏิบัติที่ดีที่สุด (หรือการปฏิบัติที่ดีที่สุดของฉันอาจไม่ดี) มีข้อโต้แย้งใด ๆ สำหรับ / ต่อหรือไม่ แก้ไขเพื่อความกระจ่าง ด้วย "ความสอดคล้อง" ฉันหมายถึง: พฤติกรรมที่สอดคล้องกันของชั้นเรียนจะต้องเป็นเจ้าของ (และปิดสตรีม) เสมอกับ "แนวปฏิบัติที่ดีที่สุด" เพื่อให้ได้กรรมสิทธิ์ในวัตถุเท่านั้นหากคุณสร้างขึ้นหรือโอนความเป็นเจ้าของอย่างชัดเจน สำหรับตัวอย่างที่มันน่ารำคาญ: สมมติว่าคุณมีสองคลาสที่กำหนด (จากห้องสมุดบุคคลที่สาม) ซึ่งยอมรับสตรีมเพื่อทำบางสิ่งกับมันเช่นการสร้างและประมวลผลข้อมูลบางส่วน: public class DataProcessor { public …

14 design  .net 

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

14 design  methodology  flowchart 

บริษัท ของเราทำเว็บไซต์ เรายังออกแบบเว็บไซต์ แต่บางครั้งลูกค้าของเรานำการออกแบบของเขา / เธอ มักจะทำโดยนักออกแบบในบ้านหรือมันเป็นแบบเดียวกับที่พวกเขาใช้สำหรับอย่างอื่น อย่างไรก็ตามบางครั้งการออกแบบเหล่านี้ดูน่ากลัว และฉันกำลังพูดถึงมืออาชีพจริงๆไม่สมดุลไม่ได้พูดอะไรมาก แต่ลูกค้าต้องการการออกแบบนี้จริงๆ ฉันไม่ชอบทำงานกับการออกแบบที่แย่เหลือเกิน มันจะทำให้ความสุขในการเขียนโค้ดทั้งหมด คุณรหัส คุณตรวจสอบการสาธิต ใช้งานได้ดี ดูน่ากลัว มันไม่สนุกเลย และท้ายที่สุดลูกค้าอาจจะมีความสุข แต่ 1) ฉันไม่รู้สึกภูมิใจในผลิตภัณฑ์ขั้นสุดท้ายและ 2) ชุมชนเห็นว่าคุณพัฒนาเว็บไซต์ที่น่าเกลียดซึ่งเป็นสิ่งที่ไม่ดีต่อภาพลักษณ์ของคุณ มีใครประสบกับสิ่งนี้หรือไม่? คุณแนะนำเมนูใด? ฉันกำลังคิด: การปิดกั้นลูกค้าเหล่านี้ หากใครมีการออกแบบ 'ของตัวเองขอให้ดูมันก่อน จากนั้นก็ปฏิเสธอย่างสุภาพ ข้อเสียเปรียบ: คุณสูญเสียลูกค้า สร้างการออกแบบใหม่ ให้นักออกแบบของเราทำงานอย่างหนึ่งที่ยอดเยี่ยมจริงๆ ข้อเสีย: ลูกค้าจะต้องจ่ายสำหรับสิ่งนี้ (โดยไม่ต้องขอ) หรือจะถูกปฏิเสธและ บริษัท เสียเวลา = เงิน และอาจเป็นการดูถูกถ้าคุณเสนอการออกแบบใหม่จากสีน้ำเงิน นักออกแบบของพวกเขาจะไม่ชอบแน่นอน ใส่คำปฏิเสธที่ชัดเจนที่ด้านล่างของเว็บไซต์: ออกแบบเว็บไซต์โดย XXXXX, การพัฒนาเว็บไซต์โดย US ช่วยให้เกิดผลกระทบต่อชุมชน …

14 design 

ฉันเคยใช้ MVP และ MVC ในอดีตและฉันชอบ MVP มากกว่าเพราะมันควบคุมการไหลของการดำเนินการที่ดีขึ้นมากในความคิดของฉัน ฉันได้สร้างโครงสร้างพื้นฐานของฉัน (คลาสที่เก็บข้อมูล / พื้นที่เก็บข้อมูล) และใช้งานได้อย่างไม่มีปัญหาเมื่อทำการเข้ารหัสข้อมูลตัวอย่างอย่างหนักดังนั้นตอนนี้ฉันจึงย้ายไปยัง GUI และเตรียม MVP ของฉัน หมวดก ฉันได้เห็น MVP โดยใช้มุมมองเป็นจุดเริ่มต้นซึ่งอยู่ในวิธีการสร้างมุมมองที่สร้างพรีเซนเตอร์ซึ่งจะสร้างแบบจำลองเชื่อมโยงเหตุการณ์ตามความจำเป็น ฉันยังเห็นผู้นำเสนอเป็นจุดเริ่มต้นที่มุมมองโมเดลและผู้นำเสนอถูกสร้างขึ้นผู้นำเสนอนี้จะได้รับวัตถุมุมมองและแบบจำลองในตัวสร้างเพื่อโยงเหตุการณ์ เช่นเดียวกับใน 2 แต่รูปแบบไม่ผ่านไปยังผู้นำเสนอ แต่โมเดลเป็นคลาสสแตติกที่เรียกเมธอดและส่งคืนการตอบกลับโดยตรง มาตรา B ในแง่ของการรักษามุมมองและรูปแบบในการซิงค์ฉันได้เห็น เมื่อใดก็ตามที่ค่าในมุมมองเปลี่ยนไปเช่นTextChangedเหตุการณ์ใน. Net / C # นี่เป็นการยิงDataChangedEventที่ผ่านเข้าไปในแบบจำลองเพื่อให้ซิงค์อยู่ตลอดเวลา DataChangedEventและที่มีการเปลี่ยนแปลงรูปแบบคือเหตุการณ์พื้นหลังมันฟังแล้วมุมมองที่มีการปรับปรุงทางความคิดเดียวกันของการเพิ่ม เมื่อผู้ใช้ต้องการที่จะกระทำการเปลี่ยนแปลงSaveEventมันก็จะผ่านเข้าไปในแบบจำลองเพื่อทำการบันทึก ในกรณีนี้แบบจำลองเลียนแบบมุมมองข้อมูลและประมวลผลการกระทำ คล้ายกับ # b1 อย่างไรก็ตามมุมมองจะไม่ซิงค์กับโมเดลตลอดเวลา แต่เมื่อผู้ใช้ต้องการที่จะยอมรับการเปลี่ยนแปลงSaveEventถูกไล่ออกและผู้นำเสนอคว้ารายละเอียดล่าสุดและส่งพวกเขาไปยังรูปแบบ ในกรณีนี้โมเดลไม่ทราบเกี่ยวกับข้อมูลมุมมองจนกว่าจะต้องดำเนินการกับมันซึ่งในกรณีนี้โมเดลจะถูกส่งผ่านรายละเอียดที่จำเป็นทั้งหมด หมวด C การแสดงวัตถุธุรกิจในมุมมองเช่นวัตถุ (MyClass) ไม่ใช่ข้อมูลดั้งเดิม (int, double) …

14 c#  design  design-patterns  winforms 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ในฐานะวิศวกรเราทุกคน "ออกแบบ" สิ่งประดิษฐ์ (อาคารโปรแกรมวงจรโมเลกุล ... ) นั่นเป็นกิจกรรม (คำกริยาออกแบบ) ที่สร้างผลลัพธ์บางอย่าง (คำนามการออกแบบ) ฉันคิดว่าเราทุกคนเห็นพ้องต้องกันว่าการออกแบบคำนามเป็นสิ่งที่แตกต่างจากสิ่งประดิษฐ์เอง กิจกรรมหลักในธุรกิจซอฟต์แวร์ (แน่นอนในธุรกิจใด ๆ ที่จำเป็นต้องปรับปรุงสิ่งประดิษฐ์ที่เป็นผลลัพธ์) คือการเข้าใจ "การออกแบบ (คำนาม)" ถึงกระนั้นเราก็ดูเหมือนว่าเป็นชุมชนที่จะล้มเหลวอย่างสมบูรณ์ในการบันทึกเป็นหลักฐานตามจำนวนของความพยายามที่ผู้คนใส่ลงไปเพื่อค้นหาข้อเท็จจริงเกี่ยวกับฐานรหัสของพวกเขา ขอให้ใครสักคนแสดงการออกแบบของรหัสและดูว่าคุณได้รับอะไร ฉันคิดว่าการออกแบบซอฟต์แวร์มีดังนี้: ข้อกำหนดที่ชัดเจนสำหรับซอฟต์แวร์ที่ควรทำและใช้งานได้ดีเพียงใด รหัสรุ่นที่ชัดเจน (ส่วนนี้เป็นเรื่องง่ายใคร ๆ ก็มี) คำอธิบายสำหรับวิธีการที่แต่ละส่วนของรหัสทำหน้าที่เพื่อให้บรรลุข้อกำหนด (เช่นความสัมพันธ์ระหว่างชิ้นส่วน spec และชิ้นส่วนรหัส) เหตุผลว่าทำไมรหัสเป็นวิธีที่มันเป็น (เช่นทำไมเป็นทางเลือกหนึ่งมากกว่าอีก) สิ่งที่ไม่ใช่การออกแบบคือมุมมองเฉพาะของรหัส ตัวอย่างเช่น [ไม่ให้เลือกโดยเฉพาะ] แผนภาพ UML ไม่ได้ออกแบบ แต่เป็นคุณสมบัติที่คุณสามารถได้รับจากรหัสหรือคุณสมบัติที่คุณต้องการให้คุณได้มาจากรหัส แต่ตามกฎทั่วไปคุณไม่สามารถรับโค้ดจาก UML ได้ ทำไมหลังจากสร้างซอฟต์แวร์มานานกว่า …

14 design  philosophy 

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

14 design  team 

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

14 design  maintenance  refactoring 

ฉันกำลังมองหาคำแนะนำเกี่ยวกับ DRY กับการแต่งงานกันของ Code ฉันไม่ชอบที่จะทำซ้ำรหัสของฉันและฉันก็ไม่ชอบการเชื่อมต่อโค้ดระหว่างโมดูลที่ไม่เกี่ยวข้อง ดังนั้นฉันจึง refactor รหัสที่ซ้ำกันถ้าฉันพบรหัสที่ซ้ำกันเหมือนกันหนึ่งปีหลังจากที่มีการแนะนำการทำซ้ำ อย่างไรก็ตามฉันมีประสบการณ์ที่มากขึ้นซึ่งโลกแห่งความจริงนั้นไม่อาจคาดเดาได้มากขึ้นและหลังจากการปรับรหัสให้ใหม่แล้ว ตัวอย่างเช่นหากฉันมีรหัสเพื่อจัดการรถยนต์เบนซิน SUV เบนซินรถยนต์ไฟฟ้าและ SUV ไฟฟ้าสมมติว่าฉันได้รับรหัสซ้ำลงในลำดับชั้น "น้ำมัน" และลำดับชั้น "ไฟฟ้า" ทั้งคู่ลงมาจากลำดับ "ยานพาหนะ" จนถึงตอนนี้ดีมาก จากนั้น บริษัท ของฉันแนะนำรถยนต์ไฮบริดและไฮบริดกึ่งซึ่งจะต้องมีการเปลี่ยนแปลงหลักในลำดับชั้นดั้งเดิมของฉันเอง อาจจะต้องมี "องค์ประกอบ" ระหว่างน้ำมันเบนซินและลำดับชั้นไฟฟ้า เห็นได้ชัดว่าการทำสำเนารหัสไม่ดีเพราะเพิ่มเวลาในการดำเนินการเปลี่ยนแปลงร่วมกับผลิตภัณฑ์ทั้งหมดข้างต้น แต่การปรับเปลี่ยนรหัสทั่วไปทำให้ยากที่จะแนะนำรูปแบบเฉพาะของผลิตภัณฑ์และนำไปสู่ ​​"การกระโดดแบบคลาส" เป็นจำนวนมากเมื่อต้องค้นหาบรรทัดของรหัสเพื่อแก้ไขข้อบกพร่อง - การเปลี่ยนแปลงในระดับผู้ปกครองระดับสูงขึ้นสามารถทำได้ ทริกเกอร์การถดถอยข้อบกพร่องในหมู่ลูกหลานทั้งหมด หนึ่งจะสมดุลระหว่าง DRY และการมีเพศสัมพันธ์รหัสที่ไม่พึงประสงค์ได้อย่างไร

14 design  dry  coupling 

การออกแบบที่ดีสำหรับการอนุญาตให้ใช้งานร่วมกันได้ของชนิดไฟล์ระหว่างซอฟต์แวร์รุ่นต่าง ๆ คืออะไร ตัวอย่างเช่น Microsoft จะรับ Word 2007, 2010 และ 2013 และอื่น ๆ ... ไปยังไฟล์ docx ที่เปิดอยู่ทั้งหมดได้อย่างไร แต่รุ่นที่แตกต่างกันสามารถบันทึกข้อมูลได้มากขึ้นและน้อยลงและบันทึกข้อมูลในรูปแบบที่แตกต่างกันเล็กน้อย ไฟล์ที่บันทึกในรุ่นหนึ่งสามารถเปิดได้ในอีกรุ่นหนึ่ง แต่องค์ประกอบบางอย่างของไฟล์อาจไม่สามารถใช้งานได้ในเวอร์ชั่นที่เก่ากว่า ฉันหมายความว่าวิธีที่ชัดเจนจริงๆที่จะมีบางอย่าง private string openfile(string filename) { File.Open(filename) ... some logic that gets a header from the file that will never change switch (fileversion) case 2007: ..... case 2010 ..... case …

14 design  file-handling  backward-compatibility 

ฉันกำลังพัฒนา RESTful API และฉันคิดว่ามันสะดวกที่จะใช้ DAO สำหรับทรัพยากรของฉันเพราะแม้ว่าฉันจะใช้หน่วยความจำเพื่อเก็บไว้ แต่ฉันไม่ต้องการปิดประตูให้ใครก็ตามที่ใช้ห้องสมุดของฉันถ้าพวกเขาตัดสินใจที่จะใช้ การใช้ฐานข้อมูลสำหรับ DAO คำถามของฉันคือว่า DAO ควรเป็นซิงเกิลตันหรือไม่ หากไม่ใช่บริการจะมีตัวอย่างของ DAO และจะมีลักษณะเช่นนี้: @Path("eventscheduler") public class EventSchedulerService { private IEventSchedulerDao dao = new EventSchedulerDao(); // in case a different implementation is to be used public void setEventSchedulerDao(IEventSchedulerDao dao) { this.dao = dao; } @Path("{uniqueName}") @GET @Produces(MediaType.APPLICATION_JSON) public Tournament …

14 java  design  design-patterns  singleton  dao 

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

14 design  design-patterns  factory-method  factory