ฉันจะจัดระเบียบแผนผังต้นกำเนิดของฉันได้อย่างไร

ฉันเป็นนักพัฒนารายบุคคลที่ทำงานเป็นส่วนใหญ่บนเว็บโปรเจ็กต์ (W / LAMP) และบางครั้งในโปรเจ็กต์ C / C ++ (ไม่ใช่ GUI) ที่ระดับเฉลี่ย

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

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

ฉันต้องการถาม:

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

เกี่ยวกับเงินรางวัล : ฉันซาบซึ้งกับคำตอบที่มีอยู่กับสมาชิกที่แบ่งปันแนวปฏิบัติของตัวเองอย่างไรก็ตามฉันต้องการสนับสนุนคำตอบทั่วไป (หรือแหล่งข้อมูล) และคำแนะนำเพิ่มเติมและการตอบสนองเพิ่มเติมจากสมาชิก

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

• presentation / webService (นำเสนอส่วนต่อประสานกับเว็บเซอร์วิสต่อตรรกะทางธุรกิจของเรา)
• ตรรกะ / * (โมดูลตรรกะทางธุรกิจเข้าที่นี่)
• storage / sql (API การจัดเก็บข้อมูลส่วนหลังที่นี่ - ใช้อินเตอร์เฟส SQL เพื่อเก็บไปยังฐานข้อมูล)
• util / * (รหัสยูทิลิตี้ - ใช้งานได้โดยเลเยอร์อื่น ๆ ทั้งหมด แต่ไม่ได้อ้างถึง util ภายนอกไปที่นี่)

โปรดทราบว่าเลเยอร์ไม่มีรหัสโดยตรง แต่จะใช้เพื่อจัดระเบียบโมดูล

ภายในโมดูลฉันใช้เลย์เอาต์เรียงลำดับต่อไปนี้:

• <module> (พา ธ ไปยังโมดูลโดยตรงกำหนดอินเทอร์เฟซแบบแยกส่วน)
• <module>/impl/<implName> (การใช้งานเฉพาะของส่วนต่อประสานโมดูลาร์)
• <module>/doc (เอกสารประกอบการใช้โมดูล)
• <module>/tb (รหัสการทดสอบหน่วยสำหรับโมดูล)

โดยที่<module>ตั้งอยู่ในพื้นที่เก็บข้อมูลตามชั้นที่มันเป็นของ

ฉันไม่สามารถให้คำแนะนำที่เกี่ยวข้องกับเว็บโปรเจ็กต์ได้มากนัก แต่นี่คือวิธีที่ฉันจัดโครงสร้างต้นไม้ของฉันในโครงการการเขียนโปรแกรม (ส่วนใหญ่มาจากมุมมอง C / C ++):

• /
  • src - ไฟล์ต้นฉบับที่เขียนด้วยตัวเอง
  • ext - มีห้องสมุดบุคคลที่สาม
    • libname-1.2.8
      • รวม - ส่วนหัว
      • lib - รวบรวมไฟล์ lib
      • Donwload.txt - มีลิงค์เพื่อดาวน์โหลดรุ่นที่ใช้
  • IDE - ฉันเก็บไฟล์โครงการไว้ที่นี่
    • vc10 - ฉันจัดเรียงไฟล์โครงการตาม IDE
  • bin - คอมไพล์ exe ไปที่นี่
  • build - ไฟล์ build ของคอมไพเลอร์
  • doc - เอกสารทุกชนิด
  • README
  • ติดตั้ง
  • คัดลอก

หมายเหตุเล็กน้อย:

1. ถ้าฉันกำลังเขียนไลบรารี (และฉันใช้ C / C ++) ฉันจะจัดระเบียบไฟล์ต้นฉบับของฉันเป็นอันดับแรกในสองโฟลเดอร์ที่เรียกว่า "รวม" และ "src" จากนั้นตามโมดูล หากเป็นแอปพลิเคชันฉันจะจัดระเบียบพวกเขาเพียงแค่โมดูล (ส่วนหัวและแหล่งที่มาจะอยู่ในโฟลเดอร์เดียวกัน)

2. ไฟล์และไดเรกทอรีที่ฉันระบุไว้ข้างต้นเป็นตัวเอียงฉันจะไม่เพิ่มไปยังที่เก็บรหัส

ในขณะที่Maven Standard Directory Layoutชนิดเฉพาะสำหรับ Java แต่อาจทำหน้าที่เป็นพื้นฐานที่ดีสำหรับโครงการประเภทอื่นเช่นกัน

นี่คือโครงสร้างพื้นฐาน (คุณสามารถแทนที่ไดเรกทอรี 'java' ด้วย 'php', 'cpp', ฯลฯ ):

src/main/java       Application/Library sources 
src/main/resources  Application/Library resources  
src/main/filters    Resource filter files 
src/main/assembly   Assembly descriptors 
src/main/config     Configuration files 
src/main/webapp     Web application sources 
src/test/java       Test sources 
src/test/resources  Test resources 
src/test/filters    Test resource filter files 
src/site            Site 
LICENSE.txt         Project's license 
NOTICE.txt          Notices and attributions required by libraries
README.txt          Project's readme

โครงสร้างแบ่งเป็น 'src / main' และ 'src / test' แล้วจัดกลุ่มตามประเภท

ฉันไม่รู้จริง ๆ เกี่ยวกับการประชุม แต่โครงการหลักทั้งหมดของฉันเสร็จสิ้นแล้วโดยใช้ Symfony Framework และฉันคุ้นเคยกับโครงสร้างของต้นไม้ดังนี้:

ราก/

• ปพลิเคชัน
• app_name
  • config (ไฟล์กำหนดค่าเฉพาะแอป)
  • lib (ไฟล์ php เฉพาะแอป)
  • โมดูล (การกระจายการทำงานของโมดูลาร์)
    • module_name
      • แม่แบบ (html)
      • การกระทำ (รหัส PHP)
• confing (ไฟล์กำหนดค่าโครงการ)
• lib (รหัส php ที่สามารถใช้ในโครงการรู)
• โมเดล (คลาสที่แสดงข้อมูลโครงการ)
  • ฐาน
• form (ไฟล์ php ที่จัดการแบบฟอร์มนี่อาจเป็นเรื่องยากที่จะประสบความสำเร็จโดยไม่ต้อง symfony)
  • ฐาน (คลาสฟอร์มฐาน)
• เว็บ
• CSS
  • ภาพ
  • file.css
• js
• log (ไฟล์บันทึกที่อาจสร้างขึ้น)
• data (ข้อมูลเฉพาะข้อมูลเช่น sql patches หรืออะไรก็ตาม)
• SQL
• ปลั๊กอิน (ไลบรารีที่ใช้ซึ่งสามารถผสานเข้ากับแอปของโครงการ)

หากคุณสนใจโปรดอ่านเอกสารSymfonyในเรื่องนี้เพื่อสอบถามเพิ่มเติม ( MVC และ Code Organization on Symfony )

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

...\products\
...\products\productName\
...\products\productName\doc\

...\systems\
...\systems\systemName\
...\systems\systemName\doc\
...\systems\systemName\res\
...\systems\systemName\build\
...\systems\systemName\test\

...\library\
...\library\libraryName\
...\library\libraryName\doc\
...\library\libraryName\build\
...\library\libraryName\test\

...\devops\

ผลิตภัณฑ์

หนึ่งโฟลเดอร์ต่อผลิตภัณฑ์ ช่วยสื่อสารว่าซอฟต์แวร์รองรับธุรกิจได้อย่างไร

ตามหลักการแล้ว "ผลิตภัณฑ์" แต่ละตัวจะมีขนาดเล็กกว่าไฟล์กำหนดค่าเพียงเล็กน้อยซึ่งบ่งชี้ว่าระบบใดที่จะเรียกใช้และจะกำหนดค่าอย่างไร โฟลเดอร์ย่อย doc อาจมีข้อมูลสรุปสั้น ๆ \ spec & วัสดุส่งเสริมการขายอื่น ๆ ...

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

ระบบ

หนึ่งโฟลเดอร์ต่อระบบ ช่วยสื่อสารความสามารถหลัก & โอกาส / คุณค่าของเนื้อหาของที่เก็บ

1. ไฟล์ "การจัดการการกำหนดค่า" ที่ระบุสภาพแวดล้อมการสร้างและการปรับใช้
2. การกำหนดค่าการทดสอบระดับระบบ (อาจเป็นปริมาณที่สำคัญ)
3. ตรรกะระดับสูงสุดและฟังก์ชั่น; การยกที่หนักที่สุดทำโดยฟังก์ชั่นห้องสมุด

ห้องสมุด

ส่วนประกอบที่นำมาใช้ซ้ำที่เรียกใช้โดยระบบต่าง ๆ กิจกรรมการพัฒนาส่วนใหญ่ถูกจัดระเบียบรอบการผลิตห้องสมุดแทนที่จะเป็นระบบดังนั้นการนำกลับมาใช้ซ้ำจะถูก "อบเข้า" ในกระบวนการพัฒนา

DevOps

สร้างบูรณาการอย่างต่อเนื่องและฟังก์ชั่นการพัฒนาระบบอัตโนมัติอื่น ๆ

ข้อสรุป

แผนผังต้นไม้เป็นเอกสารสำคัญชิ้นหนึ่งและกำหนดแนวทางโครงสร้างและจิตวิทยาของความสัมพันธ์ทางธุรกิจด้วยเทคโนโลยีที่เป็นกรรมสิทธิ์

ไดรเวอร์สำหรับวิธีนี้มีการอธิบายในเชิงลึกมากขึ้นในคำตอบของฉันสำหรับคำถามนี้: https://softwareengineering.stackexchange.com/questions/43733/who-organizes-your-matlab-code/59637#59637

สิ่งที่ฉันพยายามทำสำหรับแต่ละโครงการคล้ายกัน:

• src - ซอร์สไฟล์โฟลเดอร์สำหรับแต่ละเนมสเปซ / แพ็กเกจเพื่อเรียกค้นไฟล์ได้อย่างง่ายดาย (แม้แต่ไฟล์ส่วนหัวสำหรับ C / C ++)
• ext - สำหรับไลบรารีภายนอก / ไลบรารีของบุคคลที่สามมันเป็นเรื่องง่ายที่จะเพิ่ม externals (เช่นที่เก็บ SVN) ข้างในโฟลเดอร์สำหรับแต่ละไลบรารี (ไบนารีและรวมไฟล์)
• bin - สำหรับไบนารีที่สร้างขึ้นสามารถส่งออกได้อย่างรวดเร็วสำหรับการปล่อย
  • inc - สำหรับไฟล์ส่วนหัว C / C ++ (คัดลอกโดย IDE / makefile / ฯลฯ ... )
• out - สำหรับไฟล์ที่สร้างขึ้นชั่วคราวทั้งหมด (.class, .obj ฯลฯ ... ) และอาจถูกละเว้น (เช่น SVN)
• doc - สำหรับเอกสารใด ๆ มักจะสร้างด้วย Doxygen
• res - โดยการวางทรัพยากรที่นี่มันเป็นไปได้ที่จะแยกไฟล์ต้นฉบับข้อความและทรัพยากรไบนารีที่ใช้โดยโปรแกรม ฉันไม่ได้มีลำดับชั้นที่เฉพาะเจาะจงภายใน
  • config - สำหรับไฟล์การกำหนดค่าบางอย่าง
  • สามารถวาดได้ - สำหรับรูปภาพหรือไอคอน

ไฟล์หรือ makefiles ของ IDE ทั้งหมดจะถูกบันทึกโดยตรงที่รูทหากคุณใช้เพียงหนึ่งไฟล์เท่านั้น

ฉันทำอะไรแบบนี้ ทำงานได้ดีสำหรับเกมข้ามแพลตฟอร์มที่ฉันทำในเวลาว่าง น่าเสียดายในที่ทำงานมีการจัดระเบียบน้อยกว่ามาก ...

Output                      <-- Build outputs
Docs
External
   <libname>
      Include
      Lib
Data
<ProjectName>.xcodeproj
<ProjectName>VS2010
Source
Temp                        <-- Intermediate stuff from builds and other tools
Tools

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

/ ที่มา / ตัวแทน / ภาษา

/ ที่มา / ส่วนประกอบ / บุคคลที่สาม /

/ เอกสาร / ความต้องการ

/ เอกสาร / ออกแบบ

/ / ทดสอบอัตโนมัติ / หน่วย

/ / ทดสอบอัตโนมัติ / ToolName

/ / ทดสอบคู่มือการใช้งาน

สิ่งนี้ส่งผลให้มีการทำซ้ำโดยเฉพาะอย่างยิ่งภายใต้รหัสและห้องสมุดของบุคคลที่สาม แต่อย่างน้อยเราไม่เคยลืมคำตอบของบางอย่างเช่น "สิ่งที่ใช้ RogueWave Editor"

ผมชอบความคิดที่นำเสนอในหน้านี้www.javapractices.com/topic/TopicAction.do?Id=205 โดยทั่วไปคำแนะนำคือการจัดระเบียบโครงการของคุณเป็นคุณสมบัติ (หรือโมดูลส่วนประกอบ) นอกเหนือจากเหตุผลที่นำเสนอมี:

1. ภาระการรับรู้น้อยลงเมื่อคุณคิดเกี่ยวกับขอบเขตของรหัสที่คุณกำลังทำงานเนื่องจากคุณรับประกันได้ว่ารหัสใด ๆ ในคุณลักษณะที่คุณกำลังทำงานนั้นคือ "คุณสมบัติส่วนตัว"
2. มีความปลอดภัยเพิ่มเมื่อคุณได้รับการรับรองว่าคุณกำลังแก้ไขรหัสเพื่อรับคุณสมบัติเท่านั้น เช่นคุณจะไม่ทำลายสิ่งใดนอกจากคุณสมบัติที่คุณกำลังทำอยู่ อีกครั้งนี้เป็นเพราะ "คุณสมบัติส่วนตัว"
3. โหลดทางปัญญาน้อยลงง่ายเพราะมีไฟล์น้อยกว่าที่คุณสามารถดูสำหรับแพ็คเกจที่กำหนด ฉันแน่ใจว่าทุกคนเห็นแพ็คเกจที่มีไฟล์มากกว่า 15 ไฟล์

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

จนถึงตอนนี้โครงการที่ฉันเข้าร่วมไม่ได้ทำตามสิ่งเหล่านี้ มีสาเหตุหลายประการ แต่นี่คือบางส่วน:

1. ความเข้าใจผิดของตัวดัดแปลงการเข้าถึงเริ่มต้นของ Java (ตัวดัดแปลงการเข้าถึงที่เข้าใจผิดส่วนใหญ่ตามหนังสือเล่มนี้)
2. "Argumentum ad populum": การแลกเปลี่ยนวัฒนธรรมของแพ็คเกจโดยชั้น (อาจเกิดจากเหตุผล # 1)

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

"ตามที่นักออกแบบคนใดจะบอกคุณมันเป็นขั้นตอนแรกในกระบวนการออกแบบที่นับเป็นส่วนใหญ่จังหวะแรก ๆ ที่สร้างแบบฟอร์มถือเป็นชะตากรรมของส่วนที่เหลือ" - คริสโตเฟอร์เล็กซานเดอ

ขึ้นอยู่กับขนาดและความซับซ้อนของโครงการโอกาสที่พลาดไปในการลดต้นทุนหรือ ROI นั้นใหญ่มาก (ฉันสนใจที่จะดูการศึกษาเพื่อดูตัวเลขที่แน่นอนสำหรับสิ่งนี้)

คำแนะนำของฉันคือการดาวน์โหลดเฟรมเวิร์กหรือเอนจินต่าง ๆ และดูว่าทีมพัฒนาขนาดใหญ่จัดการโครงร่างโฟลเดอร์ของพวกเขาอย่างไร

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

คุณสามารถดาวน์โหลดเฟรมเวิร์ก Laravel, Symphony หรือ Codeigniter สำหรับโปรเจ็กต์เว็บเพื่อให้มีโครงร่างโฟลเดอร์ทันทีที่ใช้งานได้

ดังนั้นฉันจะพยายามที่จะถ่ายทอดรูปแบบโฟลเดอร์ร่วมกันเพื่อการพัฒนาใด ๆ :

MVC (Model View Controller) ให้กระบวนทัศน์ที่ดีขององค์กร

ซอร์สโค้ดรูตอาจเป็นsrc (C ++) หรือแอป (การพัฒนาเว็บ)

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

โครงสร้างโฟลเดอร์นี้ได้มาและง่ายจากLaravel กรอบ ความชอบของฉันในโพสต์นี้คือการตั้งชื่อพหูพจน์ แต่ฉันใช้คำเอกพจน์ในโครงการของฉัน

src / storage (โมเดล / ไฟล์ - ที่เก็บ / api / mysql / sql-lite / memcached / redis)

src / repositories (wrapper ของ 'การใช้งานพื้นที่เก็บข้อมูล' กับตรรกะหน่วยเก็บข้อมูลบางส่วน, อินเตอร์เฟสทั่วไปและแบบแผนผลลัพธ์ส่งคืน)

src / services | ตรรกะ | เอนทิตี (ตรรกะธุรกิจแอป)

src / controllers (ใช้ในการพัฒนาเว็บเพื่อขอเส้นทางเซิร์ฟเวอร์ไปยังบริการของคุณ)

src / modules | ระบบ ( ระบบโมดูลาร์ที่ขยายการทำงานทั่วไปของกรอบการทำงานของคุณบริการสามารถใช้โมดูล แต่ไม่รวมถึงระบบ)

src / helpers (ผู้ช่วยหรือคลาส wrapper เช่นการจัดการสตริงหลายครั้งนี้อาจเป็น libs | ผู้ขายเมื่อบุคคลที่สาม)

src / types (ตั้งชื่อ enums)

สาธารณะ | สร้าง | เอาต์พุต (เว็บหรือ c ++)

config (ไฟล์ติดตั้ง YAML กำลังเป็นที่นิยมสำหรับไฟล์กำหนดค่าข้ามแพลตฟอร์ม)

ขุมทรัพย์

บันทึก

lang (en / es / ru / ... )

bootstrap (เริ่มเฟรมเวิร์กและแอพ)

เอกสาร (เอกสารที่เขียนในรูปแบบ markdown .md)

การทดสอบ ( การทดสอบหน่วย)

ฐานข้อมูล / การย้ายข้อมูล (สร้างโครงสร้างฐานข้อมูลตั้งแต่ต้น)

ฐานข้อมูล / เมล็ด (เติมฐานข้อมูลของคุณด้วยข้อมูลจำลองเพื่อทดสอบ)

libs | ผู้ขาย (ซอฟต์แวร์บุคคลที่สามทั้งหมด 'libs' บน C ++ และ 'ผู้ขาย' โดยปกติจะเป็น php)

สินทรัพย์ | แหล่งข้อมูล (ภาพ / เสียง / สคริปต์ / json / สื่อใด ๆ )

ด้วยภาษาที่มุ่งเน้นวัตถุคุณมีความสามารถในการสร้างเนมสเปซ การแยกทางตรรกะนั้นใช้เพื่อแยกส่วนต่าง ๆ ของแอปพลิเคชันเพื่อหลีกเลี่ยงการเชื่อมต่อเป็นแหล่งที่มาหลักของการแยกตำแหน่งไฟล์โลจิคัล โดยใช้การมีเพศสัมพันธ์เป็นเหตุผลสำหรับการแตก namespaces เป็นสถานที่ที่ดีที่จะเริ่มต้นhttp://en.wikipedia.org/wiki/Software_package_metrics

คนอื่นพูดเกี่ยวกับการตั้งค่าโครงการที่เกี่ยวข้องกับการสร้าง แต่เมื่อคุณเข้าสู่แหล่งของตัวเองมันก็เป็นเรื่องที่สมเหตุสมผล