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

ดังนั้นในความพยายามของฉันในการเขียนโปรแกรมเพื่อผันคำกริยา (อัลกอริทึมไม่ใช่ผ่านชุดข้อมูล) สำหรับภาษาฝรั่งเศสฉันเจอปัญหาเล็กน้อย อัลกอริธึมที่จะผันคำกริยานั้นง่ายมากสำหรับกรณีของคำกริยา 17- หรือ - และในรูปแบบเฉพาะสำหรับแต่ละกรณี; ดังนั้นการผันคำต่อท้ายสำหรับ 17 ชั้นเรียนเหล่านี้เป็นแบบคงที่และจะ (ไม่น่าจะ) เปลี่ยนแปลงเร็ว ๆ นี้ ตัวอย่างเช่น: // Verbs #1 : (model: "chanter") terminations = { ind_imp: ["ais", "ais", "ait", "ions", "iez", "aient"], ind_pre: ["e", "es", "e", "ons", "ez", "ent"], ind_fut: ["erai", "eras", "era", "erons", "erez", "eront"], participle: ["é", "ant"] }; …

39 design  strings 

โปรแกรม CS ของโรงเรียนของฉันหลีกเลี่ยงการกล่าวถึงการเขียนโปรแกรมเชิงวัตถุดังนั้นฉันจึงต้องอ่านด้วยตัวเองเพื่อเสริม - โดยเฉพาะการสร้างซอฟต์แวร์เชิงวัตถุโดย Bertrand Meyer เมเยอร์ชี้ให้เห็นซ้ำ ๆ ว่าคลาสควรซ่อนข้อมูลเกี่ยวกับการนำไปปฏิบัติให้มากที่สุดเท่าที่จะทำได้ โดยเฉพาะเขาให้เหตุผลซ้ำ ๆ ว่าแอตทริบิวต์ (เช่นคุณสมบัติแบบคงที่และไม่คำนวณของคลาส) และรูทีน (คุณสมบัติของคลาสที่สอดคล้องกับการเรียกใช้ฟังก์ชัน / โพรซีเดอร์) ไม่สามารถแยกกันได้ ตัวอย่างเช่นถ้าคลาสPersonมีคุณสมบัติageเขายืนยันว่ามันเป็นไปไม่ได้ที่จะบอกจากสัญลักษณ์ไม่ว่าจะPerson.ageสอดคล้องภายในกับสิ่งที่ชอบreturn current_year - self.birth_dateหรือเรียบง่ายreturn self.ageที่self.ageได้รับการกำหนดเป็นแอตทริบิวต์คงที่ เรื่องนี้ทำให้รู้สึกถึงฉัน อย่างไรก็ตามเขายังคงเรียกร้องต่อไปนี้: เอกสารไคลเอนต์มาตรฐานสำหรับคลาสที่เรียกว่ารูปแบบสั้น ๆ ของคลาสจะถูกคิดขึ้นใหม่เพื่อไม่ให้เปิดเผยว่าคุณลักษณะที่กำหนดเป็นคุณลักษณะหรือฟังก์ชัน (ในกรณีที่อาจเป็นได้) กล่าวคือเขาอ้างว่าแม้แต่เอกสารสำหรับชั้นเรียนควรหลีกเลี่ยงการระบุว่า "ผู้เอา" ทำการคำนวณใด ๆ นี่ฉันไม่ทำตาม เอกสารไม่ใช่ที่เดียวที่ควรแจ้งให้ผู้ใช้ทราบถึงความแตกต่างนี้หรือไม่ ถ้าฉันต้องออกแบบฐานข้อมูลที่เต็มไปด้วยPersonวัตถุมันจะไม่สำคัญที่จะรู้ว่าPerson.ageการโทรที่มีราคาแพงหรือไม่ดังนั้นฉันจึงสามารถตัดสินใจได้ว่าจะใช้แคชบางประเภทหรือไม่ ฉันเข้าใจผิดในสิ่งที่เขาพูดหรือเขาเป็นเพียงตัวอย่างที่ยอดเยี่ยมที่สุดของปรัชญาการออกแบบ OOP หรือไม่?

39 design  object-oriented  documentation  performance 

ตัวอธิบาย 'Engine' ถูกโยนทิ้งไปมากมาย: เอ็นจิ้นกราฟิก, เครื่องยนต์ RegEx, AI engine ฯลฯ แต่จริงๆแล้วอะไรที่ทำให้ชิ้นส่วนของซอฟต์แวร์เป็น Engine? ออกแบบอินพุต / เอาต์พุตวัตถุประสงค์ขนาด?

39 design  terminology 

ถ้าฉันต้องการที่จะบันทึกและดึงวัตถุฉันควรสร้างคลาสอื่นเพื่อจัดการกับมันหรือมันจะดีกว่าที่จะทำในชั้นเรียนของตัวเอง? หรืออาจจะผสมทั้งสองอย่าง? ข้อเสนอแนะใดบ้างตามกระบวนทัศน์ของ OOD ตัวอย่างเช่น Class Student { public string Name {set; get;} .... public bool Save() { SqlConnection con = ... // Save the class in the db } public bool Retrieve() { // search the db for the student and fill the attributes } public List<Student> RetrieveAllStudents() { …

38 design  object-oriented 

เมื่อระบุวิธีตรรกะทางธุรกิจเพื่อรับเอนทิตีโดเมนพารามิเตอร์ควรยอมรับวัตถุหรือ ID หรือไม่ ตัวอย่างเช่นเราควรทำสิ่งนี้: public Foo GetItem(int id) {} หรือสิ่งนี้: public Foo GetItem(Foo foo) {} ฉันเชื่อในการส่งวัตถุไปรอบ ๆ อย่างครบถ้วน แต่สิ่งที่เกี่ยวกับกรณีนี้ที่เราได้รับวัตถุและเรารู้ ID เท่านั้น ผู้โทรควรสร้าง Foo ที่ว่างเปล่าและตั้ง ID หรือควรส่ง ID ไปที่เมธอด? เนื่องจาก Foo ที่เข้ามาจะว่างเปล่ายกเว้น ID ฉันไม่เห็นประโยชน์ของผู้โทรที่ต้องสร้าง Foo และตั้ง ID เมื่อมันสามารถส่ง ID ไปยังวิธี GetItem ()

38 c#  design  object-oriented  clean-code 

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

38 design  c++  namespace 

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

38 design  architecture  quality 

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

38 design 

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

37 design  development-methodologies  methodology 

มีรูปแบบการออกแบบที่เป็นไปได้สำหรับโปรแกรมเชิงวัตถุหรือไม่? ฉันถามนี้เพราะเมื่อเร็ว ๆ นี้ผมเห็นการดำเนินการระดับกับDoor Lockมันเป็นส่วนหนึ่งของการทดสอบและคำตอบบอกว่ารหัสเป็นไปตามรูปแบบวัตถุ Null: class Lock { public: virtual void close() = 0; virtual void open() = 0; virtual bool is_open() const = 0; virtual ~Lock() { } }; class DummyLock : public Lock { private: DummyLock(); DummyLock(const DummyLock&) = delete; DummyLock& operator=(const DummyLock&) = delete; private: void …

37 design  design-patterns  object-oriented  object-oriented-design 

ฉันเริ่มต้นอาชีพด้วยการเป็นนักพัฒนา. NET 3 เดือนที่ผ่านมาและหลังจากแผนการฝึกอบรมที่ยาวนานเกี่ยวกับเทคโนโลยีที่หลากหลายรูปแบบและแนวคิดที่นักพัฒนาที่ดูแลฉันได้ตัดสินใจว่าฉันพร้อมที่จะเข้าร่วมหนึ่งในหลาย ๆ โครงการที่ บริษัท จัดการ ฉันตื่นเต้นมากที่ในที่สุดสามารถเริ่มการเข้ารหัสได้ ทีมที่ฉันเข้าร่วมนั้นค่อนข้างเล็กเพราะตอนนี้เริ่มต้นด้วยโครงการใหม่ซึ่งดีมากเพราะฉันได้มีส่วนร่วมในวงจรชีวิตทั้งหมดของโครงการ มันเป็นโครงการสปาบนเว็บที่ได้รับการสนับสนุนที่ใช้ ASP.NET MVC / ASP.NET Web API และ Front-end เฟรมเวิร์ก Durandal และไลบรารีที่เกี่ยวข้อง ปัญหาของฉันคือหลังจากที่มีการประชุมกับเพื่อนร่วมงานของฉันและการกำหนดงานและการประเมินสำหรับเดือนถัดไปฉันพบว่าตัวเองอยู่ในตำแหน่งที่ฉันไม่รู้ว่าฉันสามารถทำงานใด ๆ ได้หรือไม่ ฉันไม่เคยทำงานที่สร้างขึ้นมาก่อนและฉันไม่รู้ว่าฉันควรดำเนินการอย่างไร ตัวอย่างหนึ่งในภารกิจที่สร้างขึ้นคือการสร้างกลไกการจัดการข้อผิดพลาดทั่วไปสำหรับแอปพลิเคชันทั้งหมด ปกติแล้วจะดำเนินการอย่างไรเมื่อเผชิญกับงานที่เขาไม่เคยทำ?

37 design  development-process  organization  junior-programmer  development-approach 

ฉันได้พัฒนาระบบที่เกิดขึ้นพร้อมกันมาหลายปีแล้วและฉันก็เข้าใจดีในเรื่องนี้แม้จะขาดการฝึกอบรมอย่างเป็นทางการ (เช่นไม่มีระดับ) มีภาษาใหม่ไม่กี่ภาษาที่ได้รับความนิยมอย่างน้อยพูดถึงเมื่อเร็ว ๆ นี้ซึ่งได้รับการออกแบบมาเพื่อทำให้การทำงานพร้อมกันง่ายขึ้นเช่น Erlang และ Go ดูเหมือนว่าวิธีการของพวกเขาในการทำงานพร้อมกันนั้นสะท้อนถึงประสบการณ์ของฉันเองว่าจะทำให้ระบบปรับขนาดได้และใช้ประโยชน์จากหลายคอร์ / โปรเซสเซอร์ / เครื่อง อย่างไรก็ตามฉันพบว่ามีเครื่องมือน้อยมากที่จะช่วยให้เห็นภาพสิ่งที่คุณตั้งใจจะทำและยืนยันว่าอย่างน้อยคุณก็ใกล้เคียงกับวิสัยทัศน์ดั้งเดิมของคุณ การดีบักโค้ดที่เกิดขึ้นพร้อมกันอาจเป็นฝันร้ายที่มีภาษาที่ไม่ได้ออกแบบมาสำหรับการทำงานพร้อมกัน (เช่น C / C ++, C #, Java, ฯลฯ ) โดยเฉพาะอย่างยิ่งมันเป็นไปไม่ได้ที่จะสร้างเงื่อนไขที่เกิดขึ้นใหม่ในระบบเดียวในสภาพแวดล้อมการพัฒนาของคุณ ดังนั้นอะไรคือแนวทางของคุณในการออกแบบระบบเพื่อจัดการกับการทำงานพร้อมกันและการประมวลผลแบบขนาน? ตัวอย่าง: คุณคิดได้อย่างไรว่าอะไรจะเกิดขึ้นพร้อมกันกับสิ่งที่ต้องเรียงตามลำดับ? คุณจะสร้างเงื่อนไขข้อผิดพลาดและดูว่าเกิดอะไรขึ้นเมื่อแอปพลิเคชันดำเนินการอย่างไร คุณเห็นภาพปฏิสัมพันธ์ระหว่างส่วนต่าง ๆ ที่เกิดขึ้นพร้อมกันของแอปพลิเคชันอย่างไร ฉันมีคำตอบของตัวเองสำหรับสิ่งเหล่านี้ แต่ฉันก็ต้องการที่จะเรียนรู้เพิ่มเติมอีกเล็กน้อย แก้ไข จนถึงตอนนี้เรามีข้อมูลที่ดีมากมาย บทความหลายบทความที่เชื่อมโยงนั้นดีมากและฉันได้อ่านมาแล้วบางส่วน ประสบการณ์ส่วนตัวของฉันกับการเขียนโปรแกรมพร้อมกันทำให้ฉันเชื่อว่าคุณต้องการความคิดที่แตกต่างจากการเขียนโปรแกรมตามลำดับ ความแตกแยกทางจิตใจนั้นกว้างพอ ๆ กับความแตกต่างระหว่างการเขียนโปรแกรมเชิงวัตถุและการโปรแกรมเชิงกระบวนวิธี ฉันต้องการชุดคำถามนี้เพื่อมุ่งเน้นที่กระบวนการคิดที่จำเป็น (เช่นทฤษฎี) เพื่อเข้าหาคำตอบอย่างเป็นระบบ เมื่อให้คำตอบที่เป็นรูปธรรมมากขึ้นมันจะช่วยยกตัวอย่าง - สิ่งที่คุณต้องผ่านเป็นการส่วนตัว เป้าหมายสำหรับค่าหัว อย่าบอกฉันว่าฉันควรทำอย่างไร …

37 design  debugging  parallelism  concurrency 

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

37 design 

เมื่อพูดถึง API ของ JSON เป็นวิธีปฏิบัติที่ดีในการแผ่การตอบสนองออกและหลีกเลี่ยงวัตถุ JSON ที่ซ้อนกันหรือไม่ ตัวอย่างเช่นสมมติว่าเรามี API คล้ายกับ IMDb แต่สำหรับวิดีโอเกม มีหน่วยงานคู่เกมแพลตฟอร์ม ESRBRating และ GamePlatformMap ซึ่งทำแผนที่เกมและแพลตฟอร์ม สมมติว่าคุณร้องขอ / เกม / 1 ซึ่งดึงข้อมูลเกมด้วย ID 1 และส่งคืนออบเจ็กต์เกมด้วยแพลตฟอร์มและการซ้อนทับซ้อน { "id": 1, "title": "Game A", "publisher": "Publisher ABC", "developer": "Developer DEF", "releaseDate": "2015-01-01", "platforms": [ {"id":1,"name":"Xbox"}, {"id":2,"name":"Playstation"} ], "esrbRating": { "id": 1, "code": …

37 design  rest  api-design  json 

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

36 web-development  design