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

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

15 object-oriented  architecture  functional-programming 

ฉันกำลังทำงานเกี่ยวกับการออกแบบแอปพลิเคชันที่ประกอบด้วยสามส่วน: เธรดเดียวที่เฝ้าดูเหตุการณ์บางอย่างที่เกิดขึ้น (การสร้างไฟล์คำขอภายนอก ฯลฯ ) เธรดผู้ปฏิบัติงาน N ที่ตอบสนองต่อเหตุการณ์เหล่านี้โดยการประมวลผล (ผู้ปฏิบัติงานแต่ละกระบวนการและใช้เหตุการณ์เดียวและการประมวลผลอาจใช้เวลาแปรผัน) คอนโทรลเลอร์ที่จัดการเธรดเหล่านั้นและจัดการข้อผิดพลาด (การรีสตาร์ทเธรดการบันทึกผลลัพธ์) แม้ว่านี่จะค่อนข้างพื้นฐานและไม่ยากที่จะนำมาใช้ แต่ฉันก็สงสัยว่ามันจะเป็นวิธีที่ "ถูกต้อง" (ในกรณีที่เป็นรูปธรรมนี้ใน Java แต่คำตอบที่เป็นนามธรรมก็สูงขึ้นเช่นกัน) กลยุทธ์ทั้งสองมาถึงใจ: ผู้สังเกตการณ์ / สังเกตได้:ผู้สังเกตการณ์จะเฝ้าสังเกตด้ายดู ในกรณีที่มีเหตุการณ์เกิดขึ้นคอนโทรลเลอร์จะได้รับแจ้งและสามารถมอบหมายงานใหม่ให้กับเธรดอิสระจากกลุ่มเธรดแคชที่ใช้ซ้ำได้ (หรือรอและแคชงานในคิว FIFO หากเธรดทั้งหมดไม่ว่างในขณะนี้) เธรดผู้ปฏิบัติงานใช้ Callable และส่งคืนผลลัพธ์ที่สำเร็จพร้อมกับผลลัพธ์ (หรือค่าบูลีน) หรือส่งคืนพร้อมข้อผิดพลาดในกรณีนี้ผู้ควบคุมอาจตัดสินใจว่าจะทำอย่างไร (ขึ้นอยู่กับลักษณะของข้อผิดพลาดที่เกิดขึ้น) ผู้ผลิต / ผู้บริโภค : เธรดการเฝ้าดูที่ใช้ร่วมกัน BlockingQueue กับตัวควบคุม (เหตุการณ์คิว) และตัวควบคุมที่ใช้ร่วมกันสองกับคนงานทั้งหมด (งานคิวและผลคิว) ในกรณีที่เกิดเหตุการณ์ด้ายเฝ้าดูทำให้วัตถุงานในคิวเหตุการณ์ คอนโทรลเลอร์ใช้งานใหม่จาก event-queue ตรวจสอบและวางไว้ใน task-queue ผู้ปฏิบัติงานแต่ละคนรองานใหม่และรับ / ใช้งานจากคิวงาน (มาก่อนได้รับก่อนจัดการโดยคิวเอง) …

15 java  architecture  concurrency  observer-pattern  producer-consumer 

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

15 java  architecture  backward-compatibility 

ฉันสับสนเล็กน้อยเกี่ยวกับรูปแบบสถาปัตยกรรมมุมมอง 4 + 1 จับคู่กับ UML Wikipediaให้การแมปต่อไปนี้: มุมมองเชิงตรรกะ:แผนภาพคลาส, แผนภาพการสื่อสาร, แผนภาพลำดับ มุมมองการพัฒนา:แผนภาพส่วนประกอบ, แผนภาพแพคเกจ มุมมองกระบวนการ:แผนภาพกิจกรรม มุมมองทางกายภาพ:แผนภาพการปรับใช้ สถานการณ์จำลอง:แผนภาพการใช้เคส กระดาษบทบาทของ UML แผนภาพลำดับ Constructs ในวัตถุ Lifecycle แนวคิดจะช่วยให้การทำแผนที่ต่อไปนี้: มุมมองเชิงตรรกะ (แผนภาพคลาส (CD), วัตถุแผนภาพ (OD), แผนภาพลำดับ (SD), แผนภาพความร่วมมือ (COD), แผนภาพสถานะของรัฐ (SCD), แผนภาพกิจกรรม (AD)) มุมมองการพัฒนา (แผนภาพแพคเกจแผนภาพส่วนประกอบ) มุมมองกระบวนการ (ใช้แผนภาพกรณี, CD, OD, SD, COD, SCD, AD) มุมมองทางกายภาพ (แผนภาพการปรับใช้) และ ใช้มุมมองกรณี (ใช้แผนภาพกรณี, …

15 architecture  uml  model  view 

ฉันมีคำถามในขณะที่ออกแบบสถาปัตยกรรมสำหรับโครงการรอบ MVC (เป็นโครงการ SDK C ++ / Marmalade ฉันไม่ได้ใช้กรอบ MVC ใด ๆ โดยเฉพาะฉันกำลังทำอยู่) ในหลาย ๆ บทความ (เช่นเดียวกับบทความเดิมของ Steve Burbek ) ฉันอ่านแนวคิด "MVC triad" ที่ทำให้ฉันรู้สึกแย่ตั้งแต่ที่ฉันใช้แนวคิดนี้ไป เมื่อฉันอ่านครั้งแรกดูเหมือนว่าแอปพลิเคชันจะถูกสร้างขึ้นรอบ ๆ "MVC triad" - หนึ่งชิ้นสำหรับแต่ละส่วน UI ที่ฉันควรจะ - แต่ฉันพบว่ามันค่อนข้างไม่ยืดหยุ่นและฉันคิดว่านั่นไม่ใช่วิธีที่ MVC ตั้งใจใช้ จากนั้นทำการค้นคว้าเพิ่มเติมเกี่ยวกับปัญหาฉันพบตัวอย่างของการมีเพศสัมพันธ์อย่างแน่นหนาของคอนโทรลเลอร์และมุมมองคือความสัมพันธ์แบบ 1 ต่อ 1 - TextEditView มี TextEditController แต่เมื่อฉันกลับไปที่โครงการของฉันฉันพบว่าอาจเป็นประโยชน์ที่จะมีตัวควบคุมหนึ่ง (โดย 'หน่วยทางลอจิคัล' เช่น AddElementController) และหลายมุมมองสำหรับตัวควบคุมนั้น …

15 design  design-patterns  architecture  mvc 

ฉันคิดว่าฉันมีความเข้าใจในความคาดหวังของการพัฒนาแอปพลิเคชันผู้บริโภคสำหรับ Windows 8 สร้าง UI แบบใหม่บนเมโทรบน WinRT ปรับใช้กับลูกค้าของคุณผ่านทาง Marketplace และทุกคนชนะ ดูเหมือนง่ายพอ น่าเสียดายที่ฉันไม่ได้อยู่ในธุรกิจนั้น ฉันทำงานกับแอปพลิเคชันภายในสายงานธุรกิจสำหรับองค์กรขนาดใหญ่ ขณะนี้เราใช้เทคโนโลยี. NET เช่น WPF และ Silverlight เพื่อสร้าง UIs ที่หลากหลายซึ่งสามารถปรับใช้กับผู้ใช้ของเราผ่านทางเว็บหรือ ClickOnce ได้อย่างง่ายดาย แอปพลิเคชันสามารถรองรับ WinXP และ Win7 ได้โดยไม่ต้องปวดหัวมากนักและนักพัฒนาของเราจะใช้ XAML ซึ่งเป็นเทคโนโลยี UI ที่แข็งแกร่งมาก ดูเหมือนว่า WPF และ Silverlight จะมีข้อสงสัยในอนาคต ณ จุดนี้ดังนั้นจึงเป็นเรื่องน่ากังวลที่จะลงทุนในหุ้นเหล่านี้ต่อไป แต่ Metro UI ดูเหมือนจะไม่เหมาะสมสำหรับแอปพลิเคชันระดับองค์กรและ WinRT API ค่อนข้าง จำกัด เกี่ยวกับสิ่งที่ "ทั่วไป" …

15 architecture  enterprise-architecture  windows-8  forward-compatibility 

ฉันมีปัญหาในการตั้งชื่อชั้นเรียนและบริการของฉันอย่างถูกต้องเมื่อมีส่วนร่วมและชั้นเรียนช่วยเหลืออื่น ๆ เข้ามาเกี่ยวข้อง คุณจะจัดโครงสร้างต่อไปนี้อย่างไร: EventService.cs EventServiceUtils.cs EventServiceValidators.cs EventServiceCoordinator.cs ฯลฯ ... ฉันมีหลายบริการที่มีความต้องการเช่นเดียวกับบริการข้างต้น ความคิดหนึ่งคือการแยกสิ่งเหล่านี้ทั้งหมดออกเป็นเนมสเปซที่เหมาะสมทำให้มันเป็นดังนี้: Services.EventService.EventService.cs //(the actual service) Services.EventService.Validators.DateValidator.cs Services.EventService.Validators.ParticipantValidator.cs Services.EventService.Coordinators.ParticipantCoordinator.cs Services.EventService.ExtensionMethods.Extensions.cs และอื่น ๆ แน่นอนว่าเนมสเปซทุกรายการจะมีโฟลเดอร์แยกต่างหาก แต่นี่ไม่ได้รู้สึก 100% เนื่องจากมีDateValidatorsบริการอื่น ๆ อีกมากมายซึ่งอาจนำไปสู่การอ้างอิงที่ไม่พึงประสงค์ได้อย่างง่ายดาย และยังServices.EventService.EventService.csรวมถึงชื่อคลาสในเนมสเปซซึ่งไม่ดีเช่นกัน คุณสามารถใช้Services.Event.EventService.csแต่มีหลักสูตรที่มีชื่อนั้นอยู่แล้ว นี่คือรูปแบบโดเมน

15 c#  architecture 

Jeff Atwood เพิ่งเขียนโพสต์บล็อกเกี่ยวกับการใช้ Netflix ของ "Chaos Monkey" มันเป็นบทความระดับสูงมาก ฉันอยากรู้ว่าถ้าใครใช้เทคนิคนี้เพื่อทดสอบระบบ ฉันเดาว่าฉันพยายามถามอะไรจริงๆ: คุณใช้กลยุทธ์อะไรเพื่อให้มั่นใจว่าสถาปัตยกรรมของคุณสามารถอยู่รอดได้ในส่วนของระบบที่ล้มเหลว

15 c#  architecture  cloud-computing 

TDD เป็นเรื่องเกี่ยวกับการออกแบบโค้ดซึ่งได้รับคำแนะนำจากการทดสอบ ดังนั้นเลเยอร์ทั่วไปมักจะไม่สร้างล่วงหน้า พวกเขาควรปรากฏขึ้นเล็กน้อยผ่านขั้นตอนการรีแฟคเตอร์ การออกแบบที่ขับเคลื่อนด้วยโดเมนนั้นเกี่ยวข้องกับรูปแบบทางเทคนิคมากมายการกำหนดเลเยอร์ที่ได้รับการยอมรับเช่นแอพพลิเคชั่นเลเยอร์โครงสร้างพื้นฐานเลเยอร์โดเมนเลเยอร์คงอยู่ ในการเริ่มต้นการเข้ารหัสส่วนของโครงการ DDD ตั้งแต่เริ่มต้นจะทำอย่างไร? ฉันควรปล่อยให้การออกแบบโผล่ออกมาจากการทดสอบอย่างเคร่งครัดหรือไม่หมายถึงไม่มีการแยกข้อกังวล (ไม่มีเลเยอร์) และ refactor เพื่อให้พอดีกับรูปแบบทางเทคนิคของ DDD? หรือฉันควรสร้างเลเยอร์ที่ว่างเปล่าเหล่านั้น (แอปพลิเคชันหน่วยงาน / บริการโดเมนโครงสร้างพื้นฐาน) และให้ TDD เหมาะสมกับแต่ละชั้นอย่างอิสระ (ใช้ mocks เพื่อแยกระหว่างเลเยอร์)

15 architecture  testing  tdd  domain-driven-design 

ชื่อกล่าวว่า "การพึ่งพาหนังสือเวียน" แต่มันไม่ได้เป็นถ้อยคำที่ถูกต้องเพราะสำหรับฉันการออกแบบดูเหมือนจะแข็ง อย่างไรก็ตามให้พิจารณาสถานการณ์ต่อไปนี้ซึ่งชิ้นส่วนสีน้ำเงินได้รับจากคู่ค้าภายนอกและสีส้มคือการนำไปปฏิบัติของฉันเอง นอกจากนี้สมมติว่ามีมากกว่าหนึ่งConcreteMainแต่ฉันต้องการใช้เฉพาะ (ในความเป็นจริงแต่ละชั้นมีการพึ่งพาอาศัยกันมากกว่านี้ แต่ฉันพยายามทำให้มันง่ายขึ้นที่นี่) ฉันต้องการเริ่มต้นทั้งหมดนี้ด้วย Depency Injection (Unity) แต่เห็นได้ชัดว่าฉันได้รับStackOverflowExceptionรหัสต่อไปนี้เนื่องจาก Runner พยายามยกตัวอย่าง ConcreteMain และ ConcreteMain ต้องการนักวิ่ง IUnityContainer ioc = new UnityContainer(); ioc.RegisterType<IMain, ConcreteMain>() .RegisterType<IMainCallback, Runner>(); var runner = ioc.Resolve<Runner>(); ฉันจะหลีกเลี่ยงสิ่งนี้ได้อย่างไร มีวิธีการสร้างโครงสร้างนี้เพื่อให้ฉันสามารถใช้กับ DI? สถานการณ์ที่ฉันทำอยู่ในขณะนี้คือการตั้งค่าทุกอย่างด้วยตนเอง แต่นั่นทำให้การพึ่งพาอย่างหนักConcreteMainในชั้นเรียนที่ทำให้อินสแตนซ์มัน นี่คือสิ่งที่ฉันพยายามหลีกเลี่ยง (ด้วยการลงทะเบียน Unity ในการกำหนดค่า) รหัสแหล่งที่มาทั้งหมดด้านล่าง (ตัวอย่างง่ายมาก!); public class Program { public static void Main(string[] …

15 architecture  dependency-injection  architectural-patterns 

เรากำลังจะเขียนแอปพลิเคชั่น WPF แรกของเราและเริ่มคุ้นเคยกับรูปแบบ MVVM เราได้สร้างแอปพลิเคชั่น Winform จำนวนมากและมีสถาปัตยกรรมที่ประสบความสำเร็จมากสำหรับเรา เรามีปัญหาเล็กน้อยในการแปลสถาปัตยกรรมนั้นหรือกำหนดว่าสถาปัตยกรรมบางอย่างของเราเหมาะสมกับรูปแบบ MVVM หรือไม่ ในอดีตเรามี Gui (exe หลัก) ที่สื่อสารกับ dll BusinessLogic BusinessLogic สื่อสารกับ DAL dll ผ่านเว็บเซอร์วิสและ DAL โต้ตอบกับ DB DAL, BusinessLogic และ GUI ล้วนอ้างถึง BusinessObjects dll เดียวกัน การเปลี่ยนแปลงไปสู่ ​​MVVM นั้นค่อนข้างตรงไปตรงมา Gui ของเราจะยังคงมีมุมมอง BusinessOjbects ของเราจะยังคงมีรูปแบบและ DAL ของเราจะยังคงมีปฏิสัมพันธ์กับฐานข้อมูล (แม้ว่าเทคโนโลยีในการใช้พวกเขาอาจเปลี่ยนแปลง) สิ่งที่เราไม่แน่ใจคือองค์ประกอบ BusinessLogic ของเรา ในอดีตนี้จะให้ฟังก์ชั่นสำหรับ GUI เพื่อเรียกไปแล้วเติมการควบคุมในมุมมอง (เช่น. …

15 architecture  mvvm 

บริบท: ฉันใช้ C # ฉันออกแบบชั้นเรียนและเพื่อแยกมันออกและทำให้การทดสอบหน่วยง่ายขึ้นฉันกำลังผ่านการพึ่งพาทั้งหมด มันไม่สร้างอินสแตนซ์ของวัตถุภายใน อย่างไรก็ตามแทนที่จะอ้างอิงอินเทอร์เฟซเพื่อรับข้อมูลที่ต้องการฉันขอให้อ้างอิงวัตถุประสงค์ทั่วไป Funcs ที่ส่งคืนข้อมูล / พฤติกรรมที่ต้องการ เมื่อฉันฉีดการพึ่งพาของฉันฉันสามารถทำได้ด้วยการแสดงออกแลมบ์ดา สำหรับฉันดูเหมือนว่าจะเป็นวิธีที่ดีกว่าเพราะฉันไม่ต้องล้อเลียนเรื่องน่าเบื่อใด ๆ ระหว่างการทดสอบหน่วย นอกจากนี้หากการดำเนินการโดยรอบมีการเปลี่ยนแปลงพื้นฐานฉันจะต้องเปลี่ยนระดับโรงงานเท่านั้น ไม่มีการเปลี่ยนแปลงในชั้นเรียนที่มีตรรกะจะต้อง อย่างไรก็ตามฉันไม่เคยเห็น IoC ทำแบบนี้มาก่อนซึ่งทำให้ฉันคิดว่าอาจมีข้อผิดพลาดที่อาจเกิดขึ้น สิ่งเดียวที่ฉันคิดได้คือความไม่ลงรอยกันเล็กน้อยกับ C # รุ่นก่อนหน้าซึ่งไม่ได้กำหนด Func และนี่ไม่ใช่ปัญหาในกรณีของฉัน มีปัญหาใด ๆ หรือไม่ที่มีการใช้งานผู้รับมอบสิทธิ์ทั่วไป / ฟังก์ชั่นการสั่งซื้อที่สูงขึ้นเช่น Func สำหรับ IoC ซึ่งตรงข้ามกับส่วนต่อประสานที่เฉพาะเจาะจงมากขึ้น?

15 architecture  interfaces  inversion-of-control  delegates 

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

14 design-patterns  architecture 

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

14 design  architecture  dry  coupling 

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

14 architecture