วิศวกรรมซอฟต์แวร์

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

10 team  team-leader  project-planning 

ฉันมีรถยนต์มากมายในแอปพลิเคชัน C ++ ของฉันซึ่งบรรจุอยู่ภายใน RaceTrack รถแต่ละคันประกอบด้วยชิ้นส่วนหลายร้อยชิ้น แต่ละส่วนขึ้นอยู่กับส่วนอื่น ๆ หรือสอง ฉันได้อ่านคำถามมากมายเกี่ยวกับ DI และหนังสือของ Mark Seemann และดูเหมือนว่าฉันไม่ควรกำหนดคลาสรถยนต์เพื่อเก็บชิ้นส่วนรถยนต์เพราะชิ้นส่วนรถยนต์ทั้งหมดจะขึ้นอยู่กับแต่ละชิ้นและชิ้นส่วนซุปนี้เป็นรถยนต์ ฉันถูกไหม? ดังนั้นเมื่อฉันวางรถแข่งทั้งหมดของฉันลงใน RaceTrack จะไม่มีเอนทิตีของรถยนต์ แต่มีชิ้นส่วนรถยนต์มากมายขึ้นอยู่กับการแข่งรถในแต่ละแทร็ค? ฉันถูกไหม? แก้ไข: สำหรับทุกวัยที่ฉันเขียนโปรแกรมคลาสรถยนต์เพราะเห็นได้ชัดว่าฉันต้องการคลาสรถยนต์หากฉันเขียนโปรแกรมตรรกะรถ แต่ด้วย DI มันไม่ชัดเจนสำหรับฉัน ยังสงสัยว่ามันเป็นสำนวนที่ DI จะไม่สร้างคลาสรถถ้าฉันไม่มีบทบาทที่กำหนดไว้หรือไม่? ฉันหมายความว่ามันโอเคที่จะมีพวงมาลัยล้อเลื่อนสำหรับการขับขี่ BoltsAndNuts บนล้อสำหรับลูกเรือหลุมและอินเทอร์เฟซตลกอื่น ๆ ทุกประเภทโดยไม่ต้องมีอินสแตนซ์ที่แสดงถึงรถยนต์โดยรวมหรือไม่?

10 c++  dependency-injection 

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

10 algorithms  collections 

ต่อสู้คู่มือกำหนดหน่วยเดียวที่ประกอบด้วยเจ้าของสินค้า, ทีมพัฒนา 3-9 สมาชิกและ 1 ต่อสู้โทหาที่ไหนสักแห่งระหว่างวันที่ 5 และ 11 สมาชิก ฉันเคยเห็นอินสแตนซ์ที่เจ้าของผลิตภัณฑ์อาจมีเจ้าหน้าที่สนับสนุนหรือทีมอาจไม่มี Scrum Master ที่เฉพาะเจาะจงในการเปลี่ยนแปลงจำนวนเล็กน้อย แต่ดูเหมือนว่าจะมีผู้เข้าร่วมประมาณโหล Nexus คู่มืออธิบายวิธีการหนึ่งของการปรับการแย่งชิงกันเพื่อจับ 3-9 ทีมแย่งชิงกันทำงานในผลิตภัณฑ์เดียว มันเพิ่มทีมบูรณาการ Nexus ใหม่ซึ่งอาจเป็นสมาชิกที่ทุ่มเทหรืออาจประกอบด้วยคนจากทีมการต่อสู้ต่าง ๆ จากคำแนะนำนั้นจะมีขนาดประมาณ 20-120 คน วินัยเปรียวสามารถเพิ่มขนาดจากทีมหนึ่งไปยังทีม N ขนาดทีมมาตรฐานแต่ละคนจะมีขนาดใกล้เคียงกับใน Scrum - สมาชิก 3-9 คนพร้อมด้วยบทบาทสนับสนุนจากผู้เชี่ยวชาญหลากหลายทีมทดสอบอิสระผู้เชี่ยวชาญโดเมน ฯลฯ ข้อควรพิจารณาในกรอบนี้ไม่ได้เป็นการปรับขนาด แต่ใช้วิธีการแบบเปรียว ในองค์กรขนาดใหญ่สภาพแวดล้อมที่มีการควบคุมด้วยการปฏิบัติตามข้อบังคับที่ได้รับมอบหมายการจ้างพนักงานที่กระจายอยู่ทั่วโลก ดูเหมือนว่าขีด จำกัด คือคุณจะมีหนึ่งอินสแตนซ์ของ DA ต่อผลิตภัณฑ์หรือสายผลิตภัณฑ์ ในระดับที่แตกต่างกันฉันมีส่วนร่วมในการทำงานหรือดำเนินการตามกระบวนการโดยใช้ Scrum, Nexus และ DAD ดังนั้นฉันจึงมีความเข้าใจอย่างถ่องแท้ ฉันไม่มีความรู้เกี่ยวกับการทำงานของ …

10 agile  large-scale-scrum  scaled-agile-framework 

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

10 database  web-services  nosql  angular2 

เราควรสร้างรูทรวมใหม่ในสถาปัตยกรรม cqrs อย่างไร ในตัวอย่างนี้ฉันต้องการสร้างรากรวม AR2 ใหม่ที่เก็บการอ้างอิงถึงหนึ่ง AR1 ฉันกำลังสร้าง AR2 โดยใช้วิธี AR1 เป็นจุดเริ่มต้น จนถึงตอนนี้ฉันเห็นตัวเลือกน้อย: Inside method ใน AR1 createAr2RootOpt1ฉันสามารถโทรnew AR2()และบันทึกออบเจ็กต์นี้ไปยัง db imediatelly โดยใช้บริการโดเมนที่มีที่เก็บข้อมูล ฉันสามารถปล่อยเหตุการณ์ในรากรวมแรกเช่น SholdCreateAR2Eventและจากนั้นก็มีเทพนิยายไร้สัญชาติที่ตอบสนองต่อสิ่งนี้และออกคำสั่งCreateAR2Commandที่ได้รับการจัดการและสร้าง AR2 และปล่อยออกAR2CreatedEventมา ในกรณีของการใช้การจัดหาเหตุการณ์SholdCreateAR2Eventจะไม่ถูกเก็บไว้ในที่จัดเก็บกิจกรรมเนื่องจากจะไม่ส่งผลกระทบต่อสถานะของการรวมรากแรก (หรือเราควรบันทึกสิ่งนี้ไว้ในที่จัดเก็บกิจกรรม) class AR1{ Integer id; DomainService ds; //OPTION 1 void createAr2RootOpt1(){ AR2 ar2 = new AR2(); ds.saveToRepo(ar2); } //OPTION 2 void createAr2RootOpt2(){ publishEvent(new …

10 domain-driven-design  event-programming  cqrs  event-sourcing  entity 

หลังจากจัดการกับรูปแบบ async / คอยรูปของ C # ในขณะนี้ฉันก็ตระหนักว่าฉันไม่รู้วิธีอธิบายสิ่งที่เกิดขึ้นในรหัสต่อไปนี้: async void MyThread() { while (!_quit) { await GetWorkAsync(); } } GetWorkAsync()จะถือว่าคืนค่าTaskที่ไม่สามารถรอได้ซึ่งอาจหรือไม่อาจทำให้เกิดการสลับเธรดเมื่อดำเนินการต่อเนื่อง ฉันจะไม่สับสนถ้าการรอไม่ได้อยู่ในวง ฉันคาดหวังว่าส่วนที่เหลือของวิธี (เช่นความต่อเนื่อง) อาจจะดำเนินการในหัวข้ออื่นซึ่งเป็นเรื่องปกติ อย่างไรก็ตามในวงแนวคิดของ "ส่วนที่เหลือของวิธีการ" ทำให้ฉันมีหมอกเล็กน้อย จะเกิดอะไรขึ้นกับ "ส่วนที่เหลือของลูป" หากเธรดเปิดอยู่ต่อเนื่องกับหากไม่เปลี่ยน เธรดใดที่วนซ้ำครั้งถัดไปของลูปที่เรียกใช้งาน การสังเกตของฉันแสดง (ไม่ได้รับการตรวจสอบอย่างแน่ชัด) ว่าการวนซ้ำแต่ละครั้งเริ่มต้นในเธรดเดียวกัน (ฉบับดั้งเดิม) ในขณะที่การดำเนินการต่อเนื่องจะดำเนินการอีกครั้ง สิ่งนี้เป็นจริงได้ไหม ถ้าใช่นี่คือระดับของการขนานที่ไม่คาดคิดซึ่งจำเป็นต้องคำนึงถึงความปลอดภัยของเธรดแบบ vis-a-vis ของเมธอด GetWorkAsync หรือไม่? UPDATE: คำถามของฉันไม่เหมือนกันตามที่แนะนำโดยบางคน while (!_quit) { ... }รูปแบบรหัสเป็นเพียงความเรียบง่ายของรหัสที่เกิดขึ้นจริงของฉัน ในความเป็นจริงเธรดของฉันคือวนรอบที่ยาวนานซึ่งประมวลผลคิวอินพุตของไอเท็มงานในช่วงเวลาปกติ (ทุกๆ …

10 c#  loops  async 

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

10 domain-driven-design  event-sourcing 

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

10 java  inheritance  composition  metadata 

ฉันกำลังทำงานเพื่อแนะนำ React ใน บริษัท ที่ฉันทำงานด้วย ในฐานะที่เป็นหลักสูตรเดียวที่เรียนจบในหัวข้อฉันจะขอให้ใครตรวจสอบเพื่อให้แน่ใจว่ารหัสนั้นเป็นไปตาม 'แนวปฏิบัติที่ดีที่สุด' และมีการนำไปใช้อย่างถูกต้อง

10 code-reviews 

เมื่อเร็ว ๆ นี้ฉันได้ทดสอบขีด จำกัด ของสแต็คบนอุปกรณ์สามตัวที่มีระบบปฏิบัติการแตกต่างกัน (โดย จำกัด ฉันหมายถึงจำนวนสูงสุดของระดับที่สแต็กสามารถมีได้) และฉันสังเกตเห็นว่าทุกครั้งที่ฉันกดระดับ 2 ^ 16 ข้อผิดพลาดมากเกินไปและเมื่อฉันใส่ 2 ^ 16-1 มันทำงานได้อย่างถูกต้อง ดังนั้นคำถามของฉันคือ - จริงหรือ? สแต็กมีขีด จำกัด สูงสุด 2 ^ 16-1 ตามคำจำกัดความหรือขึ้นอยู่กับระบบปฏิบัติการ?

10 stack 

พื้นหลัง ฉันกำลังอ่าน "หนังสือรหัสสะอาด" และใน paralel ฉันกำลังทำงานกับวัตถุแบบคาลินิเทนิกกะตะเช่นบัญชีธนาคารและฉันติดอยู่กับกฎนั้น: กฎข้อที่ 9 ของวัตถุแบบคาลิสฟีนิกคือเราไม่ใช้ทะลุหรือเซ็ตเตอร์ ดูเหมือนจะสนุกมากและฉันเห็นด้วยกับหลักการนี้ ยิ่งไปกว่านั้นที่หน้า 98-99 ของ Clean Code ผู้เขียนอธิบายว่า getters / setters ทำลายสิ่งที่เป็นนามธรรมและเราไม่ต้องถามวัตถุของเรา แต่เราต้องบอกวัตถุของเรา มันทำให้รู้สึกที่สมบูรณ์แบบในใจของฉันและฉันเห็นด้วยกับหลักการนี้อย่างเต็มที่ ปัญหาเกิดขึ้นในทางปฏิบัติ บริบท ตัวอย่างเช่นฉันมีแอปพลิเคชันที่ฉันจะต้องแสดงรายชื่อผู้ใช้บางส่วนและเพื่อแสดงรายละเอียดผู้ใช้ ผู้ใช้ของฉันประกอบด้วย: -> Name --> Firstname --> String --> Lastname --> String -> PostalAddress --> Street --> String --> PostalCode --> String ปัญหา ฉันจะทำอย่างไรหรือฉันจะทำอย่างไรเพื่อหลีกเลี่ยง getters เมื่อฉันเพียงต้องการแสดงข้อมูลอย่างง่าย …

10 java  clean-code  software-craftsmanship 

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

10 development-process 

คำถามนี้มีคำตอบที่ยอดเยี่ยมโดย Eric Lippert อธิบายถึงกองที่ใช้ สำหรับปีที่ฉันรู้จัก - พูดโดยทั่วไป - สแต็คคืออะไรและใช้อย่างไร แต่บางส่วนของคำตอบของเขาทำให้ฉันสงสัยว่าโครงสร้างสแต็กนี้ใช้น้อยลงในวันนี้หรือไม่ซึ่งการเขียนโปรแกรม async เป็นบรรทัดฐาน จากคำตอบของเขา: สแต็คเป็นส่วนหนึ่งของการทำให้ใหม่ของความต่อเนื่องในภาษาโดยไม่ต้อง coroutines โดยเฉพาะอย่างยิ่งส่วนที่ไร้ coroutinesของนี้มีฉันสงสัย เขาอธิบายเพิ่มเติมอีกเล็กน้อยที่นี่: Coroutine เป็นฟังก์ชั่นที่จำได้ว่าอยู่ที่ไหนให้ผลการควบคุมไปยัง coroutine อีกระยะหนึ่งแล้วกลับมาทำงานต่อที่พวกมันทิ้งไว้ในภายหลัง แต่ไม่จำเป็นว่าจะต้องเกิดขึ้นทันทีหลังจาก coroutine ที่เพิ่งเรียกว่า คิดว่า "คืนผลตอบแทน" หรือ "รอ" ใน C # ซึ่งจะต้องจำไว้ว่าพวกเขาอยู่ที่ไหนเมื่อมีการร้องขอรายการถัดไปหรือการดำเนินการแบบอะซิงโครนัสเสร็จสมบูรณ์ ภาษาที่มี coroutines หรือฟีเจอร์ภาษาที่คล้ายกันนั้นต้องการโครงสร้างข้อมูลที่สูงกว่าสแต็กเพื่อที่จะใช้งานต่อเนื่อง นี่เป็นเรื่องที่ยอดเยี่ยมเกี่ยวกับสแต็ก แต่ทำให้ฉันมีคำถามที่ไม่ได้รับคำตอบเกี่ยวกับโครงสร้างที่ใช้เมื่อสแต็กนั้นง่ายเกินไปที่จะจัดการคุณสมบัติภาษาเหล่านี้ที่ต้องการโครงสร้างข้อมูลขั้นสูง? สแต็คจะหายไปเมื่อเทคโนโลยีก้าวหน้าไปหรือไม่? แทนที่มันคืออะไร มันเป็นลูกผสมหรือเปล่า (เช่นโปรแกรม. NET ของฉันจะใช้สแต็กจนกว่าจะถึงการเรียกใช้ async จากนั้นสลับไปยังโครงสร้างอื่น ๆ จนกว่าจะเสร็จสมบูรณ์ ณ จุดที่สแต็กนั้นกลับมาอยู่ในสถานะที่สามารถมั่นใจได้ในรายการถัดไป …

10 stack 

ฉันเล่นเกม 2v2 กับเพื่อน 12 คนเป็นประจำและฉันต้องการฐานข้อมูลเพื่อติดตามผู้เล่นทีมคะแนนและเกมด้วยความตั้งใจในการสร้างระบบการจัดอันดับ เนื่องจากเราเป็นประจำเปลี่ยนทีมที่ผมเคยเกิดขึ้นกับตารางplayers, teamsและgamesที่เกมมีสองทีม (TEAM1 และ TEAM2) และทีมประกอบด้วยผู้เล่นสองคน (PLAYER1 และ Player2) นี่ทำให้เกิดปัญหาค่อนข้างน้อย - ตัวอย่างเช่นถ้าฉันเลือกผู้เล่นสองคน (เรียกพวกเขาว่าAและB ) ให้เล่นด้วยกันฉันต้องตรวจสอบว่ามีทีมที่ Player1 คือ A และ Player2 คือ B หรือ Player1 คือ B และ Player2 คือ. คอลัมน์gamesและwinsมีอยู่ในทั้งplayersโต๊ะและteamsโต๊ะ - แต่นี่เป็นเพราะฉันต้องการดูว่ามีผู้เล่นกี่คนที่ชนะเกม แต่ยังรวมถึงความเข้ากันได้ของผู้เล่นในทีมที่แตกต่างกัน (ความถี่ที่ผู้เล่นชนะเมื่อเข้าร่วม ผู้เล่นเฉพาะรายอื่น) กระดานคะแนนการจัดอันดับ (ฉันอาจจะใช้ระบบการจัดอันดับ Elo ) หน้าสถิติสำหรับผู้เล่นทุกคนที่มีคะแนนชนะเกมสถิติเกมล่าสุดและผู้เล่นคนไหนที่เข้ากันได้มากที่สุด ฉันสงสัยอย่างยิ่งว่าสิ่งเหล่านี้ส่วนใหญ่ละเมิดหลักการบางอย่างในการปรับฐานข้อมูลให้เป็นมาตรฐาน

10 database  database-design