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

ทุกครั้งที่มีคนมาถึงฉันและขอให้ฉันกำหนด Dependency Injection ตามแนวคิดและอธิบายข้อดีข้อเสียของการใช้ DI ในการออกแบบซอฟต์แวร์ ฉันยอมรับว่าฉันมีปัญหาในการอธิบายแนวคิดของ DI ทุกครั้งที่ฉันต้องบอกพวกเขาเกี่ยวกับประวัติศาสตร์เกี่ยวกับหลักการความรับผิดชอบเดียวองค์ประกอบการสืบทอด ฯลฯ ใครสามารถช่วยฉันอธิบายวิธีที่ดีที่สุดในการอธิบาย DI สำหรับนักพัฒนา

10 design  design-patterns  software 

ฉันได้ยินวลีที่ถูกโยนและฉันมีข้อโต้แย้งที่ฟังดูบ้าอย่างสมบูรณ์ (ขออภัยถ้าฉันกำลังทำฟางอยู่ที่นี่ไม่ใช่ความตั้งใจของฉัน) โดยทั่วไปจะมีบางอย่างตาม: คุณไม่ต้องการสร้างสิ่งที่เป็นนามธรรมก่อนที่คุณจะรู้ว่ากรณีทั่วไปคืออะไรมิฉะนั้น (1) คุณอาจวางสิ่งต่าง ๆ ในสิ่งที่เป็นนามธรรมของคุณหรือ (2) ไม่สนใจสิ่งที่มีความสำคัญ (1) สำหรับฉันนี่ดูเหมือนว่าโปรแกรมเมอร์ไม่ได้ใช้งานได้จริงพวกเขาได้ตั้งสมมติฐานว่าสิ่งต่าง ๆ จะมีอยู่ในโปรแกรมสุดท้ายที่ไม่ได้ทำงานดังนั้นพวกเขาจึงทำงานร่วมกับสิ่งที่เป็นนามธรรมในระดับต่ำปัญหาไม่ใช่ สิ่งที่เป็นนามธรรมก่อนวัยอันควร (2) การทิ้งสิ่งที่มีความสำคัญเป็นสิ่งหนึ่งอาจเป็นไปได้อย่างสิ้นเชิงที่บางสิ่งจะถูกตัดออกจากข้อมูลจำเพาะที่ในภายหลังกลายเป็นเรื่องสำคัญทางออกสำหรับสิ่งนี้ไม่ได้เกิดขึ้นกับการตัดสินใจของคุณและทรัพยากรเสียเปล่า เดาผิดก็เพื่อให้ได้ข้อมูลเพิ่มเติมจากลูกค้า เราควรทำงานจากนามธรรมลงไปถึงข้อตกลงเพราะนี่เป็นวิธีที่จริงจังที่สุดในการทำสิ่งต่าง ๆ และไม่ใช่วิธีอื่น ๆ ถ้าเราไม่ทำเช่นนั้นเราก็เสี่ยงต่อการเข้าใจผิดของลูกค้าและการสร้างสิ่งต่าง ๆ ที่จำเป็นต้องเปลี่ยน แต่ถ้าเราสร้างเพียงนามธรรมที่ลูกค้าได้กำหนดไว้ในภาษาของพวกเขาเองเราก็ไม่เคยตกอยู่ในความเสี่ยงนี้ ภาพหนึ่งในที่มืดโดยมีการสรุปบางอย่าง) ใช่เป็นไปได้ที่ลูกค้าจะเปลี่ยนใจเกี่ยวกับรายละเอียด แต่สิ่งที่พวกเขาเคยใช้ในการสื่อสารสิ่งที่พวกเขาต้องการมักจะยังคงใช้ได้ ต่อไปนี้เป็นตัวอย่างสมมติว่าลูกค้าต้องการให้คุณสร้างหุ่นยนต์ที่บรรจุถุง: public abstract class BaggingRobot() { private Collection<Item> items; public abstract void bag(Item item); } เรากำลังสร้างบางสิ่งจากนามธรรมที่ลูกค้าใช้โดยไม่ต้องลงรายละเอียดเพิ่มเติมกับสิ่งที่เราไม่รู้ นี่คือความยืดหยุ่นอย่างยิ่งฉันเห็นสิ่งนี้ถูกเรียกว่า "นามธรรมก่อนวัยอันควร" เมื่อในความเป็นจริงมันจะเร็วกว่าที่จะคิดว่าวิธีการบรรจุถุงถูกนำไปใช้อย่างไรพูดหลังจากพูดคุยกับลูกค้าที่พวกเขาต้องการ . เพื่ออัปเดตชั้นเรียนของฉันทั้งหมดที่ฉันต้องทำคือเปลี่ยนลายเซ็น …

10 design  design-patterns  object-oriented-design  development-process  abstraction 

ฉันต้องการสร้างระบบที่จัดการข้อความแจ้งเตือนจากโปรแกรมต่าง ๆ และสามารถประมวลผลการแจ้งเตือนเหล่านั้นไปยังผู้บริโภคที่ไม่ต้องการทางอีเมล ทั้งหมดนี้จะถูกเก็บไว้ในเครือข่ายภายในหนึ่งเครือข่าย ฉันคิดว่าฉันต้องการสถาปัตยกรรมพื้นฐานที่มีลักษณะเช่นนี้: ข้อกังวลหลักที่ฉันมีอยู่ในปัจจุบันคือบิต "ตัวจัดการข้อความ" ซึ่งเป็นสิ่งที่จะเป็น "sort-of-API" ของฉัน ฉันต้องการส่วนประกอบทั้งหมดของระบบนี้เพื่อส่งข้อมูลไปยัง API ซึ่งจัดการการเขียนทั้งหมดไปยังฐานข้อมูล ฉันคิดว่าวิธีนี้ง่ายกว่าเพราะมันช่วยลดความปลอดภัยและช่วยให้ฉันมีการสืบค้น DB ที่ซับซ้อนมากขึ้นในโปรแกรมเดียว ข้อกังวลคือฉันต้องการให้สิ่งนี้เป็นผู้ไม่เชื่อเรื่องภาษา - หมายความว่ารหัสใด ๆ ควรจะสามารถส่งข้อความไปยังตัวจัดการของฉัน - ซึ่งจะตีความพวกเขา ฉันหวังว่าจะทำสิ่งนี้ผ่านไฟล์แบน JSON - หรือผ่านการเรียกใช้ REST ไปยังโปรแกรม (ให้ความยืดหยุ่นกับแอพพลิเคชั่นดาวน์สตรีม) คำถามของฉันคือ - ฉันควรรบกวนตัวจัดการข้อความหรือไม่หรือจะเพิ่มความเรียบง่ายให้อนุญาตการเข้าถึงฐานข้อมูลโดยตรงไปยังแอพพลิเคชั่นดาวน์สตรีมรวมถึงส่วนประกอบอื่น ๆ สองตัว (Management Console และ Alert Manager) ด้วยวิธีนี้พวกเขาสามารถแทรกการแจ้งเตือนใดก็ได้ที่พวกเขาต้องการ - ตราบใดที่ INSERT ในตาราง DB / s นั้นถูกต้อง ฉันไม่ได้เป็นนักออกแบบซอฟต์แวร์โดยการค้าขอตัวฉัน …

10 design  design-patterns  architecture  api  api-design 

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

10 design  design-patterns  object-oriented  refactoring  clean-code 

ฉันได้อ่านบทความบทความและส่วน 4.1.4 ตอนที่ 4 ของคอมไพเลอร์: หลักการเทคนิคและเครื่องมือ (รุ่นที่ 2) (หรือที่รู้จักกันในชื่อ "The Dragon Book") ซึ่งทุกคนกล่าวถึงหัวข้อการกู้คืนข้อผิดพลาดทางไวยากรณ์ อย่างไรก็ตามหลังจากทดลองกับคอมไพเลอร์สมัยใหม่หลาย ๆ ตัวฉันได้เห็นแล้วว่าพวกเขากู้คืนจากข้อผิดพลาดทางความหมายเช่นเดียวกับข้อผิดพลาดทางไวยากรณ์ ฉันเข้าใจอัลกอริทึมและเทคนิคที่อยู่เบื้องหลังคอมไพเลอร์ที่กู้คืนจากข้อผิดพลาดเกี่ยวกับวากยสัมพันธ์ แต่ฉันไม่เข้าใจว่าคอมไพเลอร์สามารถกู้คืนจากข้อผิดพลาดทางความหมายได้อย่างไร ขณะนี้ฉันกำลังใช้รูปแบบผู้เยี่ยมชมที่แตกต่างกันเล็กน้อยเพื่อสร้างรหัสจากแผนผังไวยากรณ์นามธรรมของฉัน พิจารณาคอมไพเลอร์ของฉันรวบรวมการแสดงออกต่อไปนี้: 1 / (2 * (3 + "4")) คอมไพเลอร์จะสร้างแผนผังไวยากรณ์นามธรรมต่อไปนี้: op(/) | ------- / \ int(1) op(*) | ------- / \ int(2) op(+) | ------- / \ int(3) str(4) ขั้นตอนการสร้างรหัสจะใช้รูปแบบผู้เยี่ยมชมเพื่อสำรวจทรีไวยากรณ์แบบนามธรรมซ้ำ ๆ และดำเนินการตรวจสอบชนิด …

10 design  design-patterns  language-agnostic  type-systems 

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

10 design  object-oriented 

บทนำ เอ็นจิ้นการเรนเดอร์กราฟิกแบบเวกเตอร์หลายตัวมีข้อบกพร่องของอัลกอริทึมในตัว พวกมันแสดงรูปร่างแต่ละแบบแยกกันและ antialias โดยการคำนวณความครอบคลุมของพิกเซลแล้วประกอบมันไว้ที่ด้านบนของกันและกัน ใช่มันง่าย แต่การแก้ปัญหาที่ถูกต้องนั้นง่ายกว่า สิ่งนี้นำไปสู่ปัญหา conflation ในขณะที่ conflates ความคุ้มครองโดยความโปร่งใส การผสมอัลฟ่าเป็นไปตามกฎที่ไม่ได้เป็นตัวแทนของสถานการณ์อย่างถูกต้องตัวอย่างเช่นถ่ายภาพพิกเซลที่ครอบคลุม 50% ที่อยู่ใกล้เคียงกับพิกเซลที่ครอบคลุม 50% ไม่ได้จบลงด้วยการครอบคลุม 100% มันจบลงด้วยความครอบคลุม 75% . สิ่งที่ดูเหมือนจะขึ้นอยู่กับวิธีการปรับอัลกอริทึมและรายละเอียดอื่น ๆ แต่ในสาระสำคัญนี่เป็นข้อผิดพลาดที่ทราบ บางคนทำปัญหาการทำเอกสารข้อผิดพลาดของเครื่องยนต์แตกต่างกันไปรวมทั้งการเขียนบทความแสดงให้เห็นว่าสามารถทำได้ดีกว่า ภาพที่ 1 : ตัวอย่างที่ไม่ได้เป็นตัวแทนทั้งหมดของการเรนเดอร์รูปร่างที่ทำจากสามเหลี่ยมแสดงข้อผิดพลาดแบบขยายที่แถวบนสุด แหล่งที่มาของ SVG ปัญหามีวิธีแก้ปัญหาที่ไม่ยุ่งยากง่าย ๆ * เป็นเพียงตัวอย่างขั้นสูงโดยไม่ต้องคำนวณการครอบคลุมและกรองภาพลง เป็นโบนัสที่คุณจะได้ใช้อัลกอริธึมการสร้างภาพที่ดีกว่าการกรองแบบกล่อง (อ่านA Pixel ไม่ใช่สี่เหลี่ยมจัตุรัส3 ) มีแม้กระทั่งโซลูชันที่มีความเร็วเทียบเคียงได้กับโซลูชันปัจจุบันและวิธีแก้ปัญหาเหล่านี้ทำได้ง่ายกว่ามากในท่อส่งแรสเตอร์ฮาร์ดแวร์ นี่ไม่ใช่ปัญหาโดยไม่มีค่าใช้จ่าย มีหลายคนที่ทำงานด้านการออกแบบกราฟิกที่ใช้เวลาจำนวนเล็กน้อยในการพยายามหลีกเลี่ยงปัญหานี้ด้วยตนเองโดยทำให้แน่ใจว่ามีการทับซ้อนกันที่นี่และไม่มีการทับซ้อนกันเพื่อแก้ไขปัญหาที่คอมพิวเตอร์ควรทำเพื่อพวกเขา และล้มเหลวอย่างน่าทึ่งในหลายกรณี แต่ลูกค้าของพวกเขาไม่สนใจว่าทำไมข้อผิดพลาดอยู่ที่นั่นพวกเขาจะต้องแก้ไข คำถาม ข้อผิดพลาดเผยแพร่อย่างไร เนื่องจากพวกเขากำลังทำข้อผิดพลาดเดียวกันทั้งหมดจึงสามารถสรุปได้ว่าพวกเขาใช้แหล่งเดียวกันสำหรับอัลกอริทึมของพวกเขา สิ่งที่อาจทำให้นักออกแบบเลือกอัลกอริทึมนี้ เหตุใดโปรแกรมเมอร์ …

10 design  algorithms 

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

10 design  web-development  database  database-design 

พื้นหลัง ฉันกำลังทำงานกับแอพสำหรับลูกค้าที่มีคุณสมบัติเครือข่ายสังคมบางอย่าง ตอนแรกฉันพัฒนามือถือส่วนหน้า แต่สถานการณ์ก็ทำให้ฉันต้องรับผิดชอบด้านการพัฒนาด้านหลังเช่นกัน ในฐานะที่เป็นพื้นหลังทั่วไประบบของเราอนุญาตให้ผู้ใช้ติดตามผู้ใช้รายอื่นและรับการแจ้งเตือนเกี่ยวกับสิ่งที่พวกเขากำลังติดตามดังที่คุณคาดหวังจากเครือข่ายสังคมออนไลน์ ข้อแม้คือว่าจะมีเพียงผู้ใช้ชุดย่อยขนาดเล็ก (อย่างน้อยไม่กี่ร้อย) โดยมีความคาดหวังว่าฐานผู้ใช้ส่วนใหญ่จะติดตามบุคคลเหล่านี้อย่างน้อยหนึ่งคน ทางด้าน UI เราจะมีปุ่มแจ้งเตือนพร้อมตัวเลขและการคลิกปุ่มจะนำคุณไปยังหน้าจอการแจ้งเตือน ปัญหา ฉันค้นคว้ากลยุทธ์ในการใช้งานการแจ้งเตือนและทรัพยากรส่วนใหญ่ที่ฉันพบพบว่าสร้างตารางการแจ้งเตือนหนึ่งตารางขึ้นไปในฐานข้อมูล (ตัวอย่างที่ฉันชอบคือคำตอบที่ยอมรับได้ที่นี่: /programming/9735578/building-a-notification-system ) สิ่งที่ทิ้งฉันไปคือกลยุทธ์การขับเคลื่อนฐานข้อมูลส่วนใหญ่สำหรับการแจ้งเตือนจำเป็นต้องแทรกแถวสำหรับการแจ้งเตือนแต่ละรายการสำหรับผู้ติดตามแต่ละคน ดังนั้นหากคนนับพันติดตามแซลลี่เราจะแทรกหนึ่งพันแถวลงในตารางที่เกี่ยวข้อง ปรับขนาดได้หรือไม่ จะเกิดอะไรขึ้นถ้าเราไปถึงจุดที่ผู้ใช้หลายสิบหรือหลายแสนคนติดตาม Sally และเธอกำลังโพสต์ไม่กี่โหลต่อวัน แนวคิดดั้งเดิมของฉันคือการจัดการทุกอย่างด้วยข้อความค้นหา: หมายเลขบนปุ่มแจ้งเตือนจะได้รับโดยขอจำนวนแถวของเนื้อหาที่โพสต์เร็วกว่าครั้งล่าสุดที่คุณเยี่ยมชมหน้าจอการแจ้งเตือนในขณะที่การแจ้งเตือนแต่ละรายการจะถูกสร้างขึ้น เมื่อคุณเยี่ยมชมหน้าจอการแจ้งเตือน วิธีนี้จะไม่ต้องมีการเขียนหรือการเก็บข้อมูลเพิ่มเติม แต่ยืดหยุ่นและอาจค้อนเซิร์ฟเวอร์ค่อนข้างยาก ติดตั้ง แบ็กเอนด์ (ตามที่กำหนดโดยผู้พัฒนาก่อนหน้านี้) ใช้CodeIgniterและฐานข้อมูลMySQL ขณะนี้กำลังทำงานบนบัญชีโฮสติ้งที่ใช้ร่วมกันแบบเส็งเคร็ง GoDaddy แต่ฉันคิดว่า (หวังว่า) สิ่งนี้จะได้รับการอัปเกรดก่อนที่เราจะเข้าสู่การผลิตและแพ็คเกจโฮสติ้งจะถูกปรับสัดส่วนตามการเติบโตของผู้ใช้ ปัจจุบันส่วนหน้าของเราคือแอพมือถือ แต่เราวางแผนที่จะสร้างเว็บไซต์ในภายหลัง ฉันไม่ได้กังวลเกี่ยวกับการได้รับการอัพเดตแบบพุชแบบเรียลไทม์จากเซิร์ฟเวอร์เกี่ยวกับการแจ้งเตือน ภาคผนวก ฉันไม่เชี่ยวชาญในแบ็กเอนด์และฉันอยู่ในหัวของฉันในแผนกนั้น ลูกค้ารู้และฉันพยายามอย่างเต็มที่ที่จะอธิบายขอบเขตของโครงการในลักษณะนี้ แต่พวกเขาทำให้มันชัดเจนว่า ณ จุดนี้พวกเขาจะไม่ไว้ใจคนอื่นให้ทำงานในโครงการ เราอาจมีงานอีกเดือนที่ต้องทำก่อนที่จะเริ่มเพิ่มผู้ทดสอบและฉันจะได้รับการวัดประสิทธิภาพใด ๆ ฉันไม่สามารถประมาณจำนวนผู้ใช้ที่เราอาจมีหรือฮาร์ดแวร์ที่เราอาจจะเปิดตัวในอีก 5 ปีข้างหน้า …

10 design  php  mysql  social-networks 

ฉันคิดว่ามันปลอดภัยที่จะบอกว่าเว็บแอปพลิเคชั่นส่วนใหญ่มีพื้นฐานมาจากกระบวนทัศน์คำขอ / การตอบสนอง PHP ไม่เคยมีสิ่งที่เป็นนามธรรมของวัตถุเหล่านี้ กลุ่มหนึ่งพยายามแก้ไขสิ่งนี้: https://github.com/php-fig/fig-standards/blob/master/proposed/http-message.md อย่างไรก็ตามพวกเขาได้รับการติดตามด้านการเปลี่ยนแปลงไม่ได้ ในอีกด้านหนึ่งวัตถุขอ / ตอบสนองโดยทั่วไปต้องการการเปลี่ยนแปลงเพียงเล็กน้อยระหว่างวงจรชีวิตของพวกเขา ในทางกลับกันวัตถุตอบสนองโดยเฉพาะอย่างยิ่งมักจะต้องการส่วนหัว HTTP ที่จะเพิ่ม นอกจากนี้ความไม่สามารถเปลี่ยนแปลงได้นั้นไม่เคยเกิดขึ้นในดินแดนของ PHP ผู้คนเห็นประโยชน์อะไรในการใช้ออบเจ็กต์คำขอ / การตอบสนองที่ไม่เปลี่ยนแปลง สมมติว่าคุณส่งคืนวัตถุ json $response = new JsonResponse($item); ดีและเรียบง่าย แต่ปรากฎว่าการร้องขอนั้นเป็นการร้องขอ Cross-Origin Resource Sharing (CORS) รหัสที่สร้างการตอบสนองไม่ควรสนใจ แต่บางแห่งดาวน์สตรีมเป็นกระบวนการที่จะเพิ่มส่วนหัวควบคุมการเข้าถึงที่จำเป็น มีข้อได้เปรียบใด ๆ ในการรักษาการตอบกลับดั้งเดิมและสร้างขึ้นใหม่ด้วยส่วนหัวเพิ่มเติมหรือไม่ หรือเป็นคำถามเกี่ยวกับสไตล์การเขียนโปรแกรมอย่างเคร่งครัด วัตถุคำขอมีความน่าสนใจขึ้นอีกเล็กน้อย มันเริ่มต้นเหมือนกัน: $request = new Request('incoming request information including uri and headers'); ไม่จำเป็นต้องเปลี่ยนข้อมูลเริ่มต้น …

10 design  php  web-development  architecture 

พิจารณาสิ่งต่อไปนี้: def some_function(): return 1 def some_generator(): yield 1 ในรหัสข้างต้นsome_functionเป็นฟังก์ชั่นในขณะที่some_generatorเป็นเครื่องกำเนิดไฟฟ้า พวกมันดูคล้ายกันมาก ปัญหาที่ฉันมีเมื่ออ่านโค้ดคือฉันต้องสแกนผ่านทุกบรรทัดใน "ฟังก์ชั่น" เพื่อค้นหาyieldคำหลักก่อนที่ฉันจะสามารถตรวจสอบได้ว่ามันเป็นฟังก์ชั่นหรือเครื่องกำเนิดไฟฟ้าจริง ๆ ! สำหรับฉันดูเหมือนว่าการใช้คำหลักที่แตกต่างกันสำหรับเครื่องกำเนิดไฟฟ้าจะทำให้เข้าใจได้ง่ายขึ้นเช่น: gen some_generator(): yield 1 อะไรคือข้อดีของการใช้defคำหลักสำหรับเครื่องกำเนิดไฟฟ้าและฟังก์ชั่น? ทำไมคำหลักใหม่ไม่ได้ถูกนำมาใช้กับฟังก์ชั่นและเครื่องกำเนิดไฟฟ้าแยกกัน?

10 design  programming-languages  python 

พื้นหลัง: ฉันกำลังออกแบบแอปพลิเคชันเซิร์ฟเวอร์และสร้าง dll แยกต่างหากสำหรับระบบย่อยที่แตกต่างกัน เพื่อให้สิ่งต่าง ๆ ง่ายขึ้นสมมติว่าฉันมีระบบย่อยสองระบบ: 1) Users2)Projects ส่วนต่อประสานสาธารณะของผู้ใช้มีวิธีการดังนี้: IEnumerable<User> GetUser(int id); และส่วนต่อประสานสาธารณะของโครงการมีวิธีการดังนี้: IEnumerable<User> GetProjectUsers(int projectId); ตัวอย่างเช่นเมื่อเราต้องการแสดงผู้ใช้สำหรับโครงการบางอย่างเราสามารถเรียกGetProjectUsersและจะให้วัตถุกลับมาพร้อมข้อมูลที่เพียงพอที่จะแสดงใน DataGrid หรือคล้ายกัน ปัญหา: ตามหลักแล้วProjectsระบบย่อยไม่ควรเก็บข้อมูลผู้ใช้และควรเก็บรหัสผู้ใช้ที่เข้าร่วมในโครงการ ในการให้บริการGetProjectUsersจำเป็นต้องมีการเรียกGetUserใช้Usersระบบสำหรับแต่ละ id ผู้ใช้ที่เก็บไว้ในฐานข้อมูลของตัวเอง อย่างไรก็ตามสิ่งนี้ต้องการการGetUserเรียกที่แยกจากกันจำนวนมากทำให้เกิดคิวรี่ SQL แยกต่างหากมากมายภายในUserระบบย่อย ฉันไม่ได้ทดสอบสิ่งนี้จริงๆ แต่การมีการออกแบบช่างพูดนี้จะส่งผลกระทบต่อความสามารถในการขยายระบบ ถ้าฉันแยกระบบย่อยออกจากกันฉันสามารถเก็บข้อมูลทั้งหมดไว้ใน schema เดียวที่สามารถเข้าถึงได้โดยทั้งสองระบบและProjectsสามารถทำได้เพียงJOINเพื่อให้ผู้ใช้โครงการทั้งหมดได้รับแบบสอบถามเดียว Projectsจะต้องรู้วิธีการสร้างUserวัตถุจากผลการสืบค้นด้วย แต่นี่เป็นการแยกการแยกซึ่งมีข้อดีหลายประการ คำถาม: ทุกคนสามารถแนะนำวิธีการแยกออกจากกันในขณะที่หลีกเลี่ยงการGetUserโทรบุคคลเหล่านี้ในระหว่างGetProjectUsersหรือไม่ ตัวอย่างเช่นสิ่งหนึ่งที่ฉันคิดว่าเป็นสำหรับผู้ใช้ในการให้ความสามารถแก่ระบบภายนอกในการ "แท็ก" ผู้ใช้ที่มีคู่ค่าป้ายกำกับและเพื่อขอผู้ใช้ด้วยค่าที่แน่นอนเช่น: void AddUserTag(int userId, string tag, string value); IEnumerable<User> GetUsersByTag(string tag, …

10 c#  design  scalability  server-side 

ฉันมีวิธีการบางอย่างที่เปลี่ยนแปลงข้อมูลบางอย่างในฐานข้อมูล (แทรกอัปเดตและลบ) ออมฉันใช้การกลับมาแถวรับผลกระทบจากค่า int สำหรับประเภทของวิธีการเหล่านั้น ฉันควรกลับไปที่ "วิธีการของฉัน" เพื่อระบุสถานะความสำเร็จ / ความล้มเหลวของการดำเนินการอย่างไร พิจารณารหัสที่ส่งคืนint: A.1 public int myLowerLevelMethod(int id) { ... int affectedRows = myOrm.deleteById(id) ... return affectedRows; } การใช้งาน: A.2 public void myOtherMethod() { ... int affectedRows = myLowerLevelMethod(id) if(affectedRows > 0) { // Success } else { // Fail } } …

10 design  error-handling  methods 

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

10 design  design-patterns  architecture  packages  coupling 

ตามหลักการแบ่งแยกคำสั่งรวมถึงการคิดในข้อมูลและDDD ด้วยการนำเสนอClojureหนึ่งควรแยกผลข้างเคียง (แก้ไขโลก) จากการคำนวณและการตัดสินใจเพื่อให้ง่ายต่อการเข้าใจและทดสอบทั้งสองส่วน นี่เป็นคำถามที่ยังไม่ได้ตอบ: เราควรใส่ "ถามโลก" ที่ไหน ในอีกด้านหนึ่งการร้องขอข้อมูลจากระบบภายนอก (เช่นฐานข้อมูล, บริการนอกระบบ 'APIs และอื่น ๆ ) นั้นไม่ได้อ้างอิงอย่างโปร่งใสดังนั้นจึงไม่ควรใช้ร่วมกับการคำนวณและการตัดสินใจที่บริสุทธิ์ ในทางกลับกันมันเป็นปัญหาหรืออาจเป็นไปไม่ได้ที่จะหยอกล้อพวกเขานอกเหนือจากส่วนการคำนวณและส่งผ่านเป็นอาร์กิวเมนต์เนื่องจากเราอาจไม่ทราบล่วงหน้าว่าต้องการข้อมูลใด

10 functional-programming  domain-driven-design  clojure  design  side-effect