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

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

18 version-control  continuous-integration  builds  solo-development 

ฉันใช้ CMake เพื่อสร้างโครงการ IDE / makefiles ของฉัน แต่ฉันยังต้องเรียก "สคริปต์" แบบกำหนดเองเพื่อจัดการไฟล์ที่คอมไพล์ของฉันหรือแม้แต่สร้างรหัส ในโครงการก่อนหน้านี้ฉันใช้ Python และมันก็โอเค แต่ตอนนี้ฉันมีปัญหาร้ายแรงในการจัดการการพึ่งพาจำนวนมากในสองโครงการขนาดใหญ่มากที่ฉันทำงานอยู่ดังนั้นฉันจึงต้องการลดการพึ่งพาทุกที่ มีคนแนะนำฉันให้ใช้ C ++ เพื่อเขียนสคริปต์สร้างของฉันแทนที่จะเพิ่มการพึ่งพาภาษาสำหรับสิ่งนั้น ชุดรูปแบบโครงการใช้ C ++ อยู่แล้วดังนั้นจึงมีข้อดีหลายประการที่ฉันเห็น: ในการสร้างโครงการทั้งหมดจะต้องใช้คอมไพเลอร์ C ++ และ CMake เท่านั้นไม่มีสิ่งอื่นใด (การอ้างอิงอื่น ๆ ทั้งหมดคือ C หรือ C ++) ความปลอดภัยประเภท C ++ (เมื่อใช้ C ++ ที่ทันสมัย) ทำให้ทุกอย่างง่ายขึ้นเพื่อให้ "ถูกต้อง"; เป็นภาษาที่ฉันรู้จักดีกว่าดังนั้นฉันจึงสบายใจได้แม้ว่าฉันจะสามารถเขียนรหัส Python ได้ดีก็ตาม ความเป็นไปได้ที่จะได้รับความเร็วในการประมวลผล (แต่ฉันไม่คิดว่ามันจะเข้าใจได้จริง); อย่างไรก็ตามฉันคิดว่าอาจมีข้อเสียบางอย่างและฉันไม่แน่ใจเกี่ยวกับผลกระทบที่แท้จริงเนื่องจากฉันยังไม่ได้ลอง: …

15 c++  builds  cmake  build-system 

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

15 continuous-integration  automation  builds 

เราได้เปลี่ยนไฟล์คำสั่งแบทช์อย่างช้า ๆ (windows .bat) ซึ่งเป็นคลาสที่รวบรวมใน IDE สำหรับนักพัฒนาพร้อมกับ Ant builds ที่ครอบคลุมมากขึ้น (เช่นได้รับจาก CVS, คอมไพล์สะอาด, เก็บถาวร, อีเมล, ฯลฯ ) ฉันใช้เวลาเรียนรู้มากมาย (และแก้จุดบกพร่องปัญหา) กับ Ant ดังนั้นฉันจึงสบายใจที่จะใช้มันสำหรับงานเหล่านี้ แต่ฉันสงสัยว่ามดยังคงใช้งานได้อย่างกว้างขวางเหมือนเดิมเมื่อฉันเริ่มเรียนรู้หรือไม่ว่า "โลกได้ก้าวต่อไป" กับสิ่งใหม่กว่า (และอาจสั่นไหว) (ฉันเริ่มเห็น Maven build สิ่งของกระจายมากขึ้นซึ่งฉันไม่เคยใช้มาก่อน) การนำเข้าคำถามนี้จริง ๆ แล้วฉันจะผลักนักพัฒนาใหม่เพื่อเรียนรู้ Antหรือไม่หรือพวกเขาควรจะเรียนรู้สิ่งอื่นเพื่อการสร้างหรือไม่ ฉันไม่เคยอยู่บนแนวโน้มเช่นกันดังนั้นจึงเป็นเรื่องดีที่จะได้ยินจากนักพัฒนา Java คนอื่น ๆ สิ่งที่พวกเขาคิดว่าเป็นเครื่องมือสร้างที่ดีที่สุดและสิ่งที่พวกเขาคิดว่านักพัฒนาใหม่ควรเรียนรู้

14 java  training  maven  builds  ant 

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

14 tools  builds  automation 

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

13 open-source  builds  software-patches 

สิ่งหนึ่งที่ฉันต้องการทำกับรหัสของฉันคือการทำให้แน่ใจว่ามัน refactored เป็นชิ้นจัดการ อย่างไรก็ตามเมื่อมันมาถึงการสร้างซอฟต์แวร์ฉันพบว่าสิ่งที่สร้างซอฟต์แวร์อัตโนมัติที่ฉันใช้ (เมื่อเร็ว ๆ นี้มันเป็น GNU Make หรือ SCons) กลายเป็นความยุ่งเหยิงอย่างสมบูรณ์ ไฟล์อินพุตมีลักษณะเหมือนสคริปต์แบบยาวที่ดูเหมือนจะท้าทายการปรับโครงสร้างใหม่ได้ง่าย ฉันต้องการที่จะ refactor พวกเขาในทางใดทางหนึ่ง แต่แนวคิดของ "ฟังก์ชั่น" ไม่ได้ทำงานในลักษณะเดียวกันในซอฟต์แวร์สร้างอัตโนมัติบางอย่างเช่นในภาษาการเขียนโปรแกรมดังนั้นฉันคิดว่ามันยากที่จะเขียนจัดการได้ ไฟล์ Makefiles หรือ SConscript สำหรับโครงการใด ๆ ที่มีความซับซ้อนปานกลาง ไม่มีใครมีคำแนะนำในการเขียนไฟล์อินพุตที่สามารถจัดการได้สำหรับซอฟต์แวร์สร้างอัตโนมัติ คำแนะนำผู้ไม่เชื่อเรื่องพระเจ้าของซอฟต์แวร์จะดีที่สุด แต่แม้คำแนะนำเกี่ยวกับเครื่องมือสร้างอัตโนมัติเฉพาะจะมีประโยชน์โดยเฉพาะอย่างยิ่ง Make หรือ SCons เนื่องจากนั่นคือสิ่งที่ฉันใช้สำหรับโครงการ แก้ไข:ตามที่Thorbjørnชี้ให้เห็นฉันควรเพิ่มบริบทและตัวอย่างการใช้งาน ฉันจบปริญญาเอกสาขาวิศวกรรมเคมีและฉันค้นคว้าทางวิทยาศาสตร์การคำนวณ (ฉันเป็นนักเขียนมืออาชีพที่ SciComp.SE สำหรับผู้ที่เข้าชม) โดยทั่วไปโครงการของฉันเกี่ยวข้องกับภาษาที่รวบรวม (C, C ++, Fortran) ที่มีการยกระดับสูง, สคริปต์ภาษา (Python) , Perl) สำหรับการสร้างต้นแบบและบางครั้งภาษาเฉพาะโดเมนสำหรับการสร้างต้นแบบหรือวัตถุประสงค์ทางเทคนิค ฉันได้เพิ่มสองตัวอย่างด้านล่างโดยประมาณในช่วง …

13 refactoring  builds 

นี่เป็นโครงการเว็บที่เขียนด้วย Java ดังนั้นฉันจึงเขียน build และสคริปต์การปรับใช้ ในการสร้างงานสร้างฉันใช้มด การสร้างอย่างต่อเนื่องจะทำกับเจนกินส์ บิลด์สร้างสิ่งประดิษฐ์ 3 แบบที่แตกต่างกัน: ไฟล์สงคราม ซิปพร้อมโครงร่าง ซิปพร้อมรูปภาพ จนถึงตอนนี้ดีมาก แต่ตอนนี้ฉันต้องเขียนสคริปต์การปรับใช้ซึ่งควรจะ: ปรับใช้ war (ส่วนที่ 1) กับ tomcat ที่รันที่เซิร์ฟเวอร์ 1 วางส่วนที่2ที่เซิร์ฟเวอร์ 1ในไดเร็กทอรีเฉพาะ วางส่วนที่3ที่เซิร์ฟเวอร์ 2ในไดเร็กทอรีเฉพาะ ดังนั้นฉันจึงได้พูดคุยกับเพื่อนร่วมงานของฉันและเขาบอกว่าเราควรสร้างสิ่งประดิษฐ์ (บางทีdeploy.xml ) ที่ปรับใช้สิ่งประดิษฐ์เหล่านี้เมื่อวางไว้ที่เซิร์ฟเวอร์ที่ถูกต้อง ดังนั้นจะมีสคริปต์อื่นที่จะ: ดาวน์โหลดสิ่งประดิษฐ์เจนกินส์ scp ไปยังแต่ละเซิร์ฟเวอร์และวาง deploy.xml ที่นั่น เรียกใช้ deploy.xml แบบรีโมต สิ่งที่ทำให้ฉันรู้สึกไม่สบายใจเล็กน้อยคือการมี deploy.xml เป็นงานสร้าง แรงจูงใจที่อยู่เบื้องหลังสิ่งนี้จะทำให้สามารถปรับใช้โดยไม่จำเป็นต้องเข้าถึงคลังเก็บ VCS ดังนั้นงานสร้างจะต้องมีในตัวเองกล่าวคืองานสร้างใด ๆ ที่สามารถเข้าสู่การผลิตได้เฉพาะสิ่งที่เจนกินส์สร้างขึ้น ควรวางสคริปต์การปรับใช้ไว้ที่ใด พวกเขาควรจะเพียงที่ …

13 deployment  jenkins  builds 

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

13 project-management  version-control  development-process  documentation  builds 

วิธีแก้ปัญหาทั่วไปคือการสร้าง CI (การรวมอย่างต่อเนื่อง) ที่ทำงานบนบิลด์เซิร์ฟเวอร์: มันจะวิเคราะห์ซอร์สโค้ด, สร้างบิลด์ (ในการดีบัก) และรันการทดสอบ, ครอบคลุมการทดสอบวัด ฯลฯ ตอนนี้ชนิดบิลด์อื่นที่มักรู้จักกันคือ "บิลลี่ยามค่ำคืน": ทำสิ่งที่ช้าเช่นสร้างเอกสารรหัสสร้างแพ็คเกจการติดตั้งปรับใช้กับสภาพแวดล้อมการทดสอบและทำการทดสอบอัตโนมัติ (ควันหรือยอมรับ) กับสภาพแวดล้อมการทดสอบเป็นต้น ตอนนี้คำถาม: จะดีกว่าไหมถ้ามี "build build" แยกกันเป็นสามเป็น build build? หรือ "Nightly build" ในโหมด release และใช้เป็นรีลีส? คุณใช้อะไรใน บริษัท ของคุณ (บิลด์รีลีสควรเพิ่มแท็กบางชนิดให้กับแหล่งควบคุมของเวอร์ชันผลิตภัณฑ์ที่มีศักยภาพ)

13 builds  release  continuous-integration 

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

12 optimization  builds  front-end  angular2 

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

12 c  git  builds  build-system 

ฉันต้องการคำชี้แจงเกี่ยวกับความรับผิดชอบของ Build Script และ Build Server ฉันอ่านบทความหลายเรื่องบนอินเทอร์เน็ตเกี่ยวกับการรวมและสร้าง รวมไปถึง รหัส F5 ไม่ใช่กระบวนการสร้าง The Build Server: Heart Monitor ของโครงการของคุณ งานสร้างรายวันเป็นเพื่อนของคุณ และฉันได้สนทนากับที่ปรึกษาเกี่ยวกับกระบวนการสร้างซอฟต์แวร์ของเรา เพราะเขามีประสบการณ์มากฉันเชื่อในคำพูดของเขา แต่ฉันถูกทิ้งให้สับสน ตามที่ฉันเข้าใจจากการวิจัยของฉัน (และโปรดแก้ไขให้ฉันที่นี่ด้วยเนื่องจากเป็นสิ่งที่ฉันถาม) อุดมคติควรเป็นดังนี้: ทุกโครงการมีสคริปต์การสร้าง สคริปต์นี้สร้างโครงการ สคริปต์นี้ทำให้แน่ใจว่ามีการสร้างการอ้างอิงก่อนหน้านี้ เนื่องจากการขึ้นต่อกันอาจเป็นโครงการอื่น ๆ ด้วยสคริปต์การสร้างของตัวเองลำดับชั้นที่มีลักษณะคล้ายต้นไม้เพิ่มขึ้น อาจมีสคริปต์สร้างชั้นนำที่สร้างโครงการและแอปพลิเคชันทั้งหมด อย่างไรก็ตามความรับผิดชอบของ Build Server คือ: ตรวจสอบพื้นที่เก็บข้อมูล ทริกเกอร์การสร้าง การทดสอบทริกเกอร์และเครื่องมือ QA อื่น ๆ ทำให้สิ่งประดิษฐ์พร้อมใช้งาน สิ่งนี้อาจถูกทริกเกอร์ด้วยตนเองทุกคืนหรือทุกครั้งที่มีการเปลี่ยนแปลงที่เก็บ วัตถุประสงค์ของที่ปรึกษาของฉันคือตามที่ฉันเข้าใจพวกเขาว่าหนึ่งสคริปต์สร้างเป็นวิธีที่ยืดหยุ่นและไม่สามารถบำรุงรักษาได้ (นอกเหนือจากความจริงที่ว่ามันจะใช้เวลานานมากจากการสร้างหนึ่งสำหรับฐานรหัสดั้งเดิมของเรา) นอกจากนี้ Build Server ควรรักษาการอ้างอิงเช่นการใช้การอ้างอิงแบบเก่าเมื่อสร้างล้มเหลวใหม่ และโดยเฉพาะอย่างยิ่งสำหรับAntมันเป็นเรื่องที่เป็นรูปธรรมไม่สามารถสร้างเทคโนโลยีที่แตกต่างกันทุกชนิดที่ใช้ในรหัสฐานและไม่สามารถรักษาความไว้วางใจได้ …

12 version-control  continuous-integration  builds 

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

11 c++  builds  make 

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

11 c++  c  builds  dependency-management