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

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

22 design  architecture  dynamic-typing  static-typing 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิด 6 ปีที่ผ่านมา มุมมองโปรเฟสเซอร์ของโปรแกรมเมอร์ไม่สามารถทำกราฟิกได้ดีนักจากสิ่งที่ฉันได้อ่านและเห็น อย่างไรก็ตามฉันรักการเขียนโปรแกรม (โดยเฉพาะอย่างยิ่ง OOP, PHP, C ++, Objective-C) และไม่สามารถปฏิเสธความจริงที่ว่าฉันมีรสนิยมที่เป็นเอกลักษณ์ในการออกแบบเว็บและคนอื่น ๆ ก็บอกว่าฉันทำได้ดี (CSS) ฉันคิดกับตัวเองว่า "เฮ้เดี๋ยวก่อนฉันเป็นโปรแกรมเมอร์ฉันจะออกแบบให้ดีได้อย่างไร" คำถามคือสามารถเขียนโปรแกรมและออกแบบได้ดีหรือไม่? ใครที่นี่รู้สึกเหมือนกันไหม สำหรับบันทึก: ภาพจริงที่ฉันสร้างขึ้นถูกเรียกว่าโปรแกรมเมอร์ศิลปะหลายครั้งก่อนหน้านี้โดยเพื่อน

22 design  stereotypes 

Pseudocode ช่วยให้เราเข้าใจงานในลักษณะที่ไม่เชื่อเรื่องภาษา มันเป็นการปฏิบัติที่ดีที่สุดหรือแนวทางที่แนะนำให้มีการสร้างรหัสเทียมเป็นส่วนหนึ่งของวงจรการพัฒนาหรือไม่? ตัวอย่างเช่น ระบุและแยกงานการเข้ารหัส เขียน pseudocode รับการอนุมัติ [โดย PL หรือ TL] เริ่มการเข้ารหัสตาม Pseudocode นี่เป็นแนวทางที่แนะนำหรือไม่ มีการฝึกฝนในอุตสาหกรรมหรือไม่?

22 design  pseudocode 

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

22 design  design-patterns  object-oriented 

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

22 design  rest  xml  microservices 

ในหนังสือการออกแบบที่แตกต่างกันที่ฉันอ่านบางครั้งการเน้นอย่างมากถูกวางลงบนจำนวนวิธีที่ชั้นเรียนต้องมี (พิจารณาจากภาษา OO เช่น java หรือ C # เป็นต้น) บ่อยครั้งที่ตัวอย่างที่รายงานในหนังสือเหล่านี้มีความประณีตและเรียบง่าย แต่แทบจะไม่ครอบคลุมกรณีที่ "ร้ายแรง" หรือซับซ้อน อย่างไรก็ตามช่วงนี้ดูเหมือนจะอยู่ระหว่าง 5 ถึง 8 ในโครงการฉันได้พัฒนาคลาส "Note" โดยมีคุณสมบัติเป็น attribuse: Title, Desctiption, CreateDate เป็นต้นจากนั้นมีวิธีการพื้นฐานเช่น: getRelations (ถ้าบันทึกถูกกำหนดให้กับเอกสารต่าง ๆ ), getExpiryDate, ect อย่างไรก็ตามการดำเนินการในการพัฒนาแอปพลิเคชันจำเป็นต้องมีฟังก์ชันการทำงานที่มากขึ้นและดังนั้นจึงมีวิธีการมากขึ้น ฉันรู้ว่าชั้นเรียนมีวิธีการน้อยกว่า นี่เป็นข้อได้เปรียบที่ดีในแง่ของความเป็นโมดูลและการนำกลับมาใช้ใหม่รวมถึงการแก้ไขที่ง่ายขึ้น โดยวิธีการถ้าในบริบทของเราไม่มีความต้องการ (หรือแม้กระทั่งความรู้สึก) ในการสร้างคลาสย่อยและฟังก์ชั่นที่จำเป็นทั้งหมดเกี่ยวข้องกับคลาสนั้นเราสามารถแนบวิธีการได้อีกกี่วิธี ฉันยอมรับว่ามีมากกว่า 15 วิธีจากนั้นอาจต้องมีการออกแบบใหม่เล็กน้อย แต่แม้ในกรณีนั้นหากการลบวิธีการหรือมรดกบางอย่างไม่ใช่ตัวเลือกซึ่งจะเป็นวิธีที่เหมาะสมหรือไม่

22 design  programming-practices 

ฉันกำลังสร้างเว็บแอปพลิเคชันธุรกิจใหม่และฉันต้องการบรรลุ: ใช้เทคโนโลยีที่ดีที่สุดจากอาณาจักรที่เกี่ยวข้อง ฉันต้องการกรอบแบ็กเอนด์ที่เชื่อถือได้ด้วย ORM ที่มั่นคง และฉันต้องการเฟรมเวิร์ก SPA (แอปพลิเคชันหน้าเดียว) ที่ทันสมัยที่สุดด้วยการใช้คุณสมบัติ HTML และ Javascript ล่าสุดสำหรับแอปพลิเคชันส่วนหน้า เปิดเผยเอนทิตีแบ็กเอนด์และบริการธุรกิจสำหรับการใช้งานจากแอพพลิเคชั่นประเภทต่าง ๆ เช่นเว็บแอพพลิเคชั่นมือถือ (Android) และประเภทอื่น ๆ (อุปกรณ์สมาร์ทเป็นต้น) ดังนั้น - เพื่อตอบสนองความต้องการทั้งสองอย่างฉันมีแนวโน้มที่จะแยกแอปพลิเคชันของฉันออกอย่างสมบูรณ์ในแอปพลิเคชันส่วนหลังและส่วนหน้าและจัดการการสื่อสารระหว่างกันโดยใช้ REST API (JSON) เสียงนี้เข้าใกล้หรือไม่? การแยกดังกล่าวไม่ใช่โซลูชันการออกแบบที่ชัดเจนเนื่องจากเทคโนโลยีเว็บแอปพลิเคชันจำนวนมากได้รวมเลเยอร์มุมมองไว้ซึ่งแอปพลิเคชันฝั่งเซิร์ฟเวอร์จะควบคุมการสร้างมุมมองมากขึ้นหรือน้อยลงและจัดการการตอบสนองจากมุมมองบางส่วน layer, Java JSF / Facelets จะบันทึกสถานะของส่วนประกอบบนเซิร์ฟเวอร์อย่างสมบูรณ์) ดังนั้น - มีเทคโนโลยีมากมายที่เสนอการมีเพศสัมพันธ์ที่แข็งแกร่งมากขึ้นและให้สัญญาว่าจะพัฒนาได้เร็วขึ้นและมีเส้นทางการเดินทางที่เป็นมาตรฐานมากขึ้น ดังนั้น - ฉันต้องระวังเมื่อเริ่มใช้เทคโนโลยีในลักษณะที่ไม่ได้ใช้กันอย่างแพร่หลาย ตามที่ฉันเข้าใจแล้วส่วนหน้าของ SPA ที่แยกจากกันอย่างสมบูรณ์มักเกิดจากความจำเป็นในการใช้ API ของบุคคลที่สาม แต่การออกแบบเสียง decoupling ดังกล่าวเมื่อทั้งสองแบ็กเอนด์และส่วนหน้าได้รับการพัฒนาโดย บริษัท หนึ่ง? …

21 design  rest  api  front-end  backend 

ฉันกำลังทำงานในโครงการที่ประมวลผลคำขอและมีสององค์ประกอบในการร้องขอคือคำสั่งและพารามิเตอร์ ตัวจัดการสำหรับแต่ละคำสั่งนั้นง่ายมาก (<10 บรรทัดมัก <5) มีคำสั่งอย่างน้อย 20 คำและน่าจะมีมากกว่า 50 คำสั่ง ฉันคิดวิธีแก้ปัญหาสองสามข้อ: สวิตช์ใหญ่ / if-else หนึ่งคำสั่ง แผนที่ของคำสั่งไปยังฟังก์ชั่น แผนที่ของคำสั่งไปยังคลาสที่คงที่ / singletons แต่ละคำสั่งทำการตรวจสอบข้อผิดพลาดเล็กน้อยและบิตเดียวที่สามารถแยกออกได้คือการตรวจสอบจำนวนพารามิเตอร์ที่กำหนดไว้สำหรับแต่ละคำสั่ง อะไรจะเป็นทางออกที่ดีที่สุดสำหรับปัญหานี้และเพราะอะไร ฉันยังเปิดรับรูปแบบการออกแบบใด ๆ ที่ฉันอาจพลาดไป ฉันคิดรายการ pro / con ต่อไปนี้สำหรับแต่ละรายการ: สวิตซ์ ข้อดี เก็บคำสั่งทั้งหมดไว้ในฟังก์ชันเดียว เนื่องจากมันเรียบง่ายนี่ทำให้เป็นตารางการค้นหาด้วยภาพ ไม่ต้องวุ่นวายกับแหล่งข้อมูลด้วยฟังก์ชั่นขนาดเล็กจำนวนมาก / คลาสที่สามารถใช้งานได้ในที่เดียว ข้อเสีย นานมาก ยากที่จะเพิ่มคำสั่งโดยทางโปรแกรม (จำเป็นต้องโยงใช้ตัวพิมพ์เล็ก) คำสั่งแผนที่ -> ฟังก์ชั่น ข้อดี ชิ้นเล็กขนาดกัด สามารถเพิ่ม / ลบคำสั่งโดยทางโปรแกรม ข้อเสีย หากทำแบบอินไลน์เหมือนกับสวิตช์ …

21 design  design-patterns  map  switch-statement 

หลังจากใช้ Hibernate ในโครงการส่วนใหญ่ของฉันเป็นเวลาประมาณ 8 ปีฉันได้ตกลงกับ บริษัท ที่ไม่สนับสนุนการใช้งานและต้องการให้แอปพลิเคชันโต้ตอบกับ DB ผ่านขั้นตอนการจัดเก็บเท่านั้น หลังจากทำสิ่งนี้สองสามสัปดาห์ฉันก็ไม่สามารถสร้างรูปแบบโดเมนที่หลากหลายของแอปพลิเคชันที่ฉันเริ่มสร้างได้และแอปพลิเคชันก็ดูเหมือนสคริปต์ธุรกรรมที่น่ากลัว ปัญหาบางอย่างที่ฉันพบคือ: ไม่สามารถนำทางกราฟวัตถุในขณะที่ขั้นตอนการจัดเก็บเพียงแค่โหลดข้อมูลขั้นต่ำซึ่งหมายความว่าบางครั้งเรามีวัตถุที่คล้ายกันที่มีเขตข้อมูลที่แตกต่างกัน ตัวอย่างหนึ่งคือ: เรามีขั้นตอนการจัดเก็บเพื่อดึงข้อมูลทั้งหมดจากลูกค้าและอีกวิธีหนึ่งในการดึงข้อมูลบัญชีรวมทั้งสองสามช่องจากลูกค้า ตรรกะจำนวนมากจบลงในคลาสตัวช่วยดังนั้นโค้ดจึงมีโครงสร้างมากขึ้น (โดยใช้เอนทิตีที่ใช้เป็นโครงสร้าง C แบบเก่า) โค้ดนั่งร้านน่าเบื่อมากขึ้นเนื่องจากไม่มีกรอบที่แยกชุดผลลัพธ์จากกระบวนงานที่เก็บไว้และวางไว้ในเอนทิตี คำถามของฉันคือ: มีใครอยู่ในสถานการณ์ที่คล้ายกันและไม่เห็นด้วยกับวิธีการจัดเก็บ? คุณทำอะไรลงไป? มีประโยชน์จริง ๆ ของการใช้กระบวนงานที่เก็บไว้หรือไม่ นอกเหนือจากจุดที่ไร้สาระของ "ไม่มีใครสามารถออกตารางลดลง" มีวิธีการสร้างโดเมนที่หลากหลายโดยใช้ขั้นตอนการจัดเก็บหรือไม่? ฉันรู้ว่ามีความเป็นไปได้ที่จะใช้ AOP ในการฉีด DAOs / ที่เก็บข้อมูลลงในเอนทิตีเพื่อให้สามารถนำทางกราฟวัตถุ ฉันไม่ชอบตัวเลือกนี้เนื่องจากอยู่ใกล้กับวูดู ข้อสรุป ก่อนอื่นขอบคุณทุกคำตอบของคุณ บทสรุปที่ฉันได้มาคือ ORM ไม่สามารถเปิดใช้งานการสร้างโมเดล Rich Domain (ตามที่บางคนกล่าวถึง) แต่มันทำให้การทำงานง่ายขึ้น ต่อไปนี้เป็นคำอธิบายโดยละเอียดเพิ่มเติมของข้อสรุป แต่ไม่ได้อยู่บนพื้นฐานของข้อมูลที่ยาก แอปพลิเคชันส่วนใหญ่ร้องขอและส่งข้อมูลไปยังระบบอื่น ในการทำสิ่งนี้เราสร้างสิ่งที่เป็นนามธรรมในเงื่อนไขของแบบจำลอง (เช่นเหตุการณ์ทางธุรกิจ) และโมเดลของโดเมนจะส่งหรือรับเหตุการณ์ …

21 java  design  orm  stored-procedures  domain-driven-design 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 8 ปีที่ผ่านมา ฉันพบว่าตัวเองกำลังดิ้นรนเพื่อดูว่าหลักการนี้เกี่ยวกับอะไรและทำไมจึงเป็นสิ่งสำคัญสำหรับการออกแบบภาษา โดยพื้นฐานแล้วกล่าวว่าสำหรับทุกการแสดงออกexprในภาษาควรตรงกับโครงสร้างนี้: (function () { return expr; })() นอกจากนี้ฉันเคยได้ยินว่าทับทิมปฏิบัติตามหลักการนี้ในขณะที่งูใหญ่ไม่ ฉันไม่เข้าใจว่าทำไมสิ่งนี้ถึงเป็นจริงหรือถ้ามันเป็นเรื่องจริง

21 design  language-agnostic 

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

21 design  refactoring  terminology 

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

21 design  database 

ผมเคยอ่านค่อนข้างมากเกี่ยวกับเรื่องนี้ในอดีตและเฝ้าดูการเจรจาที่น่าสนใจบางเช่นเดียวจากนี้ลุงบ๊อบ ถึงกระนั้นฉันมักจะพบว่ามันยากที่จะออกแบบสก์ท็อปของฉันอย่างถูกต้องและแยกแยะความแตกต่างซึ่งควรเป็นความรับผิดชอบในด้านUIและสิ่งที่อยู่ในด้านตรรกะ สรุปโดยย่อเกี่ยวกับแนวทางปฏิบัติที่ดีคือสิ่งนี้ คุณควรออกแบบตรรกะของคุณแยกจาก UI ดังนั้นวิธีที่คุณสามารถใช้ (ในทางทฤษฎี) ไลบรารีของคุณไม่ว่าจะเป็นแบ็กเอนด์ / UI ใด ๆ สิ่งนี้หมายความว่าโดยพื้นฐานแล้ว UI ควรเป็นคนโง่ที่สุดและควรทำการประมวลผลอย่างหนักที่ด้านตรรกะ ถ้าอย่างนั้นฉันก็สามารถใช้ไลบรารี่ที่สวยงามของฉันกับแอพพลิเคชั่นคอนโซลเว็บแอพพลิเคชั่น นอกจากนี้ลุงบ๊อบแนะนำการอภิปรายที่แตกต่างกันของเทคโนโลยีที่ใช้จะให้ประโยชน์มากมาย (อินเทอร์เฟซที่ดี) แนวคิดการชะลอตัวนี้ช่วยให้คุณมีเอนทิตี้ที่ผ่านการทดสอบอย่างดีซึ่งฟังดูดี แต่ก็ยังยุ่งยาก ดังนั้นฉันรู้ว่าคำถามนี้เป็นคำถามที่ค่อนข้างกว้างขวางซึ่งมีการพูดคุยกันหลายครั้งผ่านอินเทอร์เน็ตทั้งหมดและในหนังสือที่ดีมากมาย ดังนั้นเพื่อให้ได้สิ่งที่ดีออกมาฉันจะโพสต์ตัวอย่างตัวอย่างเล็ก ๆ น้อย ๆ ที่พยายามใช้ MCV บน pyqt: import sys import os import random from PyQt5 import QtWidgets from PyQt5 import QtGui from PyQt5 import QtCore random.seed(1) class Model(QtCore.QObject): …

20 design  python  mvc  gui  coupling 

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

20 design  architecture  uml  modeling 

ฉันกำลังใช้บอต IRC ที่ได้รับข้อความและฉันกำลังตรวจสอบข้อความนั้นเพื่อพิจารณาว่าจะเรียกใช้ฟังก์ชันใด มีวิธีที่ฉลาดกว่านี้ในการทำเช่นนี้? ดูเหมือนว่ามันจะออกจากมือได้อย่างรวดเร็วหลังจากที่ฉันได้รับคำสั่งถึง 20 คำสั่ง บางทีอาจมีวิธีที่ดีกว่าที่จะสรุปสิ่งนี้ใช่ไหม public void onMessage(String channel, String sender, String login, String hostname, String message){ if (message.equalsIgnoreCase(".np")){ // TODO: Use Last.fm API to find the now playing } else if (message.toLowerCase().startsWith(".register")) { cmd.registerLastNick(channel, sender, message); } else if (message.toLowerCase().startsWith("give us a countdown")) { cmd.countdown(channel, message); …

20 java  design  abstraction