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

บางครั้งผู้ใช้เริ่มการดำเนินการด้านเทคนิคเพิ่มเติมซึ่งใช้เวลาสักครู่ในการดำเนินการ ในกรณีเหล่านี้มักจะแสดงแถบความคืบหน้าพร้อมกับข้อมูลเกี่ยวกับงานที่กำลังดำเนินการอยู่ในขณะนี้ เพื่อหลีกเลี่ยงการมีเพศสัมพันธ์อย่างใกล้ชิดกับ UI และเลเยอร์ตรรกะมันเป็นการดีที่สุดที่จะเกิดการสื่อสารผ่านพร็อกซีบางประเภท นั่นคือแบ็คเอนด์ไม่ควรจัดการองค์ประกอบ UI ของตัวเองหรือแม้กระทั่งโต้ตอบกับเลเยอร์ตัวกลางโดยตรง เห็นได้ชัดว่าจะต้องมีการโทรกลับบางแห่งเพื่อให้งานนี้ ฉันได้นำไปใช้โดยทั่วไปด้วยหนึ่งในสองวิธี: ส่งผ่านวัตถุที่ไม่แน่นอนไปยังส่วนหลังและให้ส่วนหลังเปลี่ยนแปลงอยู่ระหว่างดำเนินการ วัตถุแจ้ง Front-end เมื่อมีการเปลี่ยนแปลงเกิดขึ้น ผ่านฟังก์ชั่นโทรกลับของแบบฟอร์มvoid f(ProgressObject)หรือProgressObject -> unitว่าส่วนหลังเรียกใช้ ในกรณีนี้ back-end สร้างProgressObjectและมันแฝงอย่างสมบูรณ์ มันจะต้องสร้างวัตถุใหม่ทุกครั้งที่ต้องการรายงานความคืบหน้าฉันถือว่า ข้อเสียและข้อดีของวิธีการเหล่านี้คืออะไร? มีวิธีใช้ที่ดีที่สุดตามที่ตกลงกันไว้หรือไม่? มีสถานการณ์ที่แตกต่างกันสำหรับการใช้งานของพวกเขา? มีเทคนิคที่แตกต่างอย่างสิ้นเชิงจากการรายงานความก้าวหน้าที่ฉันมองข้ามไปหรือไม่?

11 design  object-oriented  gui 

รับคลาส Python ซึ่งจะถูกสร้างอินสแตนซ์เพียงครั้งเดียวคือจะมีเพียงวัตถุเดียวของคลาส ฉันสงสัยในกรณีที่เหมาะสมที่จะสร้างอินสแตนซ์ของคลาสเดียวแทนที่จะทำงานโดยตรงกับคลาสแทน มีคำถามที่คล้ายกันแต่มีจุดเน้นที่แตกต่าง: มันเกี่ยวกับการจัดกลุ่มตัวแปรส่วนกลางและฟังก์ชันในคลาสและ มันไม่ได้เป็นงูหลามที่เฉพาะเจาะจง หลังหมายถึงมันไม่ได้พิจารณาความจริงที่ว่าคลาส (ใน Python) เป็นวัตถุด้วย UPDATE: ใน Python ฉันสามารถทำสิ่งต่อไปนี้กับทั้งคลาสและวัตถุ: class A(object): pass A.some_state_var = True # Then later A.some_state_var = False my_a = A() my_a.some_state_var = True # Then later my_a.some_state_var = False ดังนั้นฉันไม่เห็นวิธีการเลือกระหว่างคลาสและอินสแตนซ์ของคลาสนั้นเกี่ยวกับสถานะ (ใน Python) ฉันสามารถรักษาสถานะด้วยสองอย่างใดอย่างหนึ่ง นอกจากนี้แรงจูงใจในการสร้างคลาส / คลาสอินสแตนซ์ของฉันไม่ได้เกี่ยวกับการบังคับใช้ข้อกำหนดแบบซิงเกิล นอกจากนี้ยังไม่มากนักเกี่ยวกับการสร้างประเภทใหม่ แรงจูงใจคือการจัดกลุ่มรหัสและข้อมูลที่เกี่ยวข้องและมีส่วนต่อประสานกับมัน นี่คือเหตุผลที่ฉันเริ่มต้นแบบเป็นคลาสในแผนภาพคลาส เมื่อพูดถึงการนำไปใช้ฉันเริ่มสงสัยว่าจะยกตัวอย่างชั้นเรียนนี้หรือไม่

11 design  object-oriented  python  object-oriented-design  class-design 

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

11 java  design  artificial-intelligence 

โปรดพิจารณาคลาสนี้: class ClassA{ private Thing[] things; // stores data // stuff omitted public Thing[] getThings(){ return things; } } คลาสนี้จะเปิดเผยอาร์เรย์ที่ใช้ในการจัดเก็บข้อมูลรหัสลูกค้าใด ๆ ที่สนใจ ฉันทำสิ่งนี้ในแอปที่ฉันทำงานอยู่ ฉันมีChordProgressionคลาสที่เก็บลำดับของChords (และทำสิ่งอื่น) มันมีChord[] getChords()วิธีที่คืนค่าอาร์เรย์ของคอร์ด เมื่อโครงสร้างข้อมูลต้องเปลี่ยน (จากอาร์เรย์เป็น ArrayList) รหัสไคลเอ็นต์ทั้งหมดจะพัง นี่ทำให้ฉันคิดว่า - วิธีต่อไปนี้อาจจะดีกว่า: class ClassA{ private Thing[] things; // stores data // stuff omitted public Thing[] getThing(int index){ return …

11 design  object-oriented  encapsulation 

นี่เป็นคำถามที่ค่อนข้างคลุมเครือ แต่เป็นสิ่งที่ฉันไม่เคยรู้สึกว่าได้รับคำตอบอย่างน่าพอใจเมื่ออ่านเกี่ยวกับการออกแบบที่เหมาะสม โดยทั่วไปเมื่อเรียนรู้เกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ, นามธรรม, แยกตัวประกอบ ฯลฯ จอกศักดิ์สิทธิ์ของการออกแบบ - และเหตุผลที่พวกเขาอ้างเสมอว่าคุณใช้เทคนิคการพัฒนาที่เป็นปัญหา - คือมันจะทำให้โปรแกรมของคุณ "ง่ายต่อการเปลี่ยนแปลง" , "maintainable", "ยืดหยุ่น" หรือคำพ้องความหมายใด ๆ ที่ใช้เพื่อแสดงแนวคิดเกี่ยวกับการผลิตที่ทำให้เกิดเสียงดังกล่าว ด้วยการทำเครื่องหมายส่วนตัวของ ivars ให้แยกรหัสออกเป็นวิธีเล็ก ๆ ที่มีอยู่ในตัวเองทำให้อินเตอร์เฟสทั่วไปทำให้คุณสามารถปรับเปลี่ยนโปรแกรมของคุณได้อย่างง่ายดาย สำหรับการเปลี่ยนแปลงที่ค่อนข้างเล็กสิ่งนี้ใช้ได้ดีสำหรับฉัน การเปลี่ยนแปลงโครงสร้างข้อมูลภายในที่ใช้โดยคลาสเพื่อเพิ่มประสิทธิภาพไม่เคยมีความยุ่งยากที่สำคัญและไม่มีการเปลี่ยนแปลงส่วนท้ายของส่วนต่อประสานผู้ใช้ที่เป็นอิสระจาก API เช่นการออกแบบระบบป้อนข้อความใหม่หรือปรับปรุงกราฟิกสำหรับองค์ประกอบการเล่นเกม . การเปลี่ยนแปลงทั้งหมดเหล่านี้ดูเหมือนมีอยู่ในตัวเองโดยเนื้อแท้ ไม่มีสิ่งใดที่เกี่ยวข้องกับการเปลี่ยนแปลงพฤติกรรมหรือการออกแบบองค์ประกอบของโปรแกรมของคุณที่ได้รับการแก้ไขตราบใดที่รหัสภายนอกเกี่ยวข้อง ไม่ว่าคุณจะเขียนขั้นตอนหรือในสไตล์ OO ที่มีฟังก์ชั่นขนาดใหญ่หรือขนาดเล็กการเปลี่ยนแปลงเหล่านี้ง่ายต่อการเปลี่ยนแปลงแม้ว่าคุณจะมีการออกแบบที่ดีพอสมควรก็ตาม อย่างไรก็ตามเมื่อใดก็ตามที่การเปลี่ยนแปลงมีขนาดใหญ่และมีขนฟูนั่นคือการเปลี่ยนแปลง API - ไม่มีรูปแบบ "อันมีค่า" ของฉันเลยที่จะช่วยเหลือ การเปลี่ยนแปลงครั้งใหญ่ยังคงใหญ่รหัสที่ได้รับผลกระทบยังคงได้รับผลกระทบและงานการวางไข่หลายชั่วโมงอยู่ข้างหน้าฉัน ดังนั้นคำถามของฉันคือสิ่งนี้ การออกแบบที่เหมาะสมนั้นมีการเปลี่ยนแปลงขนาดใหญ่เพียงใดเพื่อให้สามารถอำนวยความสะดวกได้? มีเทคนิคการออกแบบเพิ่มเติมบางอย่างไม่เป็นที่รู้จักสำหรับฉันหรือฉันล้มเหลวในการใช้งานที่ทำให้การปรับเปลี่ยนที่ทำให้เกิดเสียงง่าย ๆ หรือเป็นสัญญานั้น (ซึ่งฉันได้ยินจากกระบวนทัศน์ที่แตกต่างกันมากมาย) เป็นแนวคิดที่ดี ตัดการเชื่อมต่ออย่างสมบูรณ์จากความจริงที่ไม่เปลี่ยนรูปแบบของการพัฒนาซอฟต์แวร์? มี "เครื่องมือเปลี่ยน" …

11 design  object-oriented  maintenance  abstraction  changes 

หากเราสมมติว่ามันไม่เป็นที่พึงปรารถนาสำหรับคลาสฐานที่จะเป็นคลาสอินเตอร์เฟสที่บริสุทธิ์และใช้ 2 ตัวอย่างจากด้านล่างซึ่งเป็นวิธีที่ดีกว่าโดยใช้คำนิยามคลาสของวิธีนามธรรมหรือเสมือน? ข้อได้เปรียบของเวอร์ชั่น "นามธรรม" คือมันอาจดูสะอาดและบังคับให้คลาสที่ได้รับมาเพื่อให้การใช้งานมีความหมายอย่างมีความหวัง ข้อได้เปรียบของเวอร์ชัน "เวอร์ชวล" คือสามารถดึงโมดูลได้ง่ายและใช้สำหรับการทดสอบโดยไม่ต้องเพิ่มเฟรมพื้นฐานมากมายเหมือนเวอร์ชั่นนามธรรมที่ต้องการ เวอร์ชั่นบทคัดย่อ: public abstract class AbstractVersion { public abstract ReturnType Method1(); public abstract ReturnType Method2(); . . public abstract ReturnType MethodN(); ////////////////////////////////////////////// // Other class implementation stuff is here ////////////////////////////////////////////// } รุ่นเสมือน: public class VirtualVersion { public virtual ReturnType Method1() { return …

11 c#  design 

ฉันมีการใช้รูปแบบคำสั่งเก่านี้ เป็นการผ่านบริบทผ่านการใช้งานDIOperationทั้งหมดแต่ฉันรู้ในภายหลังในกระบวนการเรียนรู้และการเรียนรู้ (ที่ไม่เคยหยุดนิ่ง) นั่นไม่เหมาะสม ฉันยังคิดว่า "การเยี่ยมชม" ที่นี่ไม่เหมาะและสับสนจริงๆ จริง ๆ แล้วฉันกำลังคิดที่จะเปลี่ยนรหัสของฉันอีกครั้งเนื่องจากคำสั่งไม่ควรรู้อะไรเกี่ยวกับผู้อื่นและในขณะนี้พวกเขาทั้งหมดใช้คู่ค่าคีย์เดียวกัน มันยากที่จะรักษาคลาสที่เป็นเจ้าของคีย์ - ค่าซึ่งบางครั้งนำไปสู่ตัวแปรที่ซ้ำกัน ตัวอย่างกรณีการใช้งานสมมติว่าCommandBต้องการชื่อผู้ใช้ที่CommandAกำหนดไว้ CommandA ควรตั้งค่าUserNameForCommandB = Johnหรือไม่ หรือพวกเขาควรแบ่งปันชื่อผู้ใช้ทั่วไป= John key-value หรือไม่ จะเกิดอะไรขึ้นหากชื่อผู้ใช้ถูกใช้โดยคำสั่งที่สาม ฉันจะปรับปรุงการออกแบบนี้ได้อย่างไร ขอบคุณ! class DIParameters { public: /** * Parameter setter. */ virtual void setParameter(std::string key, std::string value) = 0; /** * Parameter getter. */ virtual std::string getParameter(std::string …

11 c++  design-patterns  design 

เมื่อใช้ออบเจ็กต์ธุรกิจที่ใช้ซ้ำได้สิ่งที่ควรคำนึงถึงเป็นแนวปฏิบัติที่ดีที่สุดเมื่อสร้างมุมมองแบบจำลอง เราใช้วัตถุที่เราเรียกใช้Builderเพื่อสร้างแบบจำลองมุมมองของเรา ตัวสร้างหนึ่งสำหรับแต่ละหน่วยของมุมมองแบบลอจิคัล (คำสั่งผู้ใช้ ฯลฯ ) ซึ่งแต่ละหน่วยสามารถมีรูปแบบมุมมองที่แตกต่างกันจำนวนหนึ่ง (คำสั่งซื้อประกอบด้วยข้อมูลสรุปบรรทัดคำสั่งและอื่น ๆ ) ผู้สร้างอาจดึงข้อมูลผ่านวัตถุทางธุรกิจมาตรฐานหนึ่งรายการขึ้นไปเพื่อสร้างแบบจำลองมุมมอง อะไรคือการปฏิบัติที่ดีขึ้นเมื่อพูดถึงการใช้อ็อบเจกต์ธุรกิจ / โมเดลในโมเดลที่มีมุมมอง? วิธีที่ 1 อนุญาตให้ใช้วัตถุธุรกิจในโมเดลมุมมองหรือไม่ //Business object in some library public class Order { public int OrderNum; public int NumOrderLines; //... } //Order builder in website public class OrderBuilder { public OrderSummary BuildSummaryForOrder(int OrderNum) { Some.Business.Logic.Order obOrder = …

11 design  development-approach 

นี่คือคำถามที่เกี่ยวข้อง: ในที่สุดการใช้ประโยคในการทำงานหลังจากกลับมาในสไตล์ที่ไม่ดี / เป็นอันตรายหรือไม่? ใน Q อ้างอิงแล้วรหัสสุดท้ายเกี่ยวข้องกับโครงสร้างที่ใช้และความจำเป็นในการดึงข้อมูลล่วงหน้า คำถามของฉันแตกต่างออกไปเล็กน้อยและฉันเชื่อว่ามันเป็นสิ่งที่ดีสำหรับผู้ชมที่กว้างขึ้น ตัวอย่างเฉพาะของฉันคือแอป C # winform แต่สิ่งนี้จะใช้กับ C ++ / Java ในที่สุดการใช้งานเช่นกัน ฉันสังเกตเห็นว่ามีการลองจับสองสามครั้งในที่สุดซึ่งมีโค้ดจำนวนมากที่ไม่เกี่ยวข้องกับข้อยกเว้นและการจัดการ / ล้างข้อมูลที่ฝังอยู่ภายในบล็อก และฉันจะยอมรับความลำเอียงของฉันต่อการพยายามบล็อกที่จับได้แน่นในที่สุดด้วยรหัสที่เกี่ยวข้องกับข้อยกเว้นและการจัดการอย่างใกล้ชิด นี่คือตัวอย่างของสิ่งที่ฉันเห็น ลองบล็อกจะมีการโทรขั้นต้นจำนวนมากและตัวแปรที่ตั้งค่านำไปสู่รหัสที่สามารถโยนได้ ข้อมูลการบันทึกจะได้รับการตั้งค่าและเรียกใช้ในบล็อกลองด้วย ในที่สุดบล็อกจะมีการเรียกการจัดรูปแบบแบบฟอร์ม / โมดูล / การควบคุม (แม้แอพกำลังจะปิดตัวลงดังที่แสดงในบล็อก catch) รวมถึงการสร้างวัตถุใหม่เช่นแผงควบคุม ประมาณ: methodName (... ) { ลอง { // มีโค้ดสำหรับวิธีการมากมาย ... // รหัสที่สามารถส่ง ... // มีโค้ดมากขึ้นสำหรับวิธีการและการส่งคืน ... } …

11 design  exception-handling  coding-style 

Java ทำให้ความแตกต่างที่ชัดเจนระหว่างและclass interface(ฉันเชื่อว่า C # ทำเช่นนั้น แต่ฉันไม่มีประสบการณ์ด้วย) เมื่อเขียน C ++ อย่างไรก็ตามไม่มีภาษาบังคับให้แยกความแตกต่างระหว่างคลาสและส่วนต่อประสาน ดังนั้นฉันมักจะดูอินเตอร์เฟซเป็นวิธีแก้ปัญหาสำหรับการขาดการสืบทอดหลายใน Java การทำให้ความแตกต่างดังกล่าวให้ความรู้สึกโดยพลการและไร้ความหมายใน C ++ ฉันมักจะไปกับวิธีการ "เขียนสิ่งต่าง ๆ ในวิธีที่ชัดเจนที่สุด" ดังนั้นใน C ++ ฉันมีสิ่งที่เรียกว่าส่วนติดต่อใน Java เช่น: class Foo { public: virtual void doStuff() = 0; ~Foo() = 0; }; และฉันก็ตัดสินใจว่าผู้ดำเนินการส่วนใหญ่Fooต้องการแบ่งปันฟังก์ชั่นทั่วไปบางอย่างที่ฉันอาจจะเขียน: class Foo { public: virtual void doStuff() = 0; ~Foo() …

11 c++  design  terminology  interfaces 

ฉันอ่านข้อความในบล็อกเมื่อเช้านี้และพบสิ่งนี้ : ถ้าคลาสเดียวที่ใช้อินเทอร์เฟซลูกค้าคือ CustomerImpl คุณไม่มีความหลากหลายและความสามารถในการสับเปลี่ยนได้จริง ๆ เนื่องจากไม่มีวิธีใดที่จะทดแทน runtime ได้เลย มันเป็นเรื่องธรรมดาทั่วไป นั่นเป็นเหตุผลสำหรับฉันเมื่อการใช้งานอินเทอร์เฟซเพิ่มความซับซ้อนและหากมีเพียงการใช้เพียงครั้งเดียวอย่างใดอย่างหนึ่งอาจยืนยันว่ามันเพิ่มความซับซ้อนที่ไม่จำเป็น การเขียนโค้ดที่มีความเป็นนามธรรมมากกว่าที่ควรจะเป็นมักจะถูกพิจารณาว่าเป็นกลิ่นของรหัสที่เรียกว่า "การเก็งกำไรทั่วไป" (หรือที่กล่าวถึงในโพสต์) แต่ถ้าฉันติดตาม TDD ฉันไม่สามารถสร้างการทดสอบเป็นสองเท่าได้อย่างง่ายดายโดยไม่ต้องคำนึงถึงการเก็งกำไรไม่ว่าจะอยู่ในรูปแบบของการใช้อินเทอร์เฟซหรือตัวเลือก polymorphic อื่น ๆ ของเรา ดังนั้นเราจะคืนดีการแลกเปลี่ยนนี้ได้อย่างไร มันคุ้มค่าหรือไม่ที่จะเป็นการเก็งกำไรโดยทั่วไปเพื่ออำนวยความสะดวกในการทดสอบ / TDD? หากคุณใช้การทดสอบเป็นสองเท่าให้นับเป็นการนำไปใช้ครั้งที่สองและทำให้ความคิดทั่วๆไปไม่เป็นการเก็งกำไรอีกต่อไป? คุณควรพิจารณากรอบการเยาะเย้ยเฮฟวี่เวทที่ช่วยให้ผู้เยาะเย้ยเป็นรูปธรรมมากขึ้น (เช่นโมลเทียบกับ Moq ใน C # โลก) หรือไม่ หรือคุณควรทดสอบกับชั้นเรียนที่เป็นรูปธรรมและเขียนสิ่งที่อาจพิจารณาว่าเป็นการทดสอบ "การรวม" จนกว่าจะถึงเวลาที่การออกแบบของคุณต้องมีความหลากหลาย ฉันอยากรู้อยากเห็นที่จะอ่านคนอื่นจะใช้เวลาในเรื่องนี้ - ขอบคุณล่วงหน้าสำหรับความคิดเห็นของคุณ

11 design  unit-testing  code-smell  polymorphism 

I ซึ่งเป็นโปรแกรมเมอร์ที่จำเป็นของ Java ต้องการที่จะเข้าใจวิธีการสร้าง Space Invaders แบบง่าย ๆ ตามหลักการออกแบบฟังก์ชั่น Programming (โดยเฉพาะ Referential Transparency) อย่างไรก็ตามในแต่ละครั้งที่ฉันลองนึกถึงการออกแบบฉันจะหลงทางในความแปรปรวนอย่างรุนแรงซึ่งเป็นความไม่แน่นอนที่เหมือนกันซึ่งเป็นที่รังเกียจของนักเขียนโปรแกรมการทำงาน เป็นความพยายามที่จะเรียนรู้หน้าที่ Programming ฉันตัดสินใจที่จะพยายามที่จะสร้างเกมแบบโต้ตอบ 2D ง่ายมากช่องว่าง Invader (หมายเหตุขาดพหูพจน์) ในScalaใช้lwjgl นี่คือข้อกำหนดสำหรับเกมพื้นฐาน: ผู้ใช้จัดส่งที่ด้านล่างของหน้าจอเลื่อนไปทางซ้ายและขวาด้วยปุ่ม "A" และ "D" ตามลำดับ กระสุนของผู้ใช้ยิงพุ่งขึ้นมาเปิดใช้งานโดยตรงโดยสเปซบาร์โดยมีการหยุดชั่วคราวอย่างน้อยระหว่างนัดเป็น 0.5 วินาที กระสุนของเรือรบต่างด้าวยิงตรงลงโดยใช้เวลาสุ่ม 0.5 ถึง 1.5 วินาทีระหว่างการยิง สิ่งที่จงใจทิ้งไว้จากเกมดั้งเดิมคือเอเลี่ยนของ WxH อุปสรรคในการป้องกันที่ย่อยสลายได้ x3 จานรองความเร็วสูงที่ด้านบนของหน้าจอ ตกลงไปยังโดเมนปัญหาจริงแล้ว สำหรับฉันทุกส่วนที่กำหนดไว้ชัดเจน มันเป็นชิ้นส่วนที่ไม่สามารถกำหนดได้ซึ่งดูเหมือนจะปิดกั้นความสามารถของฉันในการพิจารณาวิธีการเข้าถึง ส่วนที่กำหนดขึ้นมานั้นเป็นวิถีกระสุนของกระสุนทันทีที่มีการเคลื่อนไหวอย่างต่อเนื่องของเอเลี่ยนและการระเบิดเนื่องจากการชนทั้งสอง (หรือทั้งสองอย่าง) ของเรือของผู้เล่นหรือมนุษย์ต่างดาว ชิ้นส่วนที่ไม่สามารถกำหนดค่าได้ (สำหรับฉัน) กำลังจัดการสตรีมอินพุตของผู้ใช้การจัดการดึงค่าสุ่มสำหรับการกำหนดกระสุนไฟเอเลี่ยนและการจัดการเอาต์พุต …

11 design  functional-programming  game-development  scala 

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

11 design  design-patterns  coding-style  single-responsibility 

ขณะที่ฉันอ่านโพสต์บล็อกที่โด่งดังของ Martin Fowler Is Design Dead? หนึ่งในความประทับใจที่น่าประทับใจที่ฉันได้รับคือความจริงที่ว่าใน Agile Methodology และ Extreme Programming การออกแบบและการเขียนโปรแกรมนั้นเป็นวิวัฒนาการ อาจเป็นไปได้ว่าเมื่อระดับโปรแกรมเมอร์ดีและพวกเขาเข้าใจความหมายของการออกแบบและไม่ทำผิดพลาดร้ายแรงรหัสจะยังคงพัฒนาต่อไป อย่างไรก็ตามในบริบทปกติสิ่งที่เป็นจริงในบริบทนี้คืออะไร? ในวันปกติเมื่อมีการพัฒนาที่สำคัญเกิดขึ้นกับผลิตภัณฑ์และเมื่อการเปลี่ยนแปลงที่สำคัญเกิดขึ้นตามความต้องการมันไม่ได้เป็นข้อ จำกัด ที่เราต้องการมากเพียงใดด้านการออกแบบขั้นพื้นฐานไม่สามารถแก้ไขได้? (โดยไม่ทิ้งส่วนสำคัญของรหัส) ไม่น่าเป็นไปได้หรือที่คนเราจะถึงจุดจบในการปรับปรุงการออกแบบและความต้องการที่เป็นไปได้อีกต่อไป? ฉันไม่ได้สนับสนุนการปฏิบัติที่ไม่ใช่แบบ Agileที่นี่ แต่ฉันต้องการทราบจากผู้ที่ฝึกฝนวิธีการพัฒนาแบบว่องไวหรือวนซ้ำหรือแบบวิวัฒนาการเพื่อประสบการณ์ที่แท้จริงของพวกเขา คุณเคยไปถึงจุดจบแล้วหรือยัง? คุณมีวิธีจัดการเพื่อหลีกเลี่ยงหรือหนีออกมาได้อย่างไร? หรือมีมาตรการเพื่อให้แน่ใจว่าการออกแบบยังคงสะอาดและยืดหยุ่นตามที่วิวัฒนาการ

11 design  agile 

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

11 design  uml  multithreading