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

ฉันต้องการเขียนแอปพลิเคชันเช่นอีคอมเมิร์ซ และคุณรู้ว่าในผลิตภัณฑ์แอปพลิเคชันที่คล้ายกันอาจมีคุณสมบัติและคุณสมบัติที่แตกต่างกัน เพื่อจำลองโอกาสดังกล่าวฉันได้สร้างเอนทิตีโมเดลโดเมนต่อไปนี้: หมวดหมู่ - นี่คือสิ่งที่ "อิเล็กทรอนิกส์> сomputers" เช่นประเภทของผลิตภัณฑ์ С Categories มีรายการคุณสมบัติ (รายการ <คุณสมบัติ>) คุณสมบัติ - หน่วยงานอิสระที่มีชื่อหน่วยการวัดประเภทข้อมูล ตัวอย่างเช่น "ชื่อ", "น้ำหนัก", "ขนาดหน้าจอ" คุณสมบัติเดียวกันสามารถมีผลิตภัณฑ์ที่แตกต่างกัน ผลิตภัณฑ์ - มีชื่อและรายการค่าที่เกี่ยวข้องกับคุณสมบัติ ค่าเป็นวัตถุที่มีเพียงฟิลด์ค่าและรหัสฟิลด์ของทรัพย์สิน ตอนแรกฉันตัดสินใจที่จะทำให้หมวดหมู่เป็นแบบรวมเดี่ยวในรูปแบบนี้เพราะตัวอย่างเช่นเมื่อฉันเพิ่มผลิตภัณฑ์ใหม่ฉันจำเป็นต้องทราบข้อมูลทั้งหมดที่เกี่ยวข้องกับหมวดหมู่ปัจจุบันรวมถึงคุณสมบัติที่เกี่ยวข้องกับหมวดหมู่ปัจจุบัน ( หมวดหมู่AddNewProduct (ผลิตภัณฑ์) ) แต่ฉันควรทำอย่างไรเมื่อฉันต้องเพิ่มคุณสมบัติใหม่ที่ไม่ได้อยู่ในหมวดหมู่ใด ๆ ตัวอย่างเช่นฉันไม่สามารถทำหมวดหมู่นี้ได้เพิ่มNewProperty (คุณสมบัติ)เพราะมันบอกอย่างชัดเจนว่าเราเพิ่มคุณสมบัติให้กับหมวดหมู่เฉพาะ ตกลงขั้นตอนถัดไปฉันตัดสินใจแยกคุณสมบัติเป็นการรวมแยกต่างหาก แต่จากนั้นจะเป็นรายการที่มีเอนทิตีง่าย แน่นอนฉันสามารถสร้างบางสิ่งบางอย่างเช่น PropertyAggregate เพื่อเก็บไว้ในรายการคุณสมบัติและกฎธุรกิจได้ แต่เมื่อฉันเพิ่มผลิตภัณฑ์ฉันต้องมีภายในหมวดหมู่รายการทั้งหมดของคุณสมบัติที่เป็นของหมวดนี้เพื่อตรวจสอบค่าคงที่ แต่ฉันก็ทราบด้วยว่าการเก็บลิงค์ภายในผลรวมของมวลรวมอื่นนั้นเป็นวิธีที่ไม่ดี ตัวเลือกในการออกแบบกรณีธุรกิจนี้มีอะไรบ้าง

10 domain-driven-design  entity  aggregate 

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

10 architecture  server  backend 

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

10 java  patterns-and-practices  versioning  project-structure  dependencies 

ขณะนี้ฉันกำลังอ่านและทำงานผ่าน "รหัสสะอาด: หนังสือฝีมือซอฟต์แวร์เปรียว" โดย Robert C. Martin ผู้เขียนพูดถึงว่าฟังก์ชั่นควรทำสิ่งใดสิ่งหนึ่งเท่านั้นจึงค่อนข้างสั้น มาร์ตินเขียน: นี่ก็หมายความว่าบล็อกภายในถ้าคำสั่งคำสั่งอื่นในขณะที่คำสั่งและอื่น ๆ ควรมีความยาวหนึ่งบรรทัด อาจเป็นไปได้ว่าสายควรจะเรียกฟังก์ชั่น สิ่งนี้ไม่เพียงทำให้ฟังก์ชั่นการปิดล้อมมีขนาดเล็ก แต่ยังเพิ่มมูลค่าเอกสารเพราะฟังก์ชั่นที่เรียกว่าภายในบล็อกสามารถมีชื่อที่สื่อความหมายได้ดี นี่ก็หมายความว่าหน้าที่ไม่ควรใหญ่พอที่จะเก็บโครงสร้างที่ซ้อนกัน ดังนั้นระดับเยื้องของฟังก์ชันไม่ควรมากกว่าหนึ่งหรือสอง แน่นอนสิ่งนี้ทำให้ฟังก์ชั่นการอ่านและทำความเข้าใจง่ายขึ้น มันสมเหตุสมผล แต่ดูเหมือนขัดแย้งกับตัวอย่างของสิ่งที่ฉันเห็นว่าเป็นโค้ดที่สะอาด ใช้วิธีการต่อไปนี้เช่น: public static boolean millerRabinPrimeTest(final int n) { final int nMinus1 = n - 1; final int s = Integer.numberOfTrailingZeros(nMinus1); final int r = nMinus1 >> s; //r must be …

10 clean-code 

ฉันกำลังติดตามคำถามนี้แต่ฉันเปลี่ยนโฟกัสจากโค้ดเป็นหลักการ จากความเข้าใจของฉันเกี่ยวกับหลักการทดแทน Liskov (LSP) ไม่ว่าวิธีการใดที่อยู่ในคลาสพื้นฐานของฉันพวกเขาจะต้องดำเนินการในคลาสย่อยของฉันและตามหน้านี้หากคุณแทนที่วิธีในคลาสพื้นฐานและไม่ทำอะไรเลย คุณกำลังละเมิดหลักการ ตอนนี้ปัญหาของฉันสามารถสรุปได้เช่นนี้ฉันมีนามธรรมWeapon classและสองชั้นและSword ReloadableหากReloadableมีข้อมูลเฉพาะที่methodเรียกว่าReload()ฉันจะต้องลดความเร็วเพื่อเข้าถึงmethodและถ้าคุณต้องการหลีกเลี่ยงปัญหานั้น Strategy Patternจากนั้นผมก็คิดของการใช้ วิธีนี้แต่ละอาวุธเป็นเพียงตระหนักถึงการกระทำที่มีความสามารถในการดำเนินการดังนั้นสำหรับตัวอย่างเช่นReloadableอาวุธอย่างเห็นได้ชัดสามารถโหลด แต่ไม่สามารถและไม่ได้ตระหนักถึงSword Reload class/methodตามที่ระบุไว้ในโพสต์ Stack Overflow ของฉันฉันไม่จำเป็นต้องลดความเร็วและฉันสามารถเก็บList<Weapon>สะสม ในฟอรัมอื่นคำตอบแรกที่แนะนำเพื่อให้SwordระวังReloadเพียงไม่ทำอะไรเลย ได้รับคำตอบเดียวกันนี้ในหน้า Stack Overflow ที่ฉันลิงค์ไปด้านบน ฉันไม่เข้าใจว่าทำไม ทำไมการละเมิดหลักการและอนุญาตให้ Sword ต้องระวังReloadและปล่อยให้มันว่างเปล่า อย่างที่ฉันบอกไว้ในโพสต์ Stack Overflow SP จะแก้ปัญหาของฉันได้ค่อนข้างมาก ทำไมมันไม่เป็นทางออกที่ทำงานได้? public final Weapon{ private final String name; private final int damage; private final List<AttackStrategy> validactions; private final …

10 java  design-patterns  inheritance 

ฉันมีปัญหาในการทำความเข้าใจว่าทำไมคุณควรพัฒนาไลบรารีภายในเพื่อใช้สำหรับการพัฒนาแอปพลิเคชันภายในโดยเฉพาะ ฉันขอขอบคุณที่ถ้าฉันต้องการใช้ซอฟต์แวร์ที่บุคคลภายนอกองค์กรเขียนขึ้นพวกเขาสามารถส่งไฟล์ส่วนหัวและไฟล์. a หรือ. so และฉันสามารถลิงก์ไปยังโครงการของฉันได้ (สมมติว่าพวกเขารวบรวมในสภาพแวดล้อมเดียวกัน) . แต่ทำไมห้องสมุดภายในควรได้รับการพัฒนาเพียงเพื่อเชื่อมโยงกับแอปพลิเคชันภายในเมื่อฉันเข้าถึงส่วนหัวและไฟล์การใช้งานและสามารถรวมไว้ในแผนภูมิแหล่งที่มาของฉันและรวบรวมทั้งหมดเข้าด้วยกันได้ กล่าวอีกนัยหนึ่ง: ถ้ามีการเขียนซอร์สโค้ดคุณจะตัดสินใจได้อย่างไรว่าควรจะคอมไพล์ลงในไลบรารีไบนารีและเชื่อมโยงกับแอปพลิเคชันของคุณหรือรวมอยู่ในไฟล์ต้นฉบับของโครงการและคอมไพล์อย่างสม่ำเสมอ? เมื่อฉันพูดว่าไฟล์ 'รวม' ในแต่ละโครงการฉันไม่ได้หมายถึงการคัดลอกและวางแต่ละไฟล์ลงในแผนผังแหล่งที่มาของโครงการที่กำลังพัฒนา ฉันหมายถึงการพัฒนาไดเรกทอรี / ไลบรารี (แยกเป็นโครงการใด ๆ ) ที่มีซอร์สโค้ดร่วมที่สามารถรวมอยู่ในไฟล์ของโครงการได้ตามปกติคือ #include ps ฉันกำลังพูดถึงการพัฒนา c / c ++ ที่นี่สำหรับแอปพลิเคชันเดสก์ท็อปหลาย ๆ ตัว

10 libraries 

เราสร้างห้องสมุดเชิงพาณิชย์และตัวอย่างรหัสที่ผู้พัฒนาภายนอกใช้ เรามีเอกสาร (ปิดให้บริการสำหรับผู้ใช้ที่ลงทะเบียน) ซึ่งอธิบายวิธีการใช้ห้องสมุดอย่างกว้างขวาง นักพัฒนาหลายคนเป็นผู้ใช้ครั้งแรกดังนั้นจึงพบข้อผิดพลาดพื้นฐานมากมาย เหมาะสมหรือไม่ที่จะรวมลิงค์ไปยังเอกสารในบันทึกข้อผิดพลาด? ข้อเสียที่เป็นไปได้คืออะไร? ฉันสามารถคาดการณ์บางอย่าง แต่มันเป็นไปได้ที่จะเอาชนะต่อไปนี้ URL เอกสารคู่มือล้าสมัย ข้อผิดพลาดเฉพาะรุ่นที่ไม่ปรากฏในเอกสารล่าสุด มีบางอย่างผิดปกติและเรากำลังเสียเวลาของผู้พัฒนาโดยส่งเขาไปยังเอกสารที่ไม่เกี่ยวข้อง ด้านล่างเป็นตัวอย่างของสิ่งที่ฉันหมายถึงมันเป็นความคิดที่ดีที่จะเพิ่มข้อความหนา? [ข้อผิดพลาด] ล้มเหลวในการดำเนินการเป้าหมาย org.apache.maven.plugins: maven-archetype-plugin: 1.2.3: สร้าง (default-cli) ในโครงการ standalone-pom: archetype ที่ต้องการไม่มีอยู่ (com.example.library ต้นแบบ: library-archetype-blank: 1.2.3.0) -> โปรดดูhttp://example.com/docs/setting-up-an-archetypeสำหรับข้อมูลเพิ่มเติมและการแก้ไขปัญหาที่เป็นไปได้

10 documentation  api-design  error-handling  error-messages 

ฉันได้รับรหัสอันยิ่งใหญ่ที่ฉันได้รวมตัวอย่างสั้น ๆ ของด้านล่าง มีชื่อสำหรับรูปแบบการต่อต้านนี้โดยเฉพาะหรือไม่? มีคำแนะนำอะไรบ้างสำหรับการปรับโครงสร้างนี้ // 0=Need to log in / present username and password // 2=Already logged in // 3=Inactive User found // 4=Valid User found-establish their session // 5=Valid User found with password change needed-establish their session // 6=Invalid User based on app login // 7=Invalid User based …

10 coding-style  code-quality  coding-standards  code-reviews  code-smell 

เนื่องจากหลักการแยกอินเทอร์เฟซแนะนำว่าลูกค้าไม่ควรถูกบังคับให้ขึ้นอยู่กับวิธีการที่ไม่ได้ใช้ดังนั้นลูกค้าไม่ควรใช้วิธีการที่ว่างเปล่าสำหรับวิธีการอินเทอร์เฟซมิฉะนั้นวิธีการอินเทอร์เฟซนี้ แต่วิธีการที่เป็นรูปธรรม? ฉันควรแยกวิธีการที่ลูกค้าไม่ทุกคนจะใช้หรือไม่ พิจารณาคลาสต่อไปนี้: public class Car{ .... public boolean isQualityPass(){ ... } public int getTax(){ ... } public int getCost(){ ... } } public class CarShop{ ... public int getCarPrice(int carId){ Car car=carList[carId]; int price=car.getTax() + car.getCost()... (some formula); return price; } } ที่โค้ดด้านบน CarShop ไม่ได้ใช้วิธี isQualityPass () ใน …

10 object-oriented  solid 

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

10 distributed-computing  cqrs  event-sourcing 

หลังจากรหัสคาวบอยมาหลายปีฉันตัดสินใจที่จะรับหนังสือเกี่ยวกับวิธีการเขียนโค้ดคุณภาพดี ฉันอ่าน Clean Code ของ Robert Cecil Martin ในบทที่ 3 (ฟังก์ชั่น) มีส่วนในฟังก์ชั่น dyadic นี่คือข้อความที่ตัดตอนมาจากหนังสือ แม้กระทั่งฟังก์ชั่น dyadic ที่เห็นได้ชัดassertEquals(expected, actual)ก็เป็นปัญหา คุณใส่ของจริงกี่ครั้งที่คาดว่าควรจะเป็น? ข้อโต้แย้งทั้งสองไม่มีการเรียงลำดับแบบเป็นธรรมชาติ การจัดลำดับที่คาดหวังและเกิดขึ้นจริงเป็นแบบแผนที่ต้องฝึกปฏิบัติเพื่อเรียนรู้ ผู้เขียนทำให้เป็นจุดที่น่าสนใจ ฉันทำงานในการเรียนรู้ของเครื่องและเจอสิ่งนี้ตลอดเวลา ตัวอย่างเช่นฟังก์ชันเมทริกทั้งหมดในไลบรารี sklearn (อาจเป็นไพ ธ อนไลบรารีที่ใช้มากที่สุดในฟิลด์) กำหนดให้คุณต้องระวังลำดับของอินพุต ในฐานะที่เป็นตัวอย่างsklearn.metrics.homogeneity_scoreจะเป็นปัจจัยการผลิตและlabels_true labels_predฟังก์ชั่นนี้ไม่เกี่ยวข้องมากเกินไปสิ่งที่เกี่ยวข้องก็คือถ้าคุณสลับลำดับของอินพุตจะไม่มีข้อผิดพลาดเกิดขึ้น ในความเป็นจริงการเปลี่ยนอินพุตนั้นเทียบเท่ากับการใช้ฟังก์ชันอื่นในไลบรารี assertEqualsแต่หนังสือเล่มนี้ไม่ได้ไปกล่าวต่อไปว่าการแก้ไขที่เหมาะสมสำหรับการทำงานเช่น ฉันไม่สามารถนึกถึงการแก้ไขสำหรับassertEqualsหรือฟังก์ชั่นที่ฉันมักจะเจออย่างที่อธิบายไว้ข้างต้น แนวปฏิบัติที่ดีในการแก้ไขปัญหานี้คืออะไร

10 functions 

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

10 design  object-oriented 

ปิด คำถามนี้ต้องการรายละเอียดหรือความคมชัด ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ เพิ่มรายละเอียดและชี้แจงปัญหาโดยแก้ไขโพสต์นี้ ปิดให้บริการใน2 ปีที่ผ่านมา ทำไมบางคนถึงพัฒนาภาษาของตัวเองเพื่อใช้ภายใน บริษัท นั้นเมื่อคุณมีภาษาอื่น ๆ ของ XY ที่สามารถช่วยคุณในการใช้ห้องสมุด, ตรรกะและอื่น ๆ ได้? มันง่ายกว่าหรือไม่ที่จะไปกับสิ่งอื่น ๆ แทนที่จะพัฒนาภาษาของคุณเอง?

10 programming-languages 

ฉันมีคำถามง่าย ๆ ที่หลอกหลอนฉันซักพักเมื่อรหัสของฉันเริ่มขึ้น พารามิเตอร์ควรถูกแทนที่ด้วยตัวแปรโกลบอลเมื่อพวกเขาผ่านเส้นทางยาวของการเรียกฟังก์ชันที่ซ้อนกัน? ฉันเข้าใจว่าสภาพแวดล้อมทั่วโลกสามารถทำให้สถานะของโปรแกรมไม่สามารถคาดเดาได้เพราะฟังก์ชั่นหลายอย่างสามารถปรับเปลี่ยนตัวแปรที่แชร์ได้ แต่ถึงกระนั้นโลกก็ยังทำให้สิ่งต่าง ๆ ง่ายขึ้น ให้ฉันอธิบายตัวเอง: functionA(){ x = something functionB(x) } functionB(x){ functionC(x) } functionC(x){ finallyDoSomethingWithX(x) } finallyDoSomethingWithX(x){ x += 1 //Very dummy example ignoring pass by value, not reference. } แทนที่โดย: globalX; functionA(){ globalX = something functionB() } ... ... ... finallyDoSomethingWithX(){ globalX += 1 …

10 parameters  globals 

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

10 architecture  documentation