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

มีบางครั้งที่ฉันจะต้องแก้ไขค่าที่ส่งผ่านไปยังเมธอดจากภายในเมธอดเอง ตัวอย่างจะทำให้บริสุทธิ์สตริงเช่นวิธีนี้ที่นี่: void SanitizeName(string Name) { Name = Name.ToUpper(); //now do something here with name } สิ่งนี้ไม่เป็นอันตรายอย่างNameแท้จริงเนื่องจากอาร์กิวเมนต์ไม่ได้ถูกส่งผ่านโดยการอ้างอิง อย่างไรก็ตามถ้าด้วยเหตุผลบางอย่างผู้พัฒนาในอนาคตตัดสินใจที่จะให้ค่าทั้งหมดผ่านโดยอ้างอิงการฆ่าล้างของสตริงจะส่งผลกระทบต่อค่านอกวิธีการที่อาจมีผลเป็นอันตราย ดังนั้นแทนที่จะกำหนดใหม่ให้กับข้อโต้แย้งตัวเองฉันมักจะสร้างสำเนาท้องถิ่นเช่น: void SanitizeName(string Name) { var SanitizedName = Name.ToUpper(); //now do something here with name } สิ่งนี้ทำให้มั่นใจได้ว่าการเปลี่ยนแปลงค่าที่ส่งผ่านจะไม่ส่งผลกระทบต่อการดำเนินการด้านนอกวิธีการ แต่ฉันสงสัยว่าฉันกำลังหวาดระแวงเกี่ยวกับเรื่องนี้มากเกินไป

12 design  programming-practices 

ฉันกำลังเขียนใบสมัครและฉันมาถึงจุดนี้: private void SomeMethod() { if (Settings.GiveApples) { GiveApples(); } if (Settings.GiveBananas) { GiveBananas(); } } private void GiveApples() { ... } private void GiveBananas() { ... } นี่ดูตรงไปตรงมาสวย มีเงื่อนไขบางอย่างและหากเป็นจริงวิธีการที่จะถูกเรียก อย่างไรก็ตามฉันคิดว่ามันค่อนข้างดีกว่าที่จะทำสิ่งนี้: private void SomeMethod() { GiveApples(); GiveBananas(); } private void GiveApples() { if (!Settings.GiveApples) { return; } ... } private …

12 design  conditions 

เรากำลังทดสอบห้องสมุดภายใต้ C ++ 11 (เช่น-std=c++11) ห้องสมุดใช้auto_ptrและรูปแบบนี้: Foo* GetFoo() { autoptr<Foo> ptr(new Foo); // Initialize Foo ptr->Initialize(...); // Now configure remaining attributes ptr->SomeSetting(...); return ptr.release(); } เลิกใช้ C ++ 11 auto_ptrดังนั้นเราต้องการย้ายออกไป อย่างไรก็ตามรหัสสนับสนุนทั้ง C ++ 03 และ C ++ 11 จึงไม่ง่ายที่เป็น auto_ptryanking นอกจากนี้ยังมีมูลค่าการกล่าวถึงห้องสมุดที่ไม่มีการอ้างอิงภายนอก มันใช้ C ++ 03; และไม่ใช้ Autotools, Cmake, Boost, ... …

12 design  c++  c++11 

ฉันกำลังพัฒนาเว็บแอปพลิเคชันที่ใช้ MS SQL สำหรับข้อมูลต่าง ๆ : รวมถึงผู้ใช้บัญชีผู้ใช้ใบอนุญาตผู้ใช้ราคาใบอนุญาตใบแจ้งหนี้ ฉันต้องการบันทึกการใช้งานแบบเรียลไทม์ของระบบของผู้ใช้และใช้สำหรับการเรียกเก็บเงินรายเดือน: เช่นบันทึกเมื่อใดก็ตามที่ผู้ใช้ได้รับหน้า / URL ที่เฉพาะเจาะจงและผู้ใช้ที่เรียกเก็บเงินเมื่อสิ้นเดือนตามจำนวนหน้าที่ดึงข้อมูล ฉันควรเขียนบันทึกเหตุการณ์เหล่านี้ลงในตารางในฐานข้อมูล MS SQL ของฉันหรือไม่ ฉันควรเขียนเหตุการณ์บันทึกเหล่านี้ลงในไฟล์บันทึกแบบต่อท้ายที่ไม่ใช่ SQL เท่านั้นหรือไม่ ฉันควรเขียนบันทึกเหตุการณ์เหล่านี้ลงในไฟล์บันทึกที่แตกต่างกันสำหรับผู้ใช้แต่ละคนหรือไม่ นี่ไม่ใช่เว็บไซต์ที่มีปริมาณมากโดยเฉพาะตัวอย่างเช่นมีผู้ใช้สูงสุด 10,000 คนต่อการทำกิจกรรมเฉลี่ย 5 เหตุการณ์ต่อวัน => 50,000 กิจกรรม / วัน = 30 กิจกรรม / นาที = 18,000,000 กิจกรรม / ปี ฉันถามเพราะดูเหมือนว่าตัวเลือกจะทำงานได้และฉันไม่เห็นว่ามีข้อได้เปรียบที่ชัดเจน ข้อมูลที่เกี่ยวข้องกับเหตุการณ์ที่เรียกเก็บเงินได้นั้นง่ายมากเช่น: ID ผู้ใช้ (ความสัมพันธ์กับ foreign key ไปยังตารางผู้ใช้ใน SQL) วันและเวลา …

12 design  web-development  database  performance  logging 

ฉันทำงานให้กับ บริษัท ขนาดใหญ่ซึ่งสั่งให้ใช้กระบวนการที่คล่องตัว ตัวอย่างเช่นสำหรับโครงการของเราเราใช้บริการบนคลาวด์ที่มีเป้าหมายเฉพาะในการจัดการการพัฒนาที่คล่องตัว กลุ่มวิศวกรรมเฉพาะที่ฉันทำงานไม่ได้พัฒนาซอฟต์แวร์แบบดั้งเดิม (แต่เราช่วยผลักดันโครงการจากมุมมองที่สูงขึ้น) แต่มันกำลังเปลี่ยนแปลง เรามีโครงการซอฟต์แวร์ที่กำลังมาถึง / วางแผนหลากหลายซึ่งส่วนใหญ่เป็นศูนย์ข้อมูลเช่นเราจะทำการตรวจสอบข้อมูลการรวบรวมรวมและการรายงานบางอย่าง งานอื่น ๆ ที่เกี่ยวข้องกับระบบอัตโนมัติด้วยฮาร์ดแวร์เฉพาะและสถาปัตยกรรมไคลเอนต์ / เซิร์ฟเวอร์ (หลายเทียร์) ฉันจะช่วยในกระบวนการจ้างคนหลายคนและกำหนดแผนการหลายอย่างในการก้าวไปข้างหน้า คำถามของฉันคือการทำต้นแบบอย่างรวดเร็วหรือไม่ (รหัส throwaway) เหมาะกับปรัชญาเปรียว ตัวอย่างเช่นฉันชอบ Python และแพ็คเกจที่หลากหลาย ฉันเห็นความเป็นไปได้ที่จะนำความคิดของเราไปใช้อย่างรวดเร็วด้วยขั้นตอนการทำงานของ Python อย่างไรก็ตามฉันคิดว่าจะมีการรับรู้มากมายที่ Python ไม่ใช่ "คุณภาพระดับองค์กร" และงานนี้ส่วนใหญ่จะต้องเขียนใหม่ใน Java หรือ C ++ อย่างไรก็ตามการสร้างต้นแบบของ Python จะทำให้เรามีข้อบกพร่องมากมายในการทำให้เราสามารถให้ผลลัพธ์ที่แท้จริงได้อย่างรวดเร็ว คุณสามารถรวมต้นแบบอย่างรวดเร็ว - หวังว่าใน Python เข้ากับเวิร์กโฟลว์ที่คล่องตัวในสภาพแวดล้อมขององค์กรหรือไม่

12 python  agile  design  prototyping  product-management 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน6 ปีที่ผ่านมา เรารู้สถานการณ์ที่เหมาะสมในการเจรจาแก้ไขข้อมูลจำเพาะกับลูกค้ารับข้อมูลจำเพาะเพื่อทำสิ่งที่ลูกค้าต้องการไม่ใช่สิ่งที่พวกเขาพูดหรือคิดว่าพวกเขาต้องการ นั่นคือการเจรจาอธิบาย บางครั้งเราไม่สามารถโน้มน้าวลูกค้า เราถูกบังคับให้ผลิตสินค้าที่เสียหายตามที่ออกแบบไว้ สิ่งนี้เรียกว่า "ปิศาจวิทยา" โดยการทำบุญของนักเวทย์เรียกปีศาจและปีศาจมาเติมเต็มความปรารถนาอย่างแท้จริงทำให้เกิดการตายของนักเวทย์เป็นอีกแนวทางหนึ่งที่จะทำให้ลูกค้าไม่พอใจอย่างมากเมื่อพวกเขาตระหนักถึงข้อผิดพลาดของพวกเขา ตำหนินักพัฒนา ตอนนี้ฉันเพิ่งเผชิญกับวิธีที่แตกต่างกันมาก: ลูกค้าสร้างสเปคอย่างง่ายที่ล้มเหลวในการพิจารณาข้อแม้ที่สำคัญบางอย่างและไม่เต็มใจที่จะแก้ไขอย่างสมบูรณ์ยอมรับข้อผิดพลาดที่เห็นได้ชัดและยอมรับการแก้ไขที่แนะนำ ผลิตภัณฑ์ที่ทำตามข้อกำหนดเหล่านี้จะถูกทำลายอย่างรุนแรงและอาจทำให้เสียชีวิตได้ ยังคงสายเกินไปที่จะยกเลิกสัญญาโดยสิ้นเชิง สัญญามีข้อบทลงโทษสำหรับสิ่งที่เราไม่สามารถยอมรับได้จริงๆ การตัดสินใจของเจ้านาย? เราทำงานถูกต้องและโกหกลูกค้าที่เราทำตามข้อกำหนด อัลกอริทึมที่เป็นปัญหาถูกซ่อนอยู่ลึกพอที่ใต้พื้นผิวผลิตภัณฑ์จะทำงานได้ดีไม่ล้มเหลวในสถานการณ์ข้อแม้และถ้าไม่มีใครขุดลึกเกินไปพวกเขาจะไม่ค้นพบว่าเราไม่ได้ทำลายมันตามที่ร้องขอ มีชื่อสามัญสำหรับกลวิธีการดำเนินการรายละเอียดนี้หรือไม่?

12 design  specifications 

ฉันมีปัญหาการออกแบบเกี่ยวกับคุณสมบัติ. NET interface IX { Guid Id { get; } bool IsInvalidated { get; } void Invalidate(); } ปัญหา: อินเตอร์เฟซนี้มีสองคุณสมบัติอ่านอย่างเดียวและId IsInvalidatedอย่างไรก็ตามความจริงที่ว่าพวกเขาเป็นแบบอ่านอย่างเดียวไม่สามารถรับประกันได้ว่าค่าของพวกเขาจะคงที่ สมมติว่ามันเป็นความตั้งใจของฉันที่จะทำให้ชัดเจนว่า ... Id แทนค่าคงที่ (ซึ่งอาจถูกแคชอย่างปลอดภัย) ในขณะที่ IsInvalidatedอาจเปลี่ยนค่าในช่วงอายุของIXวัตถุ (และไม่ควรแคช) ฉันจะปรับเปลี่ยนinterface IXเพื่อให้สัญญานั้นชัดเจนเพียงพอได้อย่างไร ความพยายามสามข้อของฉันในการแก้ปัญหา: อินเตอร์เฟสได้รับการออกแบบมาอย่างดี การปรากฏตัวของวิธีการที่เรียกว่าInvalidate()ช่วยให้โปรแกรมเมอร์ที่จะอนุมานว่ามูลค่าของทรัพย์สินที่มีชื่อคล้ายกันIsInvalidatedอาจได้รับผลกระทบจากมัน อาร์กิวเมนต์นี้มีไว้เฉพาะในกรณีที่เมธอดและคุณสมบัติมีชื่อคล้ายกัน เพิ่มส่วนต่อประสานนี้กับกิจกรรมIsInvalidatedChanged: bool IsInvalidated { get; } event EventHandler IsInvalidatedChanged; สถานะของ…Changedเหตุการณ์สำหรับIsInvalidatedสถานะที่คุณสมบัตินี้อาจเปลี่ยนค่าและการไม่มีเหตุการณ์ที่คล้ายกันสำหรับIdเป็นสัญญาว่าคุณสมบัตินั้นจะไม่เปลี่ยนค่าของมัน ฉันชอบโซลูชันนี้ แต่มีสิ่งเพิ่มเติมมากมายที่อาจไม่ได้ใช้เลย แทนที่คุณสมบัติIsInvalidatedด้วยเมธอดIsInvalidated(): bool IsInvalidated(); …

12 c#  design  .net  properties 

นี่คือสิ่งที่ฉันเรียกวิธีการ "รวม" getter / setter (จาก jQuery): var foo = $("<div>This is my HTML</div>"), myText; myText = foo.text(); // myHTML now equals "This is my HTML" (Getter) foo.text("This is a new value"); // The text now equals "This is a new value") นี่คือตรรกะเดียวกันกับวิธีการแยก (ทางทฤษฎี): var foo = $("<div>This is my …

12 design  javascript 

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

12 design  database  database-design  entity 

ฉันเป็นนักพัฒนาซอฟต์แวร์ที่ทำงานใน บริษัท ระบบฝังตัว เรามีผู้จัดการโครงการที่ดูแลกำหนดการโครงการโดยรวม (รวมถึงไฟฟ้าคุณภาพซอฟต์แวร์และการผลิต) ดังนั้นกำหนดการซอฟต์แวร์ของเขาจึงสั้นมาก เรายังมีผู้จัดการซอฟต์แวร์ซึ่งเป็นหัวหน้าของฉัน เขาทำให้ฉันเขียนและบำรุงรักษากำหนดการซอฟต์แวร์เอกสารการออกแบบ (การออกแบบระดับสูงและต่ำ) SRS การจัดการการเปลี่ยนแปลงแผนการตรวจสอบและรายงานการจัดการการเปิดตัวการทบทวนและหลักสูตรซอฟต์แวร์ เรามีวิศวกรทดสอบเพียงคนเดียวสำหรับทีมซอฟต์แวร์ทั้งหมด (สมาชิก 10 คน) และในเวลาใดก็ตามมีโครงการสองโครงการเกิดขึ้น ฉันใช้เวลา 80% ในการทำเอกสารเหล่านี้ เจ้านายของฉันมาจากพื้นฐานกระบวนการและเชื่อว่าสิ่งที่เราต้องการคือเอกสารที่ดีกว่าในการปรับปรุงซอฟต์แวร์: เขาคิดว่าการออกแบบเป็นสิ่งสำคัญยิ่งการเข้ารหัสคือ "เพียงแค่เขียนการออกแบบ" มันไม่ควรใช้เวลานานเกินไปและ "รหัสทั้งหมดควรจะเขียนก่อนที่ฮาร์ดแวร์จะพร้อม" ไม่เข้าใจความแตกต่างระหว่างตัวควบคุม Central & Distributed Version แม้ว่าเราจะบอกเขาว่ามันง่ายกว่าที่จะทำงานร่วมกับแบบจำลองการกระจาย ไม่เข้าใจรหัสและต้องการเข้าใจทุกข้อบกพร่องและแนวทางแก้ไขที่เสนอ การตรวจสอบความเชื่อควรทำโดยนักพัฒนาและการตรวจสอบโดยผู้ทดสอบ สิ่งที่เป็นอยู่การตรวจสอบของเราเพียงตรวจสอบว่าการใช้งานถูกต้อง (เราไม่ได้เขียนการทดสอบหน่วยมันไม่เคยพิจารณาในตาราง) และการตรวจสอบคือการทดสอบกล่องดำดังนั้นการทดสอบหน่วยจะหายไป ฉันสับสนจริงๆ ฉันต้องรับผิดชอบในการดูแลรักษาเอกสารเหล่านี้ทั้งหมดหรือไม่ มันทำให้ฉันรู้สึกว่าฉันกำลังทำ Software Management Management เป็นหลัก ฉันใช้ได้กับเอกสารทางเทคนิค แต่ฉันเชื่อว่านักพัฒนาไม่ควรทำตามกำหนดเวลา / การวางแผน ฉันไม่ชอบการสร้างเอกสารฉันต้องการแก้ปัญหาและเขียนรหัส จากประสบการณ์ของฉันการสร้างเอกสารการออกแบบจะช่วยเท่าที่ไม่เคยแก้ปัญหาของรหัสที่ดีขึ้นหรือเร็วขึ้น ฉันรู้สึกว่าเจ้านายไม่ได้ใส่ใจกับการสร้างผลิตภัณฑ์ที่ดีกว่า แต่เกี่ยวกับการเป็นผู้จัดการที่ดีในสายตาของผู้บริหาร …

12 design  project-management  development-process  documentation 

ฉันกำลังพัฒนาแอพที่จะใช้ในการเปิดและปิดวาล์วในสภาพแวดล้อมอุตสาหกรรมและกำลังคิดถึงบางสิ่งที่เรียบง่ายเช่นนี้: - public static void ValveController { public static void OpenValve(string valveName) { // Implementation to open the valve } public static void CloseValve(string valveName) { // Implementation to close the valve } } (การนำไปใช้นั้นจะเขียนข้อมูลสองสามไบต์ไปยังพอร์ตอนุกรมเพื่อควบคุมวาล์ว - "ที่อยู่" ซึ่งได้มาจากชื่อของวาล์วและ "1" หรือ "0" เพื่อเปิดหรือปิดวาล์ว) นักพัฒนาอีกคนถามว่าเราควรสร้างคลาสแยกต่างหากสำหรับแต่ละวาล์วทางกายภาพซึ่งมีอยู่เป็นสิบหรือไม่ ฉันยอมรับว่ามันจะดีกว่าที่จะเขียนโค้ดเหมือนPlasmaValve.Open()มากกว่าValveController.OpenValve("plasma")แต่นี่เป็น overkill หรือไม่ นอกจากนี้ฉันยังสงสัยว่าวิธีที่ดีที่สุดในการจัดการกับการออกแบบโดยคำนึงถึงความต้องการในอนาคตของสมมุติสองสามข้อ: - เราได้รับการร้องขอให้สนับสนุนวาล์วชนิดใหม่ที่ต้องการค่าต่าง ๆ …

12 design  design-patterns  object-oriented 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน2 ปีที่ผ่านมา ฉันรู้ว่าฉันมีปัญหาในการสร้างการออกแบบ OOP ฉันใช้เวลาตัดสินใจหลายครั้งว่าคุณสมบัตินี้ตั้งค่าเป็นคลาส X อย่างถูกต้องหรือไม่ ตัวอย่างเช่นนี่คือโพสต์ที่มีสองสามวัน: /codereview/8041/how-to-improve-my-factory-design ฉันไม่มั่นใจในรหัสของฉัน ดังนั้นฉันต้องการที่จะปรับปรุงการออกแบบของฉันใช้เวลาน้อยลงในการสร้างมันขึ้นมา คุณเรียนรู้การสร้างงานออกแบบที่ดีได้อย่างไร หนังสือบางเล่มที่คุณสามารถแนะนำฉันได้ไหม

12 design  object-oriented 

ฉันกำลังอ่านหนังสือที่ยอดเยี่ยมเล่มนี้ชื่อว่า"Coders at Work: Reflections on Craft of Programming"โดย Peter Seibelและฉันก็เป็นส่วนหนึ่งของการสนทนากับ Joshua Bloch และฉันก็พบคำตอบนี้ซึ่งเป็นจุดสำคัญสำหรับโปรแกรมเมอร์ ย่อหน้ามีบางอย่างเช่นนี้ มีปัญหานี้ซึ่งก็คือการเขียนโปรแกรมเป็นเรื่องของการทำบุญทางปัญญามากมายและบ่อยครั้งที่คนเหล่านี้เป็นคนที่ฉลาดที่สุดในองค์กร ดังนั้นพวกเขาคิดว่าพวกเขาควรได้รับอนุญาตให้ทำการตัดสินใจทั้งหมด แต่ความจริงที่ว่าพวกเขาเป็นคนที่ฉลาดที่สุดในองค์กรไม่ได้หมายความว่าพวกเขาควรทำการตัดสินใจทั้งหมดเพราะความฉลาดไม่ได้เป็นปริมาณสเกลาร์ มันคือปริมาณเวกเตอร์ ในประโยคสุดท้ายนี้ฉันไม่เข้าใจว่าเขาพยายามแบ่งปันอะไร มีคนอธิบายได้ในอีกสักครู่ว่าสิ่งที่เขาหมายถึงปริมาณเวกเตอร์อาจพยายามนำเสนอข้อมูลเชิงลึกเดียวกัน ยิ่งไปกว่านั้นฉันได้รับจุดที่เขาไม่ได้รับเกี่ยวกับการมีองค์กรที่ไม่ใช่คนเทคนิค (บางครั้ง clueless) สามารถเป็นผู้จัดการของคนทางเทคนิคด้วยเหตุผลบางอย่างที่พวกเขาสามารถใช้เวลามากขึ้นในการเขียนอีเมลที่ดีเพราะต่อไป คำสั่งต่อไปนี้ย่อหน้าข้างต้นคือ และถ้าคุณขาดความเห็นอกเห็นใจหรือความฉลาดทางอารมณ์คุณก็ไม่ควรออกแบบ APIs หรือ GUI หรือภาษา ฉันเข้าใจว่าเขากำลังพูดว่าในวิศวกรรมซอฟต์แวร์โปรแกรมเมอร์ควรรู้ว่าผู้ใช้จะเห็นผลิตภัณฑ์และการออกแบบของพวกเขาอย่างไร ฉันรู้สึกว่าย่อหน้าข้างต้นน่าสนใจมาก

12 design  project-management  customer-relations 

ฉันอยู่ในกระบวนการพัฒนาการจัดการสัญญาณและโมดูลการกำหนดเส้นทางสำหรับระบบภาพและเสียงแบบบูรณาการและกำลังออกแบบด้วยความตั้งใจที่จะยืดหยุ่นได้มากที่สุดในเครือข่ายการกระจายสัญญาณที่แตกต่างกัน จุดประสงค์ของโมดูลคือการจัดการการจัดเส้นทางข้ามสวิตช์เมทริกซ์แบบซ้อนจำนวน1และจัดการการแปลงรูปแบบที่จำเป็น ทางออกที่ดีที่สุดที่ฉันได้สำรวจ ณ จุดนี้คือการแมปเครือข่ายกับกราฟโดยมีจุดยอดแยกสำหรับแต่ละประเภทสัญญาณที่สนับสนุนโดยสวิตช์และจากนั้นจะเชื่อมต่อผ่านโหนดที่เป็นตัวแทนของตัวประมวลผลวิดีโอที่จัดการการแปลงรูปแบบ สีแสดงถึงรูปแบบสัญญาณ โหนดรอบเป็นสวิตช์แหล่งหรืออ่างล้างจาน Square nodes เป็นตัวประมวลผลวิดีโอซึ่งทำการแปลงรูปแบบ จากนั้นฉันสามารถใช้การดำเนินการตามอัลกอริธึมของ Dijkstraเพื่อระบุเส้นทางที่จะต้องเกิดขึ้นเพื่อรับอินพุต X ไปยังเอาต์พุต Y ซึ่งควรอนุญาตให้มีข้อมูลเกี่ยวกับการกำหนดค่าอินพุต / เอาต์พุตของสวิตช์และโปรเซสเซอร์ทั้งหมด และโมดูลปรับตาม นี่เป็นวิธีแก้ปัญหาที่เหมาะสมหรือมีแนวทางอื่นที่อาจคุ้มค่าในการตรวจสอบหรือไม่? 1 aka 'crossbar switch' ซึ่งเป็นเราเตอร์วิดีโอที่มีเอาต์พุต M อินพุต x N ซึ่งรองรับการเชื่อมต่อแบบหนึ่งต่อหลายคน อุปกรณ์ phsyical แต่ละเครื่องอาจรองรับสัญญาณได้หลายรูปแบบและอาจหรือไม่สามารถทำการแปลงรูปแบบใด ๆ แก้ไข:ดังกล่าวโดยPéterTörökกราฟไม่จำเป็นต้องเป็นต้นไม้แผนภาพเป็นตัวอย่างง่าย ๆ เพื่อแสดงความคิด เมื่อนำไปใช้ในหลายเส้นทาง 'โลกแห่งความจริง' อาจมีอยู่ซึ่งเสนอระดับความหมายที่แตกต่างกัน (DVI> VGA> องค์ประกอบ> คอมโพสิต) ซึ่งฉันวางแผนที่จะนำเสนอด้วยน้ำหนักขอบ แก้ไข 2:นี่คือตัวอย่างที่ครอบคลุมมากขึ้นเล็กน้อยโดยมีการระบุทิศทางและการแสดงเครือข่ายที่ประกอบด้วยสัญญาณสองประเภท ตัวอย่างเริ่มต้นได้รับการแก้ไขเล็กน้อยเพื่อให้แต่ละอินพุตและเอาต์พุตบนอุปกรณ์ถูกกำหนดเป็นโหนดแบบไม่ต่อเนื่องเนื่องจากจะให้ข้อมูลที่จำเป็นสำหรับการควบคุมการเลือกเส้นทาง / อินพุตเมทริกซ์

12 design  algorithms 

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

12 object-oriented  design  domain-driven-design